@devrik-tools/claude-gates 0.2.1 → 0.3.1

package/plugins/gates/hooks/gates/diagnosis-before-patch/diagnosis-before-patch.edge.test.mjs

@@ -1,68 +0,0 @@
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { mkdtempSync, mkdirSync, writeFileSync } 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 GATE = join(dirname(fileURLToPath(import.meta.url)), 'index.mjs');
-
-function runGate(payload, { config } = {}) {
-  const project = mkdtempSync(join(tmpdir(), 'diagnosis-edge-'));
-  mkdirSync(join(project, '.git'));
-  if (config) {
-    mkdirSync(join(project, '.ai'));
-    writeFileSync(join(project, '.ai', 'config.json'), JSON.stringify(config));
-  }
-  const out = execFileSync(process.execPath, [GATE], {
-    input: JSON.stringify(payload),
-    encoding: 'utf8',
-    cwd: project,
-    env: { ...process.env, HOME: project, USERPROFILE: project },
-  });
-  return out.trim() ? JSON.parse(out.trim()) : null;
-}
-
-function isWarn(result) {
-  return result?.hookSpecificOutput?.additionalContext !== undefined;
-}
-
-// FIXED: extractText() now gates on toolInGroups(toolName, ['write']) and reads through
-// writtenContentOf() (lib/hook-io.mjs), which covers NotebookEdit's new_source field.
-test('FIXED: NotebookEdit changing a timeout value is detected', () => {
-  const payload = {
-    tool_name: 'NotebookEdit',
-    tool_input: {
-      notebook_path: '/repo/notebook.ipynb',
-      cell_id: 'abc',
-      new_source: 'REQUEST_TIMEOUT_MS = 30000',
-      cell_type: 'code',
-    },
-  };
-  assert.ok(isWarn(runGate(payload)), 'gate now detects a timeout change via NotebookEdit');
-});
-
-// FIXED: replace_file_content is recognized by toolInGroups(toolName, ['write']) (native
-// name in TOOL_GROUPS.write) and its `content` field is read through writtenContentOf().
-test('FIXED: replace_file_content changing a timeout value is detected', () => {
-  const payload = {
-    tool_name: 'replace_file_content',
-    tool_input: {
-      file_path: '/repo/src/config.js',
-      content: 'const REQUEST_TIMEOUT_MS = 30000;',
-    },
-  };
-  assert.ok(isWarn(runGate(payload)), 'gate now detects a timeout change via replace_file_content');
-});
-
-// EDGE CASE: confirm severity really is warn-only, never deny, for a real match (per WARN
-// family classification). This should hold given index.mjs only calls warn(), never deny.
-test('OK: matched content produces warn, never deny', () => {
-  const result = runGate({
-    tool_name: 'Write',
-    tool_input: { file_path: '/repo/src/config.js', content: 'const REQUEST_TIMEOUT_MS = 30000;' },
-  });
-  assert.ok(isWarn(result));
-  assert.notEqual(result?.hookSpecificOutput?.permissionDecision, 'deny');
-});

package/plugins/gates/hooks/gates/diagnosis-before-patch/test.mjs

@@ -1,68 +0,0 @@
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { mkdtempSync, mkdirSync, writeFileSync } 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 GATE = join(dirname(fileURLToPath(import.meta.url)), 'index.mjs');
-
-function runGate(payload, { config } = {}) {
-  const project = mkdtempSync(join(tmpdir(), 'diagnosis-before-patch-'));
-  mkdirSync(join(project, '.git'));
-  if (config) {
-    mkdirSync(join(project, '.ai'));
-    writeFileSync(join(project, '.ai', 'config.json'), JSON.stringify(config));
-  }
-  const out = execFileSync(process.execPath, [GATE], {
-    input: JSON.stringify(payload),
-    encoding: 'utf8',
-    cwd: project,
-    // Isolate from the user's real global config: point homedir() at the temp
-    // project so the global-config fallback finds nothing (registry default).
-    env: { ...process.env, HOME: project, USERPROFILE: project },
-  });
-  return out.trim() ? JSON.parse(out.trim()) : null;
-}
-
-function write(content) {
-  return {
-    tool_name: 'Write',
-    tool_input: { file_path: '/repo/src/config.js', content },
-  };
-}
-function isWarn(result) {
-  return result?.hookSpecificOutput?.additionalContext !== undefined;
-}
-
-test('warns when a timeout value is being changed', () => {
-  assert.ok(isWarn(runGate(write('const REQUEST_TIMEOUT_MS = 30000;'))));
-  assert.ok(isWarn(runGate(write('max_retry: 5'))));
-});
-
-test('allows content that does not touch a timeout/retry key', () => {
-  assert.equal(runGate(write('const x = 1;')), null);
-});
-
-test('disabled by config: the gate does not run', () => {
-  assert.equal(
-    runGate(write('TIMEOUT_MS = 5000'), {
-      config: { gates: { warnTimeoutChangeWithoutDiagnosis: false } },
-    }),
-    null,
-  );
-});
-
-test('project timeoutPatterns override replaces the built-in list', () => {
-  const config = {
-    gates: {
-      warnTimeoutChangeWithoutDiagnosis: {
-        enabled: true,
-        timeoutPatterns: ['custom_limit'],
-      },
-    },
-  };
-  assert.equal(runGate(write('TIMEOUT_MS = 5000'), { config }), null);
-  assert.ok(isWarn(runGate(write('custom_limit = 5'), { config })));
-});

package/plugins/gates/hooks/gates/feature-catalog/edge.edge.test.mjs

@@ -1,83 +0,0 @@
-// Edge-case probes for feature-catalog. Previously an Edit (new_string) writing
-// status:done or an in_progress overrun to the catalog bypassed this gate because
-// writeContentFrom() read only CodeContent/ReplacementContent/content, never
-// new_string. Migrated to writtenContentOf()/writtenPathOf() (hook-io.mjs), which read
-// through every known field shape, so these are now caught the same as a Write.
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { mkdtempSync, mkdirSync, writeFileSync } 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 GATE = join(dirname(fileURLToPath(import.meta.url)), 'index.mjs');
-
-function runGate(payload) {
-  const project = mkdtempSync(join(tmpdir(), 'feature-catalog-edge-'));
-  mkdirSync(join(project, '.git'));
-  const out = execFileSync(process.execPath, [GATE], {
-    input: JSON.stringify(payload),
-    encoding: 'utf8',
-    cwd: project,
-    env: { ...process.env, HOME: project, USERPROFILE: project },
-  });
-  return out.trim() ? JSON.parse(out.trim()) : null;
-}
-
-function isDeny(result) {
-  return result?.hookSpecificOutput?.permissionDecision === 'deny';
-}
-
-test('FIXED: an Edit (new_string) writing status:done to the catalog is now detected', () => {
-  const payload = {
-    tool_name: 'Edit',
-    tool_input: {
-      file_path: 'feature_list.json',
-      old_string: 'x',
-      new_string: JSON.stringify({
-        features: [{ name: 'checkout', status: 'done' }],
-      }),
-    },
-  };
-  assert.ok(
-    isDeny(runGate(payload)),
-    'writtenContentOf reads new_string and catches status:done via Edit',
-  );
-});
-
-test('FIXED: an Edit (new_string) exceeding maxInProgress is now detected', () => {
-  const payload = {
-    tool_name: 'Edit',
-    tool_input: {
-      file_path: 'feature_list.json',
-      old_string: 'x',
-      new_string: JSON.stringify({
-        features: [
-          { name: 'a', status: 'in_progress' },
-          { name: 'b', status: 'in_progress' },
-        ],
-      }),
-    },
-  };
-  assert.ok(
-    isDeny(runGate(payload)),
-    'writtenContentOf reads new_string and catches the maxInProgress overrun via Edit',
-  );
-});
-
-test('OK: the equivalent Write-tool payload IS caught (control)', () => {
-  const payload = {
-    tool_name: 'Write',
-    tool_input: {
-      file_path: 'feature_list.json',
-      content: JSON.stringify({
-        features: [{ name: 'checkout', status: 'done' }],
-      }),
-    },
-  };
-  assert.ok(
-    isDeny(runGate(payload)),
-    'control failed: Write-tool status:done should be denied',
-  );
-});

package/plugins/gates/hooks/gates/feature-catalog/test.mjs

@@ -1,97 +0,0 @@
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { mkdtempSync, mkdirSync, writeFileSync } 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 GATE = join(dirname(fileURLToPath(import.meta.url)), 'index.mjs');
-
-function runGate(payload, { config } = {}) {
-  const project = mkdtempSync(join(tmpdir(), 'feature-catalog-'));
-  mkdirSync(join(project, '.git'));
-  if (config) {
-    mkdirSync(join(project, '.ai'));
-    writeFileSync(join(project, '.ai', 'config.json'), JSON.stringify(config));
-  }
-  const out = execFileSync(process.execPath, [GATE], {
-    input: JSON.stringify(payload),
-    encoding: 'utf8',
-    cwd: project,
-    // Isolate from the user's real global config: point homedir() at the temp
-    // project so the global-config fallback finds nothing (registry default).
-    env: { ...process.env, HOME: project, USERPROFILE: project },
-  });
-  return out.trim() ? JSON.parse(out.trim()) : null;
-}
-
-function writeCatalog(content, targetFile = 'feature_list.json') {
-  return {
-    tool_name: 'Write',
-    tool_input: { file_path: targetFile, content },
-  };
-}
-
-function isDeny(result) {
-  return result?.hookSpecificOutput?.permissionDecision === 'deny';
-}
-
-test('denies writing status:done directly to the catalog', () => {
-  const content = JSON.stringify({
-    features: [{ name: 'checkout', status: 'done' }],
-  });
-  assert.ok(isDeny(runGate(writeCatalog(content))));
-});
-
-test('denies more than maxInProgress features in_progress', () => {
-  const content = JSON.stringify({
-    features: [
-      { name: 'a', status: 'in_progress' },
-      { name: 'b', status: 'in_progress' },
-    ],
-  });
-  assert.ok(isDeny(runGate(writeCatalog(content))));
-});
-
-test('allows a write with one in_progress feature and no direct done', () => {
-  const content = JSON.stringify({
-    features: [
-      { name: 'a', status: 'in_progress' },
-      { name: 'b', status: 'spec_ready' },
-    ],
-  });
-  assert.equal(runGate(writeCatalog(content)), null);
-});
-
-test('allows a write to an unrelated file (auto-off: no catalog targeted)', () => {
-  const content = JSON.stringify({ status: 'done' });
-  assert.equal(runGate(writeCatalog(content, 'notes.json')), null);
-});
-
-test('disabled by config: the gate does not run', () => {
-  const content = JSON.stringify({
-    features: [{ name: 'checkout', status: 'done' }],
-  });
-  assert.equal(
-    runGate(writeCatalog(content), {
-      config: { gates: { requireFeatureCatalog: false } },
-    }),
-    null,
-  );
-});
-
-test('project param maxInProgress override raises/lowers the threshold', () => {
-  const content = JSON.stringify({
-    features: [
-      { name: 'a', status: 'in_progress' },
-      { name: 'b', status: 'in_progress' },
-    ],
-  });
-  const config = {
-    gates: {
-      requireFeatureCatalog: { enabled: true, maxInProgress: 2 },
-    },
-  };
-  assert.equal(runGate(writeCatalog(content), { config }), null);
-});

package/plugins/gates/hooks/gates/force-parallel/test.mjs

@@ -1,88 +0,0 @@
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { test } from 'node:test';
-import { fileURLToPath } from 'node:url';
-
-const GATE = join(dirname(fileURLToPath(import.meta.url)), 'index.mjs');
-const STATE_ROOT = join(tmpdir(), 'claude-gates', 'force-parallel');
-
-function delegationPayload(sessionId, prompt = 'do work') {
-  return {
-    tool_name: 'Task',
-    session_id: sessionId,
-    tool_input: { prompt },
-  };
-}
-
-function isWarn(result) {
-  return typeof result?.hookSpecificOutput?.additionalContext === 'string';
-}
-
-function runGate(project, payload) {
-  mkdirSync(join(project, '.git'), { recursive: true });
-  mkdirSync(join(project, '.ai'), { recursive: true });
-  writeFileSync(
-    join(project, '.ai', 'config.json'),
-    JSON.stringify({ gates: { warnSequentialDelegations: { enabled: true } } }),
-  );
-  const out = execFileSync(process.execPath, [GATE], {
-    input: JSON.stringify(payload),
-    encoding: 'utf8',
-    cwd: project,
-    env: { ...process.env, HOME: project, USERPROFILE: project },
-  });
-  return out.trim() ? JSON.parse(out.trim()) : null;
-}
-
-test('3 sequential delegations in the same session: the 3rd warns', () => {
-  const project = mkdtempSync(join(tmpdir(), 'force-parallel-'));
-  const sessionId = `test-${randomUUID()}`;
-  rmSync(join(STATE_ROOT, sessionId), { recursive: true, force: true });
-
-  const first = runGate(project, delegationPayload(sessionId));
-  const second = runGate(project, delegationPayload(sessionId));
-  const third = runGate(project, delegationPayload(sessionId));
-
-  assert.equal(first, null, 'first delegation should not warn');
-  assert.equal(second, null, 'second delegation should not warn');
-  assert.ok(isWarn(third), 'third consecutive delegation should warn');
-  assert.match(third.hookSpecificOutput.additionalContext, /force-parallel/);
-
-  rmSync(join(STATE_ROOT, sessionId), { recursive: true, force: true });
-});
-
-test('a marked SEQUENTIAL-JUSTIFIED prompt never warns, even at count 3', () => {
-  const project = mkdtempSync(join(tmpdir(), 'force-parallel-'));
-  const sessionId = `test-${randomUUID()}`;
-  rmSync(join(STATE_ROOT, sessionId), { recursive: true, force: true });
-
-  runGate(project, delegationPayload(sessionId));
-  runGate(project, delegationPayload(sessionId));
-  const third = runGate(
-    project,
-    delegationPayload(sessionId, 'needs prior result SEQUENTIAL-JUSTIFIED'),
-  );
-
-  assert.equal(third, null);
-
-  rmSync(join(STATE_ROOT, sessionId), { recursive: true, force: true });
-});
-
-test('a non-delegation tool is never warned', () => {
-  const project = mkdtempSync(join(tmpdir(), 'force-parallel-'));
-  const sessionId = `test-${randomUUID()}`;
-  rmSync(join(STATE_ROOT, sessionId), { recursive: true, force: true });
-
-  const result = runGate(project, {
-    tool_name: 'Bash',
-    session_id: sessionId,
-    tool_input: { command: 'ls' },
-  });
-  assert.equal(result, null);
-
-  rmSync(join(STATE_ROOT, sessionId), { recursive: true, force: true });
-});

package/plugins/gates/hooks/gates/forge-flow/forge-flow.edge.test.mjs

@@ -1,155 +0,0 @@
-// Edge audit for forge-flow: fail-open vs fail-closed behavior, and the MCP write/shell
-// matcher hole (same structural gap as autonomous-mode's question hole, applied here to
-// ACTING_TOOLS = TOOL_GROUPS.write + TOOL_GROUPS.shell).
-
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { mkdtempSync, mkdirSync, writeFileSync, chmodSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { DatabaseSync } from 'node:sqlite';
-import { test } from 'node:test';
-import { fileURLToPath } from 'node:url';
-
-const GATE = join(dirname(fileURLToPath(import.meta.url)), 'index.mjs');
-
-function adoptedProject() {
-  const project = mkdtempSync(join(tmpdir(), 'forge-edge-'));
-  mkdirSync(join(project, '.git'));
-  mkdirSync(join(project, '.ai'));
-  writeFileSync(join(project, '.ai', 'forge.json'), '{}');
-  return project;
-}
-
-function writeConfig(project, forgeDatabasePath, enabled = true) {
-  const gateEntry = { enabled };
-  if (forgeDatabasePath) gateEntry.forgeDatabasePath = forgeDatabasePath;
-  writeFileSync(
-    join(project, '.ai', 'config.json'),
-    JSON.stringify({ gates: { requireForgeRunToEdit: gateEntry } }),
-  );
-}
-
-function runGate(payload, project) {
-  const out = execFileSync(process.execPath, [GATE], {
-    input: JSON.stringify(payload),
-    encoding: 'utf8',
-    cwd: project,
-    env: { ...process.env, HOME: project, USERPROFILE: project },
-  });
-  return out.trim() ? JSON.parse(out.trim()) : null;
-}
-
-function isDeny(result) {
-  return result?.hookSpecificOutput?.permissionDecision === 'deny';
-}
-
-function isWarn(result) {
-  const output = result?.hookSpecificOutput;
-  return Boolean(output?.additionalContext) && output.permissionDecision !== 'deny';
-}
-
-function makeForgeDatabase(directory, activeCwd) {
-  const databasePath = join(directory, 'forge.db');
-  const database = new DatabaseSync(databasePath);
-  database.exec(
-    'CREATE TABLE runs (id TEXT, cwd TEXT, current_phase TEXT, status TEXT)',
-  );
-  if (activeCwd) {
-    database
-      .prepare('INSERT INTO runs (id, cwd, current_phase, status) VALUES (?,?,?,?)')
-      .run('r1', activeCwd, 'build', 'active');
-  }
-  database.close();
-  return databasePath;
-}
-
-test('DEGRADED-WARN: a corrupt (non-SQLite) DB file allows the write but WARNS visibly', () => {
-  const project = adoptedProject();
-  const home = mkdtempSync(join(tmpdir(), 'forge-db-'));
-  const databasePath = join(home, 'forge.db');
-  writeFileSync(databasePath, 'this is not a sqlite file at all');
-  writeConfig(project, databasePath);
-  const result = runGate(
-    { tool_name: 'Write', tool_input: { file_path: 'x.js', content: 'x' } },
-    project,
-  );
-  // The catch-all no longer returns a silent "run present". A DB that cannot be read yields
-  // state 'unknown' -> the gate ALLOWS (a broken lookup must not freeze all work) but emits a
-  // warn, so degraded enforcement is never invisible. This is the fix for the old silent
-  // fail-open that disabled the whole gate with no trace.
-  assert.ok(isWarn(result), 'corrupt DB must allow-with-warning, not allow silently');
-});
-
-test('DEGRADED-WARN: DB exists but "runs" table is missing/wrong schema warns visibly', () => {
-  const project = adoptedProject();
-  const home = mkdtempSync(join(tmpdir(), 'forge-db-'));
-  const databasePath = join(home, 'forge.db');
-  const database = new DatabaseSync(databasePath);
-  database.exec('CREATE TABLE not_runs (id TEXT)');
-  database.close();
-  writeConfig(project, databasePath);
-  const result = runGate(
-    { tool_name: 'Write', tool_input: { file_path: 'x.js', content: 'x' } },
-    project,
-  );
-  assert.ok(isWarn(result), 'schema drift must allow-with-warning, not allow silently');
-});
-
-test('FAIL-CLOSED (deny): DB file plainly absent at the configured path denies the write', () => {
-  const project = adoptedProject();
-  writeConfig(project, join(tmpdir(), 'definitely-does-not-exist-' + Date.now(), 'forge.db'));
-  const result = runGate(
-    { tool_name: 'Write', tool_input: { file_path: 'x.js', content: 'x' } },
-    project,
-  );
-  // existsSync(forgeDatabasePath) is false -> hasActiveForgeRun returns false directly
-  // (line 72: "no DB yet -> no runs at all -> deny") -- this is the ONE path that is
-  // fail-closed; every other failure mode (corrupt file, missing table, locked file,
-  // node:sqlite unavailable) is fail-open via the catch block.
-  assert.ok(isDeny(result), 'FALLA(ok): absent DB is the sole fail-closed path');
-});
-
-test('FIXED: an MCP filesystem write tool is now gated (denied with no active run)', () => {
-  const project = adoptedProject();
-  const home = mkdtempSync(join(tmpdir(), 'forge-db-'));
-  const databasePath = makeForgeDatabase(home); // no active run: a real Write would be denied
-  writeConfig(project, databasePath);
-  const result = runGate(
-    {
-      tool_name: 'mcp__filesystem__write_file',
-      tool_input: { path: 'x.js', content: 'x' },
-    },
-    project,
-  );
-  // ACTING_GROUPS = ['execution'] and toolInGroups matches mcp__*__write_file via the write
-  // signal, so an MCP filesystem write is now subject to the active-run requirement exactly
-  // like a native Write. No active run -> deny.
-  assert.ok(isDeny(result), 'MCP write tool must now be gated like a native Write');
-});
-
-test('control: the same DB/config DOES deny a native Write (proves the MCP case above is a real gap, not a config issue)', () => {
-  const project = adoptedProject();
-  const home = mkdtempSync(join(tmpdir(), 'forge-db-'));
-  const databasePath = makeForgeDatabase(home); // no active run
-  writeConfig(project, databasePath);
-  const result = runGate(
-    { tool_name: 'Write', tool_input: { file_path: 'x.js', content: 'x' } },
-    project,
-  );
-  assert.ok(isDeny(result), 'FALLA(ok): native Write is correctly denied under identical setup');
-});
-
-test('FIXED: an MCP shell/exec tool (mcp__ide__executeCode) is now gated', () => {
-  const project = adoptedProject();
-  const home = mkdtempSync(join(tmpdir(), 'forge-db-'));
-  const databasePath = makeForgeDatabase(home); // no active run
-  writeConfig(project, databasePath);
-  const result = runGate(
-    { tool_name: 'mcp__ide__executeCode', tool_input: { code: 'require("fs").writeFileSync("x.js","x")' } },
-    project,
-  );
-  // forge-flow now consumes the 'execution' group, which includes mcp__ide__executeCode and,
-  // via toolInGroups, any mcp__* exec/run surface. No active run -> deny.
-  assert.ok(isDeny(result), 'mcp__ide__executeCode must now be gated by forge-flow');
-});