291 lines
12 KiB
JavaScript
291 lines
12 KiB
JavaScript
import { test } from 'node:test';
|
|
import { strict as assert } from 'node:assert';
|
|
import { spawnSync } from 'node:child_process';
|
|
import { existsSync, mkdtempSync, rmSync } from 'node:fs';
|
|
import { tmpdir } from 'node:os';
|
|
import { dirname, join } from 'node:path';
|
|
import { fileURLToPath, pathToFileURL } from 'node:url';
|
|
import { parseArgs } from '../../lib/parsers/arg-parser.mjs';
|
|
import { childEnv } from '../helpers/child-env.mjs';
|
|
|
|
const PARSER = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'lib', 'parsers', 'arg-parser.mjs');
|
|
const PARSER_URL = pathToFileURL(PARSER).href;
|
|
|
|
test('trekbrief — empty args', () => {
|
|
const r = parseArgs('', 'trekbrief');
|
|
assert.equal(r.command, 'trekbrief');
|
|
assert.deepEqual(r.flags, {});
|
|
});
|
|
|
|
test('trekbrief — --quick boolean', () => {
|
|
const r = parseArgs('--quick', 'trekbrief');
|
|
assert.equal(r.flags['--quick'], true);
|
|
});
|
|
|
|
test('trekresearch — --project value capture', () => {
|
|
const r = parseArgs('--project .claude/projects/2026-04-30-foo', 'trekresearch');
|
|
assert.equal(r.flags['--project'], '.claude/projects/2026-04-30-foo');
|
|
});
|
|
|
|
test('trekresearch — --quick --local combined', () => {
|
|
const r = parseArgs('--quick --local', 'trekresearch');
|
|
assert.equal(r.flags['--quick'], true);
|
|
assert.equal(r.flags['--local'], true);
|
|
});
|
|
|
|
test('trekplan — --research multi-value', () => {
|
|
const r = parseArgs('--research a.md b.md c.md', 'trekplan');
|
|
assert.deepEqual(r.flags['--research'], ['a.md', 'b.md', 'c.md']);
|
|
});
|
|
|
|
test('trekplan — --research multi stops at next flag', () => {
|
|
const r = parseArgs('--research a.md b.md --project /x', 'trekplan');
|
|
assert.deepEqual(r.flags['--research'], ['a.md', 'b.md']);
|
|
assert.equal(r.flags['--project'], '/x');
|
|
});
|
|
|
|
test('trekplan — --brief required-value flag', () => {
|
|
const r = parseArgs('--brief brief.md', 'trekplan');
|
|
assert.equal(r.flags['--brief'], 'brief.md');
|
|
});
|
|
|
|
test('trekplan — missing value for --brief produces error', () => {
|
|
const r = parseArgs('--brief --quick', 'trekplan');
|
|
assert.ok(r.errors.find(e => e.code === 'ARG_MISSING_VALUE'));
|
|
});
|
|
|
|
test('trekplan — --decompose value flag', () => {
|
|
const r = parseArgs('--decompose plan.md', 'trekplan');
|
|
assert.equal(r.flags['--decompose'], 'plan.md');
|
|
});
|
|
|
|
test('trekexecute — --resume + --project', () => {
|
|
const r = parseArgs('--resume --project /tmp/p', 'trekexecute');
|
|
assert.equal(r.flags['--resume'], true);
|
|
assert.equal(r.flags['--project'], '/tmp/p');
|
|
});
|
|
|
|
test('trekexecute — --step N value', () => {
|
|
const r = parseArgs('--step 3', 'trekexecute');
|
|
assert.equal(r.flags['--step'], '3');
|
|
});
|
|
|
|
test('trekexecute — unknown flag goes to unknown[]', () => {
|
|
const r = parseArgs('--mystery foo', 'trekexecute');
|
|
assert.ok(r.unknown.includes('--mystery'));
|
|
});
|
|
|
|
test('quoted positional with spaces preserved', () => {
|
|
const r = parseArgs('"hello world" simple', 'trekbrief');
|
|
assert.deepEqual(r.positional, ['hello world', 'simple']);
|
|
});
|
|
|
|
test('unknown command reported as error', () => {
|
|
const r = parseArgs('--quick', 'notacommand');
|
|
assert.ok(r.errors.find(e => e.code === 'ARG_UNKNOWN_COMMAND'));
|
|
});
|
|
|
|
test('trekreview — --project value capture', () => {
|
|
const r = parseArgs('--project .claude/projects/2026-05-01-foo', 'trekreview');
|
|
assert.equal(r.flags['--project'], '.claude/projects/2026-05-01-foo');
|
|
});
|
|
|
|
test('trekreview — --since <ref> value', () => {
|
|
const r = parseArgs('--since HEAD~5', 'trekreview');
|
|
assert.equal(r.flags['--since'], 'HEAD~5');
|
|
});
|
|
|
|
test('trekreview — --quick + --validate combined', () => {
|
|
const r = parseArgs('--quick --validate', 'trekreview');
|
|
assert.equal(r.flags['--quick'], true);
|
|
assert.equal(r.flags['--validate'], true);
|
|
});
|
|
|
|
test('trekreview — unknown flag goes to unknown[]', () => {
|
|
const r = parseArgs('--mystery foo', 'trekreview');
|
|
assert.ok(r.unknown.includes('--mystery'));
|
|
});
|
|
|
|
// --- S11 (NW2 part B) — opt-in --workflow substrate flag ---
|
|
|
|
test('trekreview — --workflow boolean flag (NW2 opt-in substrate)', () => {
|
|
const r = parseArgs('--workflow', 'trekreview');
|
|
assert.equal(r.flags['--workflow'], true);
|
|
assert.ok(!r.unknown.includes('--workflow'),
|
|
'--workflow must be a recognized trekreview flag, not unknown[]');
|
|
});
|
|
|
|
test('trekreview — --workflow combines with --quick + --project', () => {
|
|
const r = parseArgs('--workflow --quick --project .claude/projects/x', 'trekreview');
|
|
assert.equal(r.flags['--workflow'], true);
|
|
assert.equal(r.flags['--quick'], true);
|
|
assert.equal(r.flags['--project'], '.claude/projects/x');
|
|
assert.deepEqual(r.unknown, []);
|
|
});
|
|
|
|
test('trekcontinue — empty args produce no flags and no positional', () => {
|
|
const r = parseArgs('', 'trekcontinue');
|
|
assert.equal(r.command, 'trekcontinue');
|
|
assert.deepEqual(r.flags, {});
|
|
assert.deepEqual(r.positional, []);
|
|
assert.deepEqual(r.errors, []);
|
|
});
|
|
|
|
test('trekcontinue — --help boolean flag', () => {
|
|
const r = parseArgs('--help', 'trekcontinue');
|
|
assert.equal(r.flags['--help'], true);
|
|
});
|
|
|
|
test('trekcontinue — -h treated as positional (no alias resolution)', () => {
|
|
const r = parseArgs('-h', 'trekcontinue');
|
|
assert.deepEqual(r.positional, ['-h']);
|
|
assert.deepEqual(r.errors, []);
|
|
assert.equal(r.flags['--help'], undefined);
|
|
});
|
|
|
|
test('trekcontinue — --cleanup boolean flag', () => {
|
|
const r = parseArgs('--cleanup', 'trekcontinue');
|
|
assert.equal(r.flags['--cleanup'], true);
|
|
});
|
|
|
|
test('trekcontinue — --cleanup --confirm both flags', () => {
|
|
const r = parseArgs('--cleanup --confirm', 'trekcontinue');
|
|
assert.equal(r.flags['--cleanup'], true);
|
|
assert.equal(r.flags['--confirm'], true);
|
|
});
|
|
|
|
test('trekcontinue — positional project dir captured', () => {
|
|
const r = parseArgs('.claude/projects/2026-05-04-foo', 'trekcontinue');
|
|
assert.deepEqual(r.positional, ['.claude/projects/2026-05-04-foo']);
|
|
});
|
|
|
|
test('trekcontinue — .md positional accepted by parser (rejection is command-level)', () => {
|
|
const r = parseArgs('NEXT-SESSION-PROMPT.local.md', 'trekcontinue');
|
|
assert.deepEqual(r.positional, ['NEXT-SESSION-PROMPT.local.md']);
|
|
assert.deepEqual(r.errors, []);
|
|
});
|
|
|
|
// --- #15 — /trekendsession reads its arguments with the parser ---
|
|
// A slug or label holding "-h" is an argument, not a help request: only the
|
|
// exact --help flag or a lone -h as the first positional asks for help.
|
|
|
|
test('[#15] trekendsession — a slug is one positional, with no errors', () => {
|
|
const r = parseArgs('2026-05-01-hotfix', 'trekendsession');
|
|
assert.deepEqual(r.errors, []);
|
|
assert.deepEqual(r.positional, ['2026-05-01-hotfix']);
|
|
assert.equal(r.flags['--help'], undefined);
|
|
});
|
|
|
|
test('[#15] trekendsession — a path and a quoted label are two positionals, with no --help', () => {
|
|
const r = parseArgs('fix-header "Session 2"', 'trekendsession');
|
|
assert.deepEqual(r.errors, []);
|
|
assert.deepEqual(r.positional, ['fix-header', 'Session 2']);
|
|
assert.equal(r.flags['--help'], undefined);
|
|
});
|
|
|
|
test('[#15] trekendsession — --help is the boolean help flag', () => {
|
|
const r = parseArgs('--help', 'trekendsession');
|
|
assert.deepEqual(r.errors, []);
|
|
assert.equal(r.flags['--help'], true);
|
|
assert.deepEqual(r.unknown, []);
|
|
});
|
|
|
|
test('[#15] trekendsession — the CLI with --command trekendsession -- fix-header exits 0', () => {
|
|
const r = spawnSync(process.execPath, [PARSER, '--command', 'trekendsession', '--', 'fix-header'], { encoding: 'utf8' });
|
|
assert.equal(r.status, 0, `the parser CLI refused trekendsession: ${r.stdout}${r.stderr}`);
|
|
const out = JSON.parse(r.stdout);
|
|
assert.deepEqual(out.positional, ['fix-header']);
|
|
assert.equal(out.flags['--help'], undefined);
|
|
});
|
|
|
|
test('trekendsession — -h stays a positional (no alias resolution)', () => {
|
|
const r = parseArgs('-h', 'trekendsession');
|
|
assert.deepEqual(r.positional, ['-h']);
|
|
assert.deepEqual(r.errors, []);
|
|
assert.equal(r.flags['--help'], undefined);
|
|
});
|
|
|
|
// --- ARG / M10 (fix round 4.5b) — the arguments reach the parser as stdin
|
|
// text, never as shell words, and the label is read whole from `tail` ---
|
|
|
|
function runStdin(command, input, cwd) {
|
|
return spawnSync(process.execPath, [PARSER, '--command', command, '--stdin'], {
|
|
input, cwd, encoding: 'utf8', env: childEnv(),
|
|
});
|
|
}
|
|
|
|
test('[ARG] --stdin keeps ; $( ) and * as literal characters and creates no file', async () => {
|
|
const mod = await import(PARSER_URL);
|
|
assert.equal(typeof mod.parseArgs, 'function', 'arg-parser.mjs exports parseArgs');
|
|
const cwd = mkdtempSync(join(tmpdir(), 'arg-parser-stdin-'));
|
|
try {
|
|
const r = runStdin('trekendsession', 'brief.md ; touch PWNED $(touch PWNED2) * ~/x $HOME\n', cwd);
|
|
assert.equal(r.status, 0, `the parser CLI refused --stdin: ${r.stdout}${r.stderr}`);
|
|
const out = JSON.parse(r.stdout);
|
|
assert.deepEqual(out.positional,
|
|
['brief.md', ';', 'touch', 'PWNED', '$(touch', 'PWNED2)', '*', '~/x', '$HOME']);
|
|
assert.equal(out.tail, '; touch PWNED $(touch PWNED2) * ~/x $HOME');
|
|
assert.equal(existsSync(join(cwd, 'PWNED')), false, 'no PWNED file was created');
|
|
assert.equal(existsSync(join(cwd, 'PWNED2')), false, 'no PWNED2 file was created');
|
|
} finally {
|
|
rmSync(cwd, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test('[ARG] a balanced quote groups words', async () => {
|
|
const mod = await import(PARSER_URL);
|
|
assert.equal(typeof mod.tokenize, 'function', 'arg-parser.mjs exports tokenize');
|
|
assert.deepEqual(mod.tokenize(`a "b c" 'd e' f`), [
|
|
{ value: 'a', start: 0, end: 1 },
|
|
{ value: 'b c', start: 2, end: 7 },
|
|
{ value: 'd e', start: 8, end: 13 },
|
|
{ value: 'f', start: 14, end: 15 },
|
|
]);
|
|
assert.deepEqual(mod.tokenize(`brief.md "Fix the user's login"`).map((t) => t.value),
|
|
['brief.md', "Fix the user's login"]);
|
|
});
|
|
|
|
test('[ARG] an unbalanced quote stays a literal character', async () => {
|
|
const mod = await import(PARSER_URL);
|
|
assert.equal(typeof mod.tokenize, 'function', 'arg-parser.mjs exports tokenize');
|
|
assert.deepEqual(mod.tokenize(`Fix the user's login`).map((t) => t.value),
|
|
['Fix', 'the', "user's", 'login']);
|
|
assert.deepEqual(mod.tokenize('say "hi there').map((t) => t.value),
|
|
['say', '"hi', 'there']);
|
|
assert.deepEqual(mod.parseArgs(`brief.md it's`, 'trekendsession').positional,
|
|
['brief.md', "it's"]);
|
|
});
|
|
|
|
test('[ARG] empty stdin gives no positional, an empty tail and exit 0', async () => {
|
|
const mod = await import(PARSER_URL);
|
|
assert.equal(typeof mod.parseArgs, 'function', 'arg-parser.mjs exports parseArgs');
|
|
for (const input of ['', '\n']) {
|
|
const r = runStdin('trekendsession', input);
|
|
assert.equal(r.status, 0, `the parser CLI refused empty stdin: ${r.stdout}${r.stderr}`);
|
|
const out = JSON.parse(r.stdout);
|
|
assert.deepEqual(out.positional, []);
|
|
assert.deepEqual(out.errors, []);
|
|
assert.equal(out.tail, '', `tail for ${JSON.stringify(input)}`);
|
|
}
|
|
});
|
|
|
|
test('[M10] tail keeps a multi-word label whole', async () => {
|
|
const mod = await import(PARSER_URL);
|
|
assert.equal(typeof mod.parseArgs, 'function', 'arg-parser.mjs exports parseArgs');
|
|
const r = mod.parseArgs('brief.md Session 2 of 3', 'trekendsession');
|
|
assert.equal(r.tail, 'Session 2 of 3');
|
|
assert.equal(r.positional[0], 'brief.md');
|
|
});
|
|
|
|
test('[M10] one outer quote pair around the label is removed', async () => {
|
|
const mod = await import(PARSER_URL);
|
|
assert.equal(typeof mod.parseArgs, 'function', 'arg-parser.mjs exports parseArgs');
|
|
assert.equal(mod.parseArgs(`brief.md 'Session 2 of 3'`, 'trekendsession').tail, 'Session 2 of 3');
|
|
assert.equal(mod.parseArgs(`brief.md "Session 2 of 3"`, 'trekendsession').tail, 'Session 2 of 3');
|
|
});
|
|
|
|
test('[M10] an inner apostrophe stays', async () => {
|
|
const mod = await import(PARSER_URL);
|
|
assert.equal(typeof mod.parseArgs, 'function', 'arg-parser.mjs exports parseArgs');
|
|
assert.equal(mod.parseArgs(`brief.md Fix the user's login`, 'trekendsession').tail, "Fix the user's login");
|
|
});
|