claude-prism 0.1.0

package/hooks/debug-loop.mjs

@@ -0,0 +1,67 @@
+/**
+ * claude-prism — Debug Loop Detector
+ * Warns on repeated edits to same file, blocks at threshold
+ */
+
+import { createHash } from 'crypto';
+import { readState, writeState, readJsonState, writeJsonState } from '../lib/state.mjs';
+
+export const debugLoop = {
+  name: 'debug-loop',
+
+  evaluate(ctx, config, stateDir) {
+    const filePath = ctx.filePath;
+    if (!filePath) return { type: 'pass' };
+
+    // Skip non-source files
+    if (!/\.(ts|tsx|js|jsx|py|go|rs|java|c|cpp|h)$/.test(filePath)) return { type: 'pass' };
+
+    const hash = createHash('md5').update(filePath).digest('hex').slice(0, 8);
+    const countKey = `edit-count-${hash}`;
+    const logKey = `edit-log-${hash}`;
+
+    // Increment counter
+    const prev = parseInt(readState(stateDir, countKey) || '0', 10) || 0;
+    const count = prev + 1;
+    writeState(stateDir, countKey, String(count));
+
+    // Track edit snippets for pattern analysis
+    const oldStr = ctx.oldString || '';
+    let editLog = readJsonState(stateDir, logKey) || [];
+    const snippet = oldStr.slice(0, 80).replace(/\n/g, '\\n');
+    editLog.push({ edit: count, snippet, ts: Date.now() });
+    if (editLog.length > 10) editLog = editLog.slice(-10);
+    writeJsonState(stateDir, logKey, editLog);
+
+    const name = filePath.split('/').pop();
+
+    if (count === config.warnAt) {
+      const pattern = analyzePattern(editLog);
+      const hint = pattern === 'divergent'
+        ? ' Pattern: DIVERGENT — same area edited repeatedly.'
+        : '';
+      return {
+        type: 'warn',
+        message: `🌈 Prism > Debug Loop: ${name} edited ${count} times.${hint} Stop and investigate root cause.`
+      };
+    }
+
+    if (count >= config.blockAt) {
+      return {
+        type: 'block',
+        message: `🌈 Prism ✋ Debug Loop blocked: ${name} edited ${count} times. Discuss approach with user before continuing.`
+      };
+    }
+
+    return { type: 'pass' };
+  }
+};
+
+function analyzePattern(log) {
+  if (log.length < 3) return null;
+  const recent = log.slice(-3).map(e => e.snippet);
+  const uniqueSnippets = new Set(recent).size;
+  if (uniqueSnippets === 1) return 'divergent';
+  const overlap = recent.filter(s => recent[0] && s.includes(recent[0].slice(0, 20))).length;
+  return overlap >= 2 ? 'divergent' : 'convergent';
+}

package/hooks/scope-guard.mjs

@@ -0,0 +1,61 @@
+/**
+ * claude-prism — Scope Guard
+ * Warns when too many unique files are modified without a plan
+ */
+
+import { readJsonState, writeJsonState } from '../lib/state.mjs';
+
+const SOURCE_PATTERN = /\.(ts|tsx|js|jsx|py|go|rs|java|c|cpp|h|svelte|vue)$/;
+const TEST_PATTERN = /\.(test|spec|_test)\./;
+const PLAN_PATTERN = /(?:^|\/)docs\/plans\/.*\.md$|(?:^|\/).*plan.*\.md$/i;
+
+export const scopeGuard = {
+  name: 'scope-guard',
+
+  evaluate(ctx, config, stateDir) {
+    const filePath = ctx.filePath;
+    if (!filePath) return { type: 'pass' };
+
+    // Plan file created → reset scope (user is decomposing properly)
+    if (PLAN_PATTERN.test(filePath)) {
+      writeJsonState(stateDir, 'scope-files', []);
+      return { type: 'pass', message: '🌈 Prism 📋 Plan file detected. Scope counter reset.' };
+    }
+
+    // Only track source files
+    if (!SOURCE_PATTERN.test(filePath)) return { type: 'pass' };
+
+    // Don't count test files toward scope
+    if (TEST_PATTERN.test(filePath)) return { type: 'pass' };
+
+    // Track unique files
+    let files = readJsonState(stateDir, 'scope-files') || [];
+    if (!files.includes(filePath)) {
+      files.push(filePath);
+      writeJsonState(stateDir, 'scope-files', files);
+    }
+
+    const count = files.length;
+
+    // Agent-aware thresholds: sub-agents get higher limits
+    const isAgent = ctx.agentId && ctx.agentId !== '' && ctx.agentId !== 'default';
+    const warnAt = isAgent ? (config.agentWarnAt || 8) : (config.warnAt || 4);
+    const blockAt = isAgent ? (config.agentBlockAt || 12) : (config.blockAt || 7);
+
+    if (count >= blockAt) {
+      return {
+        type: 'block',
+        message: `🌈 Prism ✋ Scope Guard: ${count} unique files modified without a plan. Run /prism to decompose before continuing.`
+      };
+    }
+
+    if (count >= warnAt) {
+      return {
+        type: 'warn',
+        message: `🌈 Prism > Scope Guard: ${count} unique files modified. Consider running /prism to decompose the task.`
+      };
+    }
+
+    return { type: 'pass' };
+  }
+};

package/hooks/test-tracker.mjs

@@ -0,0 +1,61 @@
+/**
+ * claude-prism — Test Tracker
+ * Detects test commands and records results for commit-guard
+ */
+
+import { writeState } from '../lib/state.mjs';
+
+const TEST_PATTERNS = [
+  /\bnpm\s+test\b/,
+  /\bnode\s+--test\b/,
+  /\bjest\b/,
+  /\bvitest\b/,
+  /\bpytest\b/,
+  /\bmocha\b/,
+  /\bcargo\s+test\b/,
+  /\bgo\s+test\b/,
+  /\bmake\s+test\b/,
+  /\bnpx\s+(jest|vitest|mocha)\b/,
+];
+
+export const testTracker = {
+  name: 'test-tracker',
+
+  evaluate(ctx, config, stateDir) {
+    const command = ctx.command || '';
+
+    const isTestCommand = TEST_PATTERNS.some(p => p.test(command));
+    if (!isTestCommand) return { type: 'pass' };
+
+    // Record timestamp
+    const now = Math.floor(Date.now() / 1000);
+    writeState(stateDir, 'last-test-run', String(now));
+
+    // Record result — Claude Code does not provide exitCode,
+    // so we infer pass/fail from stdout and interrupted flag
+    let passed;
+    if (ctx.interrupted) {
+      passed = false;
+    } else {
+      const stdout = ctx.stdout || '';
+      const failMatch = stdout.match(/# fail (\d+)/);
+      if (failMatch) {
+        passed = parseInt(failMatch[1], 10) === 0;
+      } else if (/(?:FAIL|FAILED|ERROR)\b/i.test(stdout) && !/# pass \d+/.test(stdout)) {
+        passed = false;
+      } else {
+        passed = true;
+      }
+    }
+    writeState(stateDir, 'last-test-result', passed ? 'pass' : 'fail');
+
+    if (!passed) {
+      return {
+        type: 'warn',
+        message: '🌈 Prism 📊 Tests FAILED. Fix before committing.'
+      };
+    }
+
+    return { type: 'pass' };
+  }
+};

package/lib/adapter.mjs

@@ -0,0 +1,89 @@
+/**
+ * claude-prism — Claude Code Adapter
+ * Translates between Claude Code hook protocol and prism rules
+ */
+
+import { readFileSync } from 'fs';
+import { sanitizeId } from './utils.mjs';
+import { getHookConfig } from './config.mjs';
+import { getStateDir } from './state.mjs';
+
+const TOOL_ACTION_MAP = {
+  'Edit': 'edit',
+  'Write': 'write',
+  'Bash': 'command',
+  'Read': 'read',
+  'Task': 'subagent',
+};
+
+const EVENT_PHASE_MAP = {
+  'PreToolUse': 'pre',
+  'PostToolUse': 'post',
+};
+
+export function parseInput() {
+  try {
+    return JSON.parse(readFileSync(0, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function toContext(input, hookEventName) {
+  const toolName = input.tool_name || '';
+  return {
+    action: TOOL_ACTION_MAP[toolName] || toolName.toLowerCase(),
+    phase: EVENT_PHASE_MAP[hookEventName] || 'pre',
+    filePath: input.tool_input?.file_path || undefined,
+    command: input.tool_input?.command || undefined,
+    oldString: input.tool_input?.old_string || undefined,
+    sessionId: sanitizeId(input.session_id),
+    agentId: sanitizeId(input.agent_id || ''),
+    stdout: input.tool_response?.stdout ?? undefined,
+    stderr: input.tool_response?.stderr ?? undefined,
+    interrupted: input.tool_response?.interrupted ?? false,
+  };
+}
+
+export function formatOutput(hookEventName, result) {
+  if (result.type === 'pass' && !result.message) return null;
+
+  const parts = [];
+  if (result.message) parts.push(result.message);
+  if (parts.length === 0) return null;
+
+  return JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName,
+      additionalContext: parts.join('\n')
+    }
+  });
+}
+
+/**
+ * Run a hook rule via Claude Code protocol
+ * @param {string} ruleName
+ * @param {string} hookEventName
+ * @param {Object} rule - Rule with evaluate() method
+ */
+export function runHook(ruleName, hookEventName, rule) {
+  const config = getHookConfig(ruleName, process.cwd());
+  if (!config.enabled) process.exit(0);
+
+  const input = parseInput();
+  if (!input) process.exit(0);
+
+  const ctx = toContext(input, hookEventName);
+  const stateDir = getStateDir(ctx.sessionId, ctx.agentId);
+  const result = rule.evaluate(ctx, config, stateDir);
+
+  if (result.type === 'block') {
+    process.stderr.write(result.message || '🌈 Prism ✋ Action blocked.');
+    process.exit(2);
+  }
+
+  const output = formatOutput(hookEventName, result);
+  if (output) {
+    process.stdout.write(output);
+  }
+}

package/lib/config.mjs

@@ -0,0 +1,54 @@
+/**
+ * claude-prism — Configuration Loader
+ * Reads .claude-prism.json from project root, with defaults
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const DEFAULTS = {
+  language: 'en',
+  hooks: {
+    'commit-guard': { enabled: true, maxTestAge: 300 },
+    'debug-loop': { enabled: true, warnAt: 3, blockAt: 5 },
+    'test-tracker': { enabled: true },
+    'scope-guard': { enabled: true, warnAt: 4, blockAt: 7, agentWarnAt: 8, agentBlockAt: 12 }
+  }
+};
+
+export function loadConfig(projectRoot) {
+  const configPath = join(projectRoot, '.claude-prism.json');
+
+  if (!existsSync(configPath)) {
+    return JSON.parse(JSON.stringify(DEFAULTS));
+  }
+
+  try {
+    const userConfig = JSON.parse(readFileSync(configPath, 'utf8'));
+    return deepMerge(DEFAULTS, userConfig);
+  } catch {
+    return JSON.parse(JSON.stringify(DEFAULTS));
+  }
+}
+
+export function getHookConfig(hookName, projectRoot) {
+  const config = loadConfig(projectRoot);
+  return config.hooks?.[hookName] || DEFAULTS.hooks[hookName] || { enabled: true };
+}
+
+const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (DANGEROUS_KEYS.has(key)) continue;
+    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      result[key] = deepMerge(target[key] || {}, source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+export { DEFAULTS };