@devrik-tools/claude-gates 0.1.0

package/plugins/gates/hooks/hooks.json

@@ -0,0 +1,266 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash|run_command|Agent|Task|invoke_subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/bash-commands/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|NotebookEdit|write_to_file|replace_file_content|Bash|run_command",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/protected-paths/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|NotebookEdit|write_to_file|replace_file_content",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/root-whitelist/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Bash|run_command|Agent|Task|invoke_subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/no-blocking/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Agent|Task|invoke_subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/brief-before-delegate/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Agent|Task|invoke_subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/intent-flow/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Agent|Task|invoke_subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/risk-level/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Agent|Task|invoke_subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/circuit-breaker/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Agent|Task|invoke_subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/no-memory-dependency/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|NotebookEdit|write_to_file|replace_file_content",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/feature-catalog/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|NotebookEdit|write_to_file|replace_file_content|Agent|Task|invoke_subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/sdd-specs/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Agent|Task|invoke_subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/implementation-pipeline/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Agent|Task|invoke_subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/mandatory-flow/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Agent|Task|invoke_subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/test-matrix/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|NotebookEdit|write_to_file|replace_file_content",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/dependency-skills/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|NotebookEdit|write_to_file|replace_file_content|Agent|Task|invoke_subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/root-cause-first/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|NotebookEdit|write_to_file|replace_file_content|Agent|Task|invoke_subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/audit-before-build/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|NotebookEdit|write_to_file|replace_file_content|Agent|Task|invoke_subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/never-assume/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|NotebookEdit|write_to_file|replace_file_content|Bash|run_command|mcp__ide__executeCode|Agent|Task|invoke_subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/rule-skill-autodiscovery/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|NotebookEdit|write_to_file|replace_file_content|Bash|run_command|mcp__ide__executeCode|Agent|Task|invoke_subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/recurrence-lock/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|NotebookEdit|write_to_file|replace_file_content",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/test-after-implementation/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "AskUserQuestion",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/no-reconfirm/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|NotebookEdit|write_to_file|replace_file_content",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/neutral-spanish/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|NotebookEdit|write_to_file|replace_file_content",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/diagnosis-before-patch/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|NotebookEdit|write_to_file|replace_file_content|Agent|Task|invoke_subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/reuse-before-build/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|NotebookEdit|write_to_file|replace_file_content",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/tool-map/index.mjs\"",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}

package/plugins/gates/hooks/lib/__tests__/config.test.mjs

@@ -0,0 +1,154 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { test } from 'node:test';
+import { isGateEnabled, gateParameters } from '../config.mjs';
+
+const GATE_KEY = 'blockDestructiveShellCommands';
+
+function temporaryDirectory() {
+  return mkdtempSync(join(tmpdir(), 'claude-gates-config-'));
+}
+
+/** A project directory with a .git marker so config.mjs finds a project root. */
+function projectDirectory() {
+  const root = temporaryDirectory();
+  mkdirSync(join(root, '.git'));
+  return root;
+}
+
+function writeProjectConfig(root, config) {
+  mkdirSync(join(root, '.ai'), { recursive: true });
+  writeFileSync(join(root, '.ai', 'config.json'), JSON.stringify(config));
+}
+
+function writeGlobalConfig(home, config) {
+  const directory = join(home, '.claude', 'claude-gates');
+  mkdirSync(directory, { recursive: true });
+  writeFileSync(join(directory, 'config.json'), JSON.stringify(config));
+}
+
+test('isGateEnabled falls back to the registry default when no config exists anywhere', () => {
+  const project = projectDirectory();
+  const home = temporaryDirectory();
+  assert.equal(isGateEnabled(GATE_KEY, true, project, { home }), true);
+  assert.equal(isGateEnabled(GATE_KEY, false, project, { home }), false);
+});
+
+test('isGateEnabled reads a bool shorthand entry from the project config', () => {
+  const project = projectDirectory();
+  const home = temporaryDirectory();
+  writeProjectConfig(project, { gates: { [GATE_KEY]: false } });
+  assert.equal(isGateEnabled(GATE_KEY, true, project, { home }), false);
+
+  const projectTrue = projectDirectory();
+  writeProjectConfig(projectTrue, { gates: { [GATE_KEY]: true } });
+  assert.equal(isGateEnabled(GATE_KEY, false, projectTrue, { home }), true);
+});
+
+test('isGateEnabled reads an object entry with an explicit enabled flag', () => {
+  const project = projectDirectory();
+  const home = temporaryDirectory();
+  writeProjectConfig(project, {
+    gates: { [GATE_KEY]: { enabled: false, someParam: 'x' } },
+  });
+  assert.equal(isGateEnabled(GATE_KEY, true, project, { home }), false);
+});
+
+test('isGateEnabled treats an object entry with no enabled field as silent (uses registry default)', () => {
+  const project = projectDirectory();
+  const home = temporaryDirectory();
+  writeProjectConfig(project, {
+    gates: { [GATE_KEY]: { someParam: 'x' } },
+  });
+  assert.equal(isGateEnabled(GATE_KEY, true, project, { home }), true);
+  assert.equal(isGateEnabled(GATE_KEY, false, project, { home }), false);
+});
+
+test('isGateEnabled falls back to the global config when the project declares nothing', () => {
+  const project = projectDirectory();
+  const home = temporaryDirectory();
+  writeGlobalConfig(home, { gates: { [GATE_KEY]: false } });
+  assert.equal(isGateEnabled(GATE_KEY, true, project, { home }), false);
+});
+
+test('isGateEnabled: an existing project config wins over the global config even if silent about this gate', () => {
+  const project = projectDirectory();
+  const home = temporaryDirectory();
+  writeGlobalConfig(home, { gates: { [GATE_KEY]: false } });
+  writeProjectConfig(project, { gates: {} });
+  // Project config exists (even without this gate declared): registry default wins,
+  // global's false must NOT leak through.
+  assert.equal(isGateEnabled(GATE_KEY, true, project, { home }), true);
+});
+
+test('isGateEnabled: corrupt project config is treated as absent and falls through to global', () => {
+  const project = projectDirectory();
+  const home = temporaryDirectory();
+  mkdirSync(join(project, '.ai'), { recursive: true });
+  writeFileSync(join(project, '.ai', 'config.json'), '{not valid json');
+  writeGlobalConfig(home, { gates: { [GATE_KEY]: false } });
+  assert.equal(isGateEnabled(GATE_KEY, true, project, { home }), false);
+});
+
+test('isGateEnabled: a malformed entry (string/number) is ignored, falls back to registry default', () => {
+  const project = projectDirectory();
+  const home = temporaryDirectory();
+  writeProjectConfig(project, { gates: { [GATE_KEY]: 'yes' } });
+  assert.equal(isGateEnabled(GATE_KEY, true, project, { home }), true);
+  assert.equal(isGateEnabled(GATE_KEY, false, project, { home }), false);
+
+  const projectNumber = projectDirectory();
+  writeProjectConfig(projectNumber, { gates: { [GATE_KEY]: 1 } });
+  assert.equal(isGateEnabled(GATE_KEY, false, projectNumber, { home }), false);
+});
+
+test('gateParameters returns {} when nothing is declared for the gate', () => {
+  const project = projectDirectory();
+  const home = temporaryDirectory();
+  writeProjectConfig(project, { gates: {} });
+  assert.deepEqual(gateParameters(GATE_KEY, project, { home }), {});
+});
+
+test('gateParameters returns {} for a bool shorthand entry (no params, just enabled)', () => {
+  const project = projectDirectory();
+  const home = temporaryDirectory();
+  writeProjectConfig(project, { gates: { [GATE_KEY]: true } });
+  assert.deepEqual(gateParameters(GATE_KEY, project, { home }), {});
+});
+
+test('gateParameters strips enabled and returns the remaining params from the project config', () => {
+  const project = projectDirectory();
+  const home = temporaryDirectory();
+  writeProjectConfig(project, {
+    gates: {
+      [GATE_KEY]: { enabled: true, protectedPaths: ['a', 'b'] },
+    },
+  });
+  assert.deepEqual(gateParameters(GATE_KEY, project, { home }), {
+    protectedPaths: ['a', 'b'],
+  });
+});
+
+test('gateParameters: project params replace (do not merge with) global params', () => {
+  const project = projectDirectory();
+  const home = temporaryDirectory();
+  writeGlobalConfig(home, {
+    gates: {
+      [GATE_KEY]: { protectedPaths: ['global-a'], extra: 'g' },
+    },
+  });
+  writeProjectConfig(project, {
+    gates: { [GATE_KEY]: { protectedPaths: ['project-a'] } },
+  });
+  assert.deepEqual(gateParameters(GATE_KEY, project, { home }), {
+    protectedPaths: ['project-a'],
+  });
+});
+
+test('gateParameters returns {} when no config exists anywhere', () => {
+  const project = projectDirectory();
+  const home = temporaryDirectory();
+  assert.deepEqual(gateParameters(GATE_KEY, project, { home }), {});
+});

package/plugins/gates/hooks/lib/__tests__/hook-io.test.mjs

@@ -0,0 +1,154 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { test } from 'node:test';
+import { pathToFileURL } from 'node:url';
+import {
+  toolNamesFor,
+  matcherFor,
+  toolNameOf,
+  sessionIdOf,
+  toolInputOf,
+} from '../hook-io.mjs';
+
+// deny/warn/allow/runGate call process.exit and cannot be invoked in-process without
+// killing the test runner. They are exercised here as a child process instead; each
+// gate's own tests additionally cover runGate's wiring through its real check function.
+
+test('toolNamesFor expands a single group', () => {
+  assert.deepEqual(toolNamesFor(['question']), ['AskUserQuestion']);
+});
+
+test('toolNamesFor expands multiple groups and de-duplicates overlapping names', () => {
+  const names = toolNamesFor(['write', 'execution']);
+  // 'execution' repeats every 'write' tool plus Bash/run_command/mcp__ide__executeCode.
+  assert.equal(names.filter((name) => name === 'Write').length, 1);
+  assert.ok(names.includes('Write'));
+  assert.ok(names.includes('Bash'));
+  assert.ok(names.includes('mcp__ide__executeCode'));
+});
+
+test('toolNamesFor returns an empty list for an empty group set', () => {
+  assert.deepEqual(toolNamesFor([]), []);
+});
+
+test('toolNamesFor ignores an unknown group name', () => {
+  assert.deepEqual(toolNamesFor(['not-a-real-group']), []);
+});
+
+test('matcherFor joins tool names with a pipe', () => {
+  assert.equal(matcherFor(['question']), 'AskUserQuestion');
+  assert.equal(matcherFor(['shell']), 'Bash|run_command');
+});
+
+test('matcherFor returns an empty string for an empty group set', () => {
+  assert.equal(matcherFor([]), '');
+});
+
+test('toolNameOf reads tool_name, falls back to name, defaults to empty string', () => {
+  assert.equal(toolNameOf(JSON.stringify({ tool_name: 'Bash' })), 'Bash');
+  assert.equal(toolNameOf(JSON.stringify({ name: 'Edit' })), 'Edit');
+  assert.equal(
+    toolNameOf(JSON.stringify({ tool_name: 'Bash', name: 'Edit' })),
+    'Bash',
+  );
+  assert.equal(toolNameOf(JSON.stringify({})), '');
+});
+
+test('toolNameOf returns null for unparseable payloads', () => {
+  assert.equal(toolNameOf('{not json'), null);
+  assert.equal(toolNameOf(undefined), null);
+});
+
+test('sessionIdOf reads session_id or returns null when absent/unparseable', () => {
+  assert.equal(sessionIdOf(JSON.stringify({ session_id: 'abc123' })), 'abc123');
+  assert.equal(sessionIdOf(JSON.stringify({})), null);
+  assert.equal(sessionIdOf('{not json'), null);
+});
+
+test('toolInputOf reads tool_input, falls back to input, defaults to {}', () => {
+  assert.deepEqual(
+    toolInputOf(JSON.stringify({ tool_input: { command: 'ls' } })),
+    { command: 'ls' },
+  );
+  assert.deepEqual(toolInputOf(JSON.stringify({ input: { file: 'a' } })), {
+    file: 'a',
+  });
+  assert.deepEqual(
+    toolInputOf(JSON.stringify({ tool_input: { a: 1 }, input: { b: 2 } })),
+    { a: 1 },
+  );
+  assert.deepEqual(toolInputOf(JSON.stringify({})), {});
+});
+
+test('toolInputOf returns {} for unparseable payloads', () => {
+  assert.deepEqual(toolInputOf('{not json'), {});
+  assert.deepEqual(toolInputOf(undefined), {});
+});
+
+const hookIoModuleUrl = pathToFileURL(
+  new URL('../hook-io.mjs', import.meta.url).pathname.replace(
+    /^\/([A-Za-z]:)/,
+    '$1',
+  ),
+).href;
+
+/** Runs `body` (a callback expression referencing `mod`) in a child process after
+ *  dynamically importing hook-io.mjs there, so process.exit-calling exports can be
+ *  exercised without killing the test runner. */
+function runInChildProcess(body, execOptions) {
+  const script = `import('${hookIoModuleUrl}').then((mod) => { ${body} });`;
+  return execFileSync(process.execPath, ['--input-type=module', '-e', script], {
+    encoding: 'utf8',
+    ...execOptions,
+  });
+}
+
+test('readHookPayload reads whatever is piped on stdin, including empty input', () => {
+  const output = runInChildProcess(
+    'process.stdout.write(JSON.stringify(mod.readHookPayload()))',
+    { input: '{"tool_name":"Bash"}' },
+  );
+  assert.equal(output, JSON.stringify('{"tool_name":"Bash"}'));
+
+  const emptyOutput = runInChildProcess(
+    'process.stdout.write(JSON.stringify(mod.readHookPayload()))',
+    { stdio: ['ignore', 'pipe', 'pipe'] },
+  );
+  // With no stdin available, readFileSync(0) resolves to an empty string rather than
+  // throwing on this platform, so readHookPayload returns '' — not null. The null
+  // path (an unreadable fd 0) is exercised indirectly by every gate's own tests via
+  // runGate, since forcing an EBADF/EAGAIN on fd 0 portably from node:test is not
+  // reliable across platforms.
+  assert.equal(emptyOutput, JSON.stringify(''));
+});
+
+test('deny writes a permissionDecision:deny hookSpecificOutput and exits 0', () => {
+  const output = runInChildProcess("mod.deny('my-gate', 'because reasons')", {
+    input: '',
+  });
+  const parsed = JSON.parse(output);
+  assert.equal(parsed.hookSpecificOutput.hookEventName, 'PreToolUse');
+  assert.equal(parsed.hookSpecificOutput.permissionDecision, 'deny');
+  assert.equal(
+    parsed.hookSpecificOutput.permissionDecisionReason,
+    '[my-gate] because reasons',
+  );
+});
+
+test('warn writes additionalContext and exits 0', () => {
+  const output = runInChildProcess("mod.warn('my-gate', 'consider this')", {
+    input: '',
+  });
+  const parsed = JSON.parse(output);
+  assert.equal(parsed.hookSpecificOutput.hookEventName, 'PreToolUse');
+  assert.equal(
+    parsed.hookSpecificOutput.additionalContext,
+    '[my-gate] consider this',
+  );
+  assert.equal(parsed.hookSpecificOutput.permissionDecision, undefined);
+});
+
+test('allow exits 0 with no stdout', () => {
+  const output = runInChildProcess('mod.allow()', { input: '' });
+  assert.equal(output, '');
+});