Logbuch-Kommandozeile

import {run} from './logbook.js';

// The data file comes from LOGBOOK_FILE (for example through --env-file), or logbook.json.
const file = process.env.LOGBOOK_FILE ?? 'logbook.json';
const result = await run(process.argv.slice(2), {file});
process.stdout.write(result.out);
process.stderr.write(result.err);
process.exitCode = result.code;

import {readFile, writeFile} from 'node:fs/promises';
import {parseArgs} from 'node:util';

export const USAGE = `Usage:
  node main.js add <text> [--tag <tag>]...
  node main.js list [--tag <tag>]
  node main.js export <file>`;

// Milestone 1: describe --tag (short -t, may be given more than once) for parseArgs.
const OPTIONS = {};

// Milestone 2 and 5: read and parse the JSON file. A missing file is an empty
// logbook only when missingOk is true; otherwise throw an Error with a clear message.
export async function load(file, {missingOk = false} = {}) {
  return [];
}

// Milestone 2: one line per entry, such as "1  2026-09-30  Went running  [sport]".
export function format(entry) {
  return '';
}

// Runs one command and returns {code, out, err} instead of printing.
// Milestones 1 to 5: parse args, then handle add, list and export.
export async function run(args, {file, now = () => new Date()}) {
  return {code: 0, out: '', err: ''};
}

{
  "type": "module"
}

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {spawnSync} from 'node:child_process';
import {mkdtempSync, readFileSync, writeFileSync, existsSync} from 'node:fs';
import {tmpdir} from 'node:os';
import {join} from 'node:path';
import {fileURLToPath} from 'node:url';
import {run} from './logbook.js';

// A fresh folder per test, and a fixed clock, so dates are predictable.
const folder = () => mkdtempSync(join(tmpdir(), 'logbook-'));
const now = () => new Date('2026-09-30T12:00:00Z');

test('Ein unbekannter Befehl gibt die Hilfe auf stderr aus und endet mit 2', async () => {
  const r = await run(['remove'], {file: join(folder(), 'log.json'), now});
  assert.equal(r.code, 2, `der Exit-Code war ${r.code}`);
  assert.match(r.err, /Usage:/, `stderr war ${JSON.stringify(r.err)}`);
  assert.equal(r.out, '', `stdout sollte leer bleiben, war aber ${JSON.stringify(r.out)}`);
});

test('Eine unbekannte Option meldet parseArgs, und das Programm endet mit 2', async () => {
  const r = await run(['list', '--colour'], {file: join(folder(), 'log.json'), now});
  assert.equal(r.code, 2, `der Exit-Code war ${r.code}`);
  assert.match(r.err, /--colour/, `stderr sollte die Option nennen, war aber ${JSON.stringify(r.err)}`);
});

test('add legt die Datei an und speichert den Eintrag mit seinen Schlagwörtern', async () => {
  const file = join(folder(), 'log.json');
  const r = await run(['add', 'Fixed the login bug', '--tag', 'work', '-t', 'bug'], {file, now});
  assert.equal(r.code, 0, `der Exit-Code war ${r.code}; stderr: ${r.err}`);
  assert.equal(r.out, 'Added entry 1.\n', `stdout war ${JSON.stringify(r.out)}`);
  const saved = JSON.parse(readFileSync(file, 'utf8'));
  assert.deepEqual(saved, [{id: 1, date: '2026-09-30', text: 'Fixed the login bug', tags: ['work', 'bug']}], `die Datei enthält ${JSON.stringify(saved)}`);
});

test('list gibt jeden Eintrag in einer eigenen Zeile aus, in der Reihenfolge des Hinzufügens', async () => {
  const file = join(folder(), 'log.json');
  await run(['add', 'Read the fs docs', '--tag', 'learn'], {file, now});
  await run(['add', 'Went running'], {file, now});
  const r = await run(['list'], {file, now});
  assert.equal(r.code, 0, `der Exit-Code war ${r.code}; stderr: ${r.err}`);
  assert.equal(r.out, '1  2026-09-30  Read the fs docs  [learn]\n2  2026-09-30  Went running\n', `stdout war ${JSON.stringify(r.out)}`);
});

test('list --tag zeigt nur die Einträge mit diesem Schlagwort', async () => {
  const file = join(folder(), 'log.json');
  await run(['add', 'Read the fs docs', '--tag', 'learn'], {file, now});
  await run(['add', 'Went running', '--tag', 'sport'], {file, now});
  const r = await run(['list', '--tag', 'sport'], {file, now});
  assert.equal(r.out, '2  2026-09-30  Went running  [sport]\n', `stdout war ${JSON.stringify(r.out)}`);
  const none = await run(['list', '--tag', 'music'], {file, now});
  assert.equal(none.out, 'No entries.\n', `ohne Treffer war stdout ${JSON.stringify(none.out)}`);
});

test('export schreibt jeden Eintrag in die genannte JSON-Datei', async () => {
  const dir = folder();
  const file = join(dir, 'log.json');
  await run(['add', 'First'], {file, now});
  await run(['add', 'Second', '--tag', 'x'], {file, now});
  const out = join(dir, 'out.json');
  const r = await run(['export', out], {file, now});
  assert.equal(r.code, 0, `der Exit-Code war ${r.code}; stderr: ${r.err}`);
  assert.equal(r.out, `Exported 2 entries to ${out}.\n`, `stdout war ${JSON.stringify(r.out)}`);
  assert.ok(existsSync(out), 'die Exportdatei wurde nicht geschrieben');
  const exported = JSON.parse(readFileSync(out, 'utf8'));
  assert.deepEqual(exported.map((e) => e.text), ['First', 'Second'], `der Export enthält ${JSON.stringify(exported)}`);
});

test('Eine beschädigte Datendatei ergibt eine klare Meldung auf stderr und Exit-Code 1', async () => {
  const file = join(folder(), 'log.json');
  writeFileSync(file, '[{"id": 1,');
  const r = await run(['list'], {file, now});
  assert.equal(r.code, 1, `der Exit-Code war ${r.code}`);
  assert.equal(r.err, `logbook: ${file} is not valid JSON\n`, `stderr war ${JSON.stringify(r.err)}`);
});

test('list ohne Datendatei ergibt eine klare Meldung und Exit-Code 1', async () => {
  const file = join(folder(), 'log.json');
  const r = await run(['list'], {file, now});
  assert.equal(r.code, 1, `der Exit-Code war ${r.code}`);
  assert.equal(r.err, `logbook: no logbook at ${file}; add an entry first\n`, `stderr war ${JSON.stringify(r.err)}`);
});

test('node main.js liest LOGBOOK_FILE und setzt den Exit-Code', () => {
  const dir = folder();
  const env = {...process.env, LOGBOOK_FILE: join(dir, 'log.json')};
  const main = fileURLToPath(new URL('./main.js', import.meta.url));
  const added = spawnSync(process.execPath, [main, 'add', 'From the shell'], {env, encoding: 'utf8'});
  assert.equal(added.status, 0, `add endete mit ${added.status}; stderr: ${added.stderr}`);
  assert.equal(added.stdout, 'Added entry 1.\n', `add gab ${JSON.stringify(added.stdout)} aus`);
  const bad = spawnSync(process.execPath, [main, 'dance'], {env, encoding: 'utf8'});
  assert.equal(bad.status, 2, `ein unbekannter Befehl endete mit ${bad.status}`);
  assert.equal(bad.stdout, '', `ein unbekannter Befehl gab ${JSON.stringify(bad.stdout)} auf stdout aus`);
});