@devrik-tools/claude-gates 0.1.1 → 0.1.3

package/plugins/gates/hooks/gates/never-assume/index.mjs

@@ -1,55 +1,58 @@
-import { runGate, warn, TOOL_GROUPS } from '../../lib/hook-io.mjs';
-
-const GATE_ID = 'never-assume';
-const CONFIG_KEY = 'requireVerificationBeforeAssuming';
-
-const DEFAULT_CONJECTURE_PATTERNS = [
-  'i assume',
-  'assuming that',
-  'probably',
-  'i guess',
-  'should be',
-  "i'll default to",
-];
-
-function extractContent(toolName, toolInput) {
-  if (TOOL_GROUPS.delegation.includes(toolName)) return toolInput?.prompt;
-  return toolInput?.content ?? toolInput?.new_string;
-}
-
-runGate(
-  {
-    id: GATE_ID,
-    configKey: CONFIG_KEY,
-    enabledByDefault: false,
-    defaultParams: {
-      conjecturePatterns: DEFAULT_CONJECTURE_PATTERNS,
-    },
-  },
-  ({ toolName, toolInput, parameters }) => {
-    const isWrite = TOOL_GROUPS.write.includes(toolName);
-    const isDelegation = TOOL_GROUPS.delegation.includes(toolName);
-    if (!isWrite && !isDelegation) return;
-
-    const content = extractContent(toolName, toolInput);
-    if (typeof content !== 'string') return;
-
-    const patterns = parameters.conjecturePatterns.map(
-      (source) => new RegExp(source, 'i'),
-    );
-    const hits = [];
-    for (const pattern of patterns) {
-      const match = content.match(pattern);
-      if (match) hits.push(match[0]);
-    }
-    if (hits.length === 0) return;
-
-    warn(
-      GATE_ID,
-      `Content contains conjecture phrasing without stated verification: ${hits.join(', ')}. Verify before asserting instead of assuming.`,
-    );
-  },
-);
-
-// The source guard (guard-never-assume.mjs) is explicit: this never denies,
-// only warns — conjecture language is a prompt to verify, not a blocker.
+import {
+  runGate,
+  warn,
+  toolInGroups,
+  writtenContentOf,
+  delegationPromptOf,
+} from '../../lib/hook-io.mjs';
+import { CONJECTURE_SOURCES } from '../../lib/signals.mjs';
+
+const GATE_ID = 'never-assume';
+const CONFIG_KEY = 'requireVerificationBeforeAssuming';
+
+// Bilingual (ES+EN) conjecture phrasing, centralized in lib/signals.mjs so every gate
+// that needs to recognize unverified-assumption prose shares the same coverage. See
+// signals.mjs header for the ES/EN-only limitation.
+const DEFAULT_CONJECTURE_PATTERNS = CONJECTURE_SOURCES;
+
+function extractContent(toolName, toolInput) {
+  if (toolInGroups(toolName, ['delegation'])) return delegationPromptOf(toolInput);
+  return writtenContentOf(toolInput);
+}
+
+runGate(
+  {
+    id: GATE_ID,
+    configKey: CONFIG_KEY,
+    enabledByDefault: false,
+    defaultParams: {
+      conjecturePatterns: DEFAULT_CONJECTURE_PATTERNS,
+    },
+  },
+  ({ toolName, toolInput, parameters }) => {
+    const isWrite = toolInGroups(toolName, ['write']);
+    const isDelegation = toolInGroups(toolName, ['delegation']);
+    if (!isWrite && !isDelegation) return;
+
+    const content = extractContent(toolName, toolInput);
+    if (!content) return;
+
+    const patterns = parameters.conjecturePatterns.map(
+      (source) => new RegExp(source, 'i'),
+    );
+    const hits = [];
+    for (const pattern of patterns) {
+      const match = content.match(pattern);
+      if (match) hits.push(match[0]);
+    }
+    if (hits.length === 0) return;
+
+    warn(
+      GATE_ID,
+      `Content contains conjecture phrasing without stated verification: ${hits.join(', ')}. Verify before asserting instead of assuming.`,
+    );
+  },
+);
+
+// The source guard (guard-never-assume.mjs) is explicit: this never denies,
+// only warns — conjecture language is a prompt to verify, not a blocker.

package/plugins/gates/hooks/gates/never-assume/never-assume.edge.test.mjs

@@ -0,0 +1,71 @@
+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(), 'never-assume-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;
+}
+
+const ENABLE = { config: { gates: { requireVerificationBeforeAssuming: true } } };
+
+// FIXED: extractContent() now reads through writtenContentOf() (lib/hook-io.mjs), which
+// covers NotebookEdit's new_source field, closing the tool-coverage gap this test used to
+// document as a bug.
+test('FIXED: conjecture phrasing written via NotebookEdit is detected', () => {
+  const payload = {
+    tool_name: 'NotebookEdit',
+    tool_input: {
+      notebook_path: '/repo/nb.ipynb',
+      cell_id: 'x',
+      new_source: '# i assume the timezone is UTC',
+      cell_type: 'code',
+    },
+  };
+  assert.ok(isWarn(runGate(payload, ENABLE)), 'gate now detects conjecture phrasing via NotebookEdit');
+});
+
+// EDGE CASE (BUG): 'invoke_subagent' is a declared delegation tool name (TOOL_GROUPS.delegation
+// in lib/hook-io.mjs) and is matched in hooks.json, but extractContent() branches on
+// TOOL_GROUPS.delegation.includes(toolName) which DOES include invoke_subagent — so this one
+// should actually work. Verify it does (a real behavioral check, not a bug) to make sure the
+// delegation branch itself is sound before concluding the write-side gap is the only issue.
+test('OK: conjecture phrasing in an invoke_subagent prompt is detected (delegation branch is sound)', () => {
+  const payload = {
+    tool_name: 'invoke_subagent',
+    tool_input: { prompt: 'i assume the config is already loaded, proceed' },
+  };
+  assert.ok(isWarn(runGate(payload, ENABLE)));
+});
+
+// EDGE CASE: false-positive check — "should be" is a very broad conjecture pattern that can
+// match ordinary correct engineering prose describing an invariant, not an unverified guess,
+// e.g. "the response should be a 200 for valid input" (spec language, not conjecture).
+test('OK/expected-noise: "should be" fires even on spec-style invariant language (broad pattern, not a bug but a known false-positive source)', () => {
+  const result = runGate(
+    { tool_name: 'Write', tool_input: { file_path: '/repo/x.js', content: '// per the spec, the response should be a 200 for valid input' } },
+    ENABLE,
+  );
+  assert.ok(isWarn(result), 'documents that "should be" over-fires on legitimate spec prose, not just conjecture');
+});

package/plugins/gates/hooks/gates/never-assume/test.mjs

@@ -1,78 +1,95 @@
-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(), 'never-assume-'));
-  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/x.js', content },
-  };
-}
-function isWarn(result) {
-  return result?.hookSpecificOutput?.additionalContext !== undefined;
-}
-function isDeny(result) {
-  return result?.hookSpecificOutput?.permissionDecision === 'deny';
-}
-
-const ENABLE = {
-  config: { gates: { requireVerificationBeforeAssuming: true } },
-};
-
-test('warns on conjecture phrasing', () => {
-  assert.ok(isWarn(runGate(write('// i assume the timezone is UTC'), ENABLE)));
-  assert.ok(isWarn(runGate(write('// probably fine to skip this'), ENABLE)));
-});
-
-test('never denies, only warns', () => {
-  const result = runGate(write('// i assume this works'), ENABLE);
-  assert.ok(isWarn(result));
-  assert.ok(!isDeny(result));
-});
-
-test('allows content without conjecture phrasing', () => {
-  assert.equal(runGate(write('const x = 1;'), ENABLE), null);
-});
-
-test('disabled by default (registry default is false)', () => {
-  assert.equal(runGate(write('// i assume this works')), null);
-});
-
-test('project conjecturePatterns override replaces the built-in list', () => {
-  const config = {
-    gates: {
-      requireVerificationBeforeAssuming: {
-        enabled: true,
-        conjecturePatterns: ['totally made up'],
-      },
-    },
-  };
-  assert.equal(runGate(write('// i assume this works'), { config }), null);
-  assert.ok(
-    isWarn(runGate(write('// totally made up value here'), { config })),
-  );
-});
+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(), 'never-assume-'));
+  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/x.js', content },
+  };
+}
+function isWarn(result) {
+  return result?.hookSpecificOutput?.additionalContext !== undefined;
+}
+function isDeny(result) {
+  return result?.hookSpecificOutput?.permissionDecision === 'deny';
+}
+
+const ENABLE = {
+  config: { gates: { requireVerificationBeforeAssuming: true } },
+};
+
+test('warns on conjecture phrasing', () => {
+  assert.ok(isWarn(runGate(write('// i assume the timezone is UTC'), ENABLE)));
+  assert.ok(isWarn(runGate(write('// probably fine to skip this'), ENABLE)));
+});
+
+test('never denies, only warns', () => {
+  const result = runGate(write('// i assume this works'), ENABLE);
+  assert.ok(isWarn(result));
+  assert.ok(!isDeny(result));
+});
+
+test('allows content without conjecture phrasing', () => {
+  assert.equal(runGate(write('const x = 1;'), ENABLE), null);
+});
+
+test('disabled by default (registry default is false)', () => {
+  assert.equal(runGate(write('// i assume this works')), null);
+});
+
+test('warns on conjecture phrasing in Spanish', () => {
+  assert.ok(isWarn(runGate(write('// supongo que la zona horaria es UTC'), ENABLE)));
+  assert.ok(isWarn(runGate(write('// probablemente sea correcto omitir esto'), ENABLE)));
+  assert.ok(isWarn(runGate(write('// deberia ser suficiente con este chequeo'), ENABLE)));
+});
+
+test('bilingual control: ES and EN equivalent conjecture briefs both warn', () => {
+  const es = write('// creo que el usuario ya esta autenticado, no lo verifique');
+  const en = write('// i assume the user is already authenticated, did not verify it');
+  assert.ok(isWarn(runGate(es, ENABLE)));
+  assert.ok(isWarn(runGate(en, ENABLE)));
+});
+
+test('allows neutral Spanish content without conjecture phrasing', () => {
+  assert.equal(runGate(write('const contrasena = "verificada";'), ENABLE), null);
+});
+
+test('project conjecturePatterns override replaces the built-in list', () => {
+  const config = {
+    gates: {
+      requireVerificationBeforeAssuming: {
+        enabled: true,
+        conjecturePatterns: ['totally made up'],
+      },
+    },
+  };
+  assert.equal(runGate(write('// i assume this works'), { config }), null);
+  assert.ok(
+    isWarn(runGate(write('// totally made up value here'), { config })),
+  );
+});