@devrik-tools/claude-gates 0.1.1 → 0.1.3

package/cli/__tests__/task.test.mjs

@@ -0,0 +1,124 @@
+// The `task` CLI subcommands are thin wiring over task-store.mjs; these tests exercise the
+// CLI surface itself (spawning `cli/index.mjs task ...` as a real child process, the way a
+// user or the register-requests hook's advice actually invokes it) against a temp project,
+// never against this repo's own .ai/config.json or task store.
+
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const CLI_ENTRY = join(
+  dirname(fileURLToPath(import.meta.url)),
+  '..',
+  'index.mjs',
+);
+
+function makeProject() {
+  const project = mkdtempSync(join(tmpdir(), 'task-cli-'));
+  mkdirSync(join(project, '.git'));
+  return project;
+}
+
+function runCli(args, cwd) {
+  try {
+    const stdout = execFileSync(process.execPath, [CLI_ENTRY, ...args], {
+      cwd,
+      encoding: 'utf8',
+    });
+    return { code: 0, stdout };
+  } catch (error) {
+    return {
+      code: error.status ?? 1,
+      stdout: error.stdout ?? '',
+      stderr: error.stderr ?? String(error),
+    };
+  }
+}
+
+test('task add persists a new open task under .ai/tasks/active.json', () => {
+  const project = makeProject();
+  const result = runCli(['task', 'add', 'Fix the thing', '--description', 'details'], project);
+  assert.equal(result.code, 0, result.stderr);
+
+  const activePath = join(project, '.ai', 'tasks', 'active.json');
+  assert.ok(existsSync(activePath));
+  const active = JSON.parse(readFileSync(activePath, 'utf8'));
+  assert.equal(active.tasks.length, 1);
+  assert.equal(active.tasks[0].title, 'Fix the thing');
+  assert.equal(active.tasks[0].status, 'open');
+});
+
+test('task list shows the active task, and --all also reaches history', () => {
+  const project = makeProject();
+  runCli(['task', 'add', 'Task one', '--id', 't1'], project);
+  runCli(['task', 'add', 'Task two', '--id', 't2'], project);
+  runCli(['task', 'abandon', 't2', '--reason', 'not needed'], project);
+
+  const active = runCli(['task', 'list'], project);
+  assert.match(active.stdout, /Task one/);
+  assert.doesNotMatch(active.stdout, /Task two/);
+
+  const all = runCli(['task', 'list', '--all'], project);
+  assert.match(all.stdout, /Task one/);
+  assert.match(all.stdout, /Task two/);
+});
+
+test('task close WITHOUT --evidence fails and leaves the task active', () => {
+  const project = makeProject();
+  runCli(['task', 'add', 'Needs evidence', '--id', 't1'], project);
+
+  const result = runCli(['task', 'close', 't1'], project);
+  assert.notEqual(result.code, 0);
+  assert.match(result.stderr, /evidence/i);
+
+  const activePath = join(project, '.ai', 'tasks', 'active.json');
+  const active = JSON.parse(readFileSync(activePath, 'utf8'));
+  assert.equal(active.tasks.length, 1, 'the task must still be active');
+});
+
+test('task close WITH --evidence succeeds and moves the task to history', () => {
+  const project = makeProject();
+  runCli(['task', 'add', 'Has evidence', '--id', 't1'], project);
+
+  const result = runCli(
+    ['task', 'close', 't1', '--evidence', 'npm test -> 5 passing'],
+    project,
+  );
+  assert.equal(result.code, 0, result.stderr);
+
+  const historyPath = join(project, '.ai', 'tasks', 'history.json');
+  const history = JSON.parse(readFileSync(historyPath, 'utf8'));
+  assert.equal(history.tasks.length, 1);
+  assert.equal(history.tasks[0].status, 'done');
+  assert.equal(history.tasks[0].evidence, 'npm test -> 5 passing');
+});
+
+test('task abandon needs no evidence and moves the task to history', () => {
+  const project = makeProject();
+  runCli(['task', 'add', 'Drop me', '--id', 't1'], project);
+
+  const result = runCli(['task', 'abandon', 't1', '--reason', 'obsolete'], project);
+  assert.equal(result.code, 0, result.stderr);
+
+  const historyPath = join(project, '.ai', 'tasks', 'history.json');
+  const history = JSON.parse(readFileSync(historyPath, 'utf8'));
+  assert.equal(history.tasks[0].status, 'abandoned');
+  assert.equal(history.tasks[0].closeReason, 'obsolete');
+});
+
+test('task promote links a forge run and keeps the task active as in_forge', () => {
+  const project = makeProject();
+  runCli(['task', 'add', 'Promote me', '--id', 't1'], project);
+
+  const result = runCli(['task', 'promote', 't1', 'run-42'], project);
+  assert.equal(result.code, 0, result.stderr);
+
+  const activePath = join(project, '.ai', 'tasks', 'active.json');
+  const active = JSON.parse(readFileSync(activePath, 'utf8'));
+  assert.equal(active.tasks[0].status, 'in_forge');
+  assert.equal(active.tasks[0].forgeRunId, 'run-42');
+});

package/cli/config.mjs

@@ -1,113 +1,124 @@
-// Where the selection is persisted and how it merges with what is already there.
-//
-// Scope "project": `<project root>/.ai/config.json` — the file the hooks read
-//   per project. Other keys the project already has (autoCommit, etc.) are kept.
-// Scope "global": `~/.claude/claude-gates/config.json` — the fallback the hooks
-//   use when a project has no answer of its own.
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { findUpSync } from 'find-up';
-import {
-  CLAUDE_USER_DIRECTORY,
-  CONFIG_FILE,
-  GLOBAL_STATE_DIRECTORY,
-  HOME_DIRECTORY,
-  JSON_INDENT,
-  PROJECT_ROOT_MARKERS,
-  PROJECT_STATE_DIRECTORY,
-} from './constants.mjs';
-
-export const SCOPES = Object.freeze({ GLOBAL: 'global', PROJECT: 'project' });
-
-/**
- * Climbs from `startDirectory` to the nearest project marker (`.git`/`.ai`).
- * The home directory (and anything above it) is never a project root: a stray
- * `~/.ai` would otherwise turn every folder under home into "the project" and the
- * config would land in the wrong place silently. `.git` may be a file (worktrees),
- * so the matcher checks existence, not type.
- */
-export function findProjectRoot(
-  startDirectory,
-  { home = HOME_DIRECTORY } = {},
-) {
-  if (startDirectory === home) return startDirectory;
-  const markerDirectory = findUpSync(
-    (directory) => {
-      if (directory === home) return findUpSync.stop;
-      const hasMarker = PROJECT_ROOT_MARKERS.some((marker) =>
-        existsSync(join(directory, marker)),
-      );
-      return hasMarker ? directory : undefined;
-    },
-    { cwd: startDirectory, stopAt: home, type: 'directory' },
-  );
-  return markerDirectory ?? startDirectory;
-}
-
-export function configPathFor(
-  scope,
-  { cwd = process.cwd(), home = HOME_DIRECTORY } = {},
-) {
-  if (scope === SCOPES.GLOBAL)
-    return join(
-      home,
-      CLAUDE_USER_DIRECTORY,
-      GLOBAL_STATE_DIRECTORY,
-      CONFIG_FILE,
-    );
-  if (scope === SCOPES.PROJECT)
-    return join(
-      findProjectRoot(cwd, { home }),
-      PROJECT_STATE_DIRECTORY,
-      CONFIG_FILE,
-    );
-  throw new Error(`Unknown scope: ${scope}`);
-}
-
-export function readConfig(path) {
-  if (!existsSync(path)) return { exists: false, data: {}, corrupt: false };
-  try {
-    return {
-      exists: true,
-      data: JSON.parse(readFileSync(path, 'utf8')),
-      corrupt: false,
-    };
-  } catch {
-    return { exists: true, data: {}, corrupt: true };
-  }
-}
-
-/**
- * Merges one gate's new value onto whatever the project already had, preserving the user's
- * edits. A gate with params arrives as `{ enabled, ...defaults }`; if the user already
- * tuned those params, their values win and only `enabled` follows the new selection. A
- * paramless gate is a plain boolean. This is what keeps a re-run of `init` additive: it
- * never overwrites a whitelist or pattern list the user changed by hand.
- */
-function mergeGate(existingValue, newValue) {
-  if (typeof newValue === 'boolean') return newValue;
-  if (existingValue && typeof existingValue === 'object') {
-    return { ...newValue, ...existingValue, enabled: newValue.enabled };
-  }
-  return newValue;
-}
-
-/**
- * Merges the new selection into an existing config without touching unrelated keys. Gates
- * are merged key by key: a gate absent from the new map keeps its old value (a registry
- * that dropped a gate must not silently flip it), and a gate the user configured keeps its
- * params (see mergeGate).
- */
-export function mergeConfig(existing, { adopted, gates, gateVersion }) {
-  const mergedGates = { ...(existing.gates ?? {}) };
-  for (const [key, value] of Object.entries(gates)) {
-    mergedGates[key] = mergeGate(mergedGates[key], value);
-  }
-  return { ...existing, adopted, gateVersion, gates: mergedGates };
-}
-
-export function writeConfig(path, data) {
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(data, null, JSON_INDENT)}\n`, 'utf8');
-}
+// Where the selection is persisted and how it merges with what is already there.
+//
+// Scope "project": `<project root>/.ai/config.json` — the file the hooks read
+//   per project. Other keys the project already has (autoCommit, etc.) are kept.
+// Scope "global": `~/.claude/claude-gates/config.json` — the fallback the hooks
+//   use when a project has no answer of its own.
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { findUpSync } from 'find-up';
+import {
+  CLAUDE_USER_DIRECTORY,
+  CONFIG_FILE,
+  GLOBAL_STATE_DIRECTORY,
+  HOME_DIRECTORY,
+  JSON_INDENT,
+  PROJECT_ROOT_MARKERS,
+  PROJECT_STATE_DIRECTORY,
+} from './constants.mjs';
+
+export const SCOPES = Object.freeze({ GLOBAL: 'global', PROJECT: 'project' });
+
+/**
+ * Climbs from `startDirectory` to the nearest project marker (`.git`/`.ai`).
+ * The home directory (and anything above it) is never a project root: a stray
+ * `~/.ai` would otherwise turn every folder under home into "the project" and the
+ * config would land in the wrong place silently. `.git` may be a file (worktrees),
+ * so the matcher checks existence, not type.
+ */
+export function findProjectRoot(
+  startDirectory,
+  { home = HOME_DIRECTORY } = {},
+) {
+  if (startDirectory === home) return startDirectory;
+  const markerDirectory = findUpSync(
+    (directory) => {
+      if (directory === home) return findUpSync.stop;
+      const hasMarker = PROJECT_ROOT_MARKERS.some((marker) =>
+        existsSync(join(directory, marker)),
+      );
+      return hasMarker ? directory : undefined;
+    },
+    { cwd: startDirectory, stopAt: home, type: 'directory' },
+  );
+  return markerDirectory ?? startDirectory;
+}
+
+export function configPathFor(
+  scope,
+  { cwd = process.cwd(), home = HOME_DIRECTORY } = {},
+) {
+  if (scope === SCOPES.GLOBAL)
+    return join(
+      home,
+      CLAUDE_USER_DIRECTORY,
+      GLOBAL_STATE_DIRECTORY,
+      CONFIG_FILE,
+    );
+  if (scope === SCOPES.PROJECT)
+    return join(
+      findProjectRoot(cwd, { home }),
+      PROJECT_STATE_DIRECTORY,
+      CONFIG_FILE,
+    );
+  throw new Error(`Unknown scope: ${scope}`);
+}
+
+// A leading UTF-8 BOM (EF BB BF, decoded as U+FEFF) is not stripped by readFileSync('utf8'),
+// and JSON.parse rejects a string that starts with it. Without stripping it, a config saved
+// by a BOM-adding editor or `PowerShell Set-Content -Encoding utf8` would read back as
+// `corrupt: true` — a valid, user-edited config (with its gate overrides) mistaken for
+// unreadable. init.mjs bails loudly on `corrupt`, but a caller relying on `data` alone (as
+// `mergeConfig` does) would otherwise merge onto `{}` and silently drop every existing gate
+// override the user made. This is the same failure mode fixed in the gates' own config.mjs.
+function stripBom(text) {
+  return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+
+export function readConfig(path) {
+  if (!existsSync(path)) return { exists: false, data: {}, corrupt: false };
+  try {
+    return {
+      exists: true,
+      data: JSON.parse(stripBom(readFileSync(path, 'utf8'))),
+      corrupt: false,
+    };
+  } catch {
+    return { exists: true, data: {}, corrupt: true };
+  }
+}
+
+/**
+ * Merges one gate's new value onto whatever the project already had, preserving the user's
+ * edits. A gate with params arrives as `{ enabled, ...defaults }`; if the user already
+ * tuned those params, their values win and only `enabled` follows the new selection. A
+ * paramless gate is a plain boolean. This is what keeps a re-run of `init` additive: it
+ * never overwrites a whitelist or pattern list the user changed by hand.
+ */
+function mergeGate(existingValue, newValue) {
+  if (typeof newValue === 'boolean') return newValue;
+  if (existingValue && typeof existingValue === 'object') {
+    return { ...newValue, ...existingValue, enabled: newValue.enabled };
+  }
+  return newValue;
+}
+
+/**
+ * Merges the new selection into an existing config without touching unrelated keys. Gates
+ * are merged key by key: a gate absent from the new map keeps its old value (a registry
+ * that dropped a gate must not silently flip it), and a gate the user configured keeps its
+ * params (see mergeGate).
+ */
+export function mergeConfig(existing, { adopted, gates, gateVersion }) {
+  const mergedGates = { ...(existing.gates ?? {}) };
+  for (const [key, value] of Object.entries(gates)) {
+    mergedGates[key] = mergeGate(mergedGates[key], value);
+  }
+  return { ...existing, adopted, gateVersion, gates: mergedGates };
+}
+
+export function writeConfig(path, data) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(data, null, JSON_INDENT)}\n`, 'utf8');
+}

package/cli/index.mjs

@@ -1,97 +1,100 @@
-#!/usr/bin/env node
-// Entry point (commander). Commands:
-//   init      interactive (or flag-driven) selection of gates, per project or globally
-//   registry  --check validates registry.json; --list prints the catalog
-
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { Command } from 'commander';
-import {
-  EXIT_CODE,
-  LIST_SEPARATOR,
-  REGISTRY_PATH,
-  REPOSITORY_ROOT,
-} from './constants.mjs';
-import { loadRegistry, validateRegistry } from './registry.mjs';
-
-const packageManifest = JSON.parse(
-  readFileSync(join(REPOSITORY_ROOT, 'package.json'), 'utf8'),
-);
-
-function fail(message) {
-  process.stderr.write(`${message}\n`);
-  process.exit(EXIT_CODE.FAILURE);
-}
-
-function splitList(value) {
-  return value
-    .split(LIST_SEPARATOR)
-    .map((item) => item.trim())
-    .filter(Boolean);
-}
-
-function registryCheck() {
-  const problems = validateRegistry(
-    JSON.parse(readFileSync(REGISTRY_PATH, 'utf8')),
-  );
-  if (problems.length > 0) {
-    fail(`registry.json is invalid:\n- ${problems.join('\n- ')}`);
-  }
-  process.stdout.write('registry.json OK\n');
-}
-
-function registryList() {
-  const registry = loadRegistry();
-  for (const family of registry.families) {
-    process.stdout.write(`${family.name} (${family.id})\n`);
-    for (const gate of family.gates) {
-      const marker = gate.default ? '*' : ' ';
-      process.stdout.write(`  ${marker} ${gate.id}  ${gate.configKey}\n`);
-    }
-  }
-  process.stdout.write('\n* = recommended default\n');
-}
-
-const program = new Command()
-  .name(packageManifest.name)
-  .description(packageManifest.description)
-  .version(packageManifest.version);
-
-program
-  .command('init')
-  .description('Choose which gates to adopt and write the config.')
-  .option('--project', 'apply to this project (<root>/.ai/config.json)')
-  .option('--global', 'apply globally (~/.claude/claude-gates/config.json)')
-  .option('--defaults', 'enable the recommended defaults')
-  .option('--all', 'enable every gate')
-  .option('--none', "record a 'no' so you are not asked again")
-  .option(
-    '--families <ids>',
-    'enable whole families, comma-separated',
-    splitList,
-  )
-  .option(
-    '--gates <ids>',
-    'enable individual gates, comma-separated',
-    splitList,
-  )
-  .option('-y, --yes', 'never prompt; use flags and defaults')
-  .option('--no-install', 'write the config but do not install the plugin')
-  .option('--dry-run', 'show the selection without writing')
-  .action(async (options) => {
-    const { runInit } = await import('./init.mjs');
-    await runInit(options);
-  });
-
-program
-  .command('registry')
-  .description('Inspect registry.json.')
-  .option('--check', 'validate the registry')
-  .option('--list', 'print families and gates')
-  .action((options) => {
-    if (options.check) return registryCheck();
-    if (options.list) return registryList();
-    return fail('registry needs --check or --list');
-  });
-
-program.parseAsync(process.argv).catch((error) => fail(error.message));
+#!/usr/bin/env node
+// Entry point (commander). Commands:
+//   init      interactive (or flag-driven) selection of gates, per project or globally
+//   registry  --check validates registry.json; --list prints the catalog
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Command } from 'commander';
+import {
+  EXIT_CODE,
+  LIST_SEPARATOR,
+  REGISTRY_PATH,
+  REPOSITORY_ROOT,
+} from './constants.mjs';
+import { loadRegistry, validateRegistry } from './registry.mjs';
+import { registerTaskCommand } from './task.mjs';
+
+const packageManifest = JSON.parse(
+  readFileSync(join(REPOSITORY_ROOT, 'package.json'), 'utf8'),
+);
+
+function fail(message) {
+  process.stderr.write(`${message}\n`);
+  process.exit(EXIT_CODE.FAILURE);
+}
+
+function splitList(value) {
+  return value
+    .split(LIST_SEPARATOR)
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function registryCheck() {
+  const problems = validateRegistry(
+    JSON.parse(readFileSync(REGISTRY_PATH, 'utf8')),
+  );
+  if (problems.length > 0) {
+    fail(`registry.json is invalid:\n- ${problems.join('\n- ')}`);
+  }
+  process.stdout.write('registry.json OK\n');
+}
+
+function registryList() {
+  const registry = loadRegistry();
+  for (const family of registry.families) {
+    process.stdout.write(`${family.name} (${family.id})\n`);
+    for (const gate of family.gates) {
+      const marker = gate.default ? '*' : ' ';
+      process.stdout.write(`  ${marker} ${gate.id}  ${gate.configKey}\n`);
+    }
+  }
+  process.stdout.write('\n* = recommended default\n');
+}
+
+const program = new Command()
+  .name(packageManifest.name)
+  .description(packageManifest.description)
+  .version(packageManifest.version);
+
+program
+  .command('init')
+  .description('Choose which gates to adopt and write the config.')
+  .option('--project', 'apply to this project (<root>/.ai/config.json)')
+  .option('--global', 'apply globally (~/.claude/claude-gates/config.json)')
+  .option('--defaults', 'enable the recommended defaults')
+  .option('--all', 'enable every gate')
+  .option('--none', "record a 'no' so you are not asked again")
+  .option(
+    '--families <ids>',
+    'enable whole families, comma-separated',
+    splitList,
+  )
+  .option(
+    '--gates <ids>',
+    'enable individual gates, comma-separated',
+    splitList,
+  )
+  .option('-y, --yes', 'never prompt; use flags and defaults')
+  .option('--no-install', 'write the config but do not install the plugin')
+  .option('--dry-run', 'show the selection without writing')
+  .action(async (options) => {
+    const { runInit } = await import('./init.mjs');
+    await runInit(options);
+  });
+
+program
+  .command('registry')
+  .description('Inspect registry.json.')
+  .option('--check', 'validate the registry')
+  .option('--list', 'print families and gates')
+  .action((options) => {
+    if (options.check) return registryCheck();
+    if (options.list) return registryList();
+    return fail('registry needs --check or --list');
+  });
+
+registerTaskCommand(program);
+
+program.parseAsync(process.argv).catch((error) => fail(error.message));