claude-prism 0.3.1 → 0.4.0

package/lib/pipeline.mjs

@@ -0,0 +1,188 @@
+/**
+ * claude-prism — Hook Pipeline
+ * Runs multiple rules in a single hook invocation for reduced I/O
+ */
+
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { sanitizeId } from './utils.mjs';
+import { loadConfig } 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',
+  'UserPromptSubmit': 'prompt',
+};
+
+function parseInput() {
+  try {
+    return JSON.parse(readFileSync(0, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+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,
+    userPrompt: input.tool_input?.user_prompt ?? undefined,
+  };
+}
+
+function formatOutput(hookEventName, messages) {
+  if (messages.length === 0) return null;
+  return JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName,
+      additionalContext: messages.join('\n')
+    }
+  });
+}
+
+/**
+ * Run a pipeline of rules for a single hook event
+ * @param {Array<{name: string, rule: Object}>} rules - Rules with evaluate() methods
+ * @param {string} hookEventName - 'PreToolUse' or 'PostToolUse'
+ */
+export function runPipeline(rules, hookEventName) {
+  const input = parseInput();
+  if (!input) process.exit(0);
+
+  // Read config ONCE
+  const fullConfig = loadConfig(process.cwd());
+
+  const ctx = toContext(input, hookEventName);
+  const stateDir = getStateDir(ctx.sessionId, ctx.agentId);
+
+  const messages = [];
+  let blocked = false;
+  let blockMessage = '';
+
+  for (const { name, rule } of rules) {
+    // Build hook-specific config (same as getHookConfig but without re-reading file)
+    const hookConfig = fullConfig.hooks?.[name] || { enabled: true };
+    hookConfig.language = fullConfig.language || 'en';
+    hookConfig.sourceExtensions = fullConfig.sourceExtensions;
+    hookConfig.testPatterns = fullConfig.testPatterns;
+
+    if (!hookConfig.enabled) continue;
+
+    const result = rule.evaluate(ctx, hookConfig, stateDir);
+
+    if (result.type === 'block') {
+      blocked = true;
+      blockMessage = result.message || '🌈 Prism ✋ Action blocked.';
+      break; // First block wins, stop pipeline
+    }
+
+    if (result.message) {
+      messages.push(result.message);
+    }
+  }
+
+  if (blocked) {
+    process.stderr.write(blockMessage);
+    process.exit(2);
+  }
+
+  const output = formatOutput(hookEventName, messages);
+  if (output) {
+    process.stdout.write(output);
+  }
+}
+
+/**
+ * Load custom rules from config and merge with built-in rules
+ * @param {Array<{name: string, rule: Object}>} builtInRules
+ * @param {string[]} customRulePaths - Paths relative to project root
+ * @returns {Promise<Array<{name: string, rule: Object}>>}
+ */
+export async function loadCustomRules(builtInRules, customRulePaths) {
+  if (!customRulePaths || customRulePaths.length === 0) return builtInRules;
+
+  const rules = [...builtInRules];
+  for (const rulePath of customRulePaths) {
+    try {
+      const absPath = join(process.cwd(), rulePath);
+      const mod = await import(absPath);
+      const rule = mod.default || mod[Object.keys(mod)[0]];
+      if (rule && typeof rule.evaluate === 'function') {
+        rules.push({ name: rule.name || rulePath, rule });
+      }
+    } catch {
+      // Skip invalid rules silently — don't break the pipeline
+    }
+  }
+  return rules;
+}
+
+/**
+ * Run pipeline with custom rules support (async)
+ * @param {Array<{name: string, rule: Object}>} builtInRules
+ * @param {string} hookEventName - 'PreToolUse' or 'PostToolUse'
+ */
+export async function runPipelineAsync(builtInRules, hookEventName) {
+  const input = parseInput();
+  if (!input) process.exit(0);
+
+  const fullConfig = loadConfig(process.cwd());
+  const customRulePaths = fullConfig.customRules || [];
+  const rules = await loadCustomRules(builtInRules, customRulePaths);
+
+  const ctx = toContext(input, hookEventName);
+  const stateDir = getStateDir(ctx.sessionId, ctx.agentId);
+
+  const messages = [];
+  let blocked = false;
+  let blockMessage = '';
+
+  for (const { name, rule } of rules) {
+    const hookConfig = fullConfig.hooks?.[name] || { enabled: true };
+    hookConfig.language = fullConfig.language || 'en';
+    hookConfig.sourceExtensions = fullConfig.sourceExtensions;
+    hookConfig.testPatterns = fullConfig.testPatterns;
+
+    if (hookConfig.enabled === false) continue;
+
+    const result = rule.evaluate(ctx, hookConfig, stateDir);
+
+    if (result.type === 'block') {
+      blocked = true;
+      blockMessage = result.message || '🌈 Prism ✋ Action blocked.';
+      break;
+    }
+
+    if (result.message) {
+      messages.push(result.message);
+    }
+  }
+
+  if (blocked) {
+    process.stderr.write(blockMessage);
+    process.exit(2);
+  }
+
+  const output = formatOutput(hookEventName, messages);
+  if (output) {
+    process.stdout.write(output);
+  }
+}

package/lib/session.mjs

@@ -0,0 +1,108 @@
+/**
+ * claude-prism — Session Event Logger
+ * JSONL-based event recording for session analysis
+ */
+
+import { readFileSync, appendFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+const SESSION_ROOT = join(tmpdir(), '.prism', 'sessions');
+
+/**
+ * Get session log file path
+ */
+export function getSessionLogPath(sessionId) {
+  mkdirSync(SESSION_ROOT, { recursive: true, mode: 0o700 });
+  return join(SESSION_ROOT, `${sessionId}.jsonl`);
+}
+
+/**
+ * Append an event to the session log
+ */
+export function logEvent(sessionId, event) {
+  const logPath = getSessionLogPath(sessionId);
+  const entry = {
+    ts: Date.now(),
+    ...event
+  };
+  appendFileSync(logPath, JSON.stringify(entry) + '\n', { mode: 0o600 });
+}
+
+/**
+ * Read all events from a session log
+ */
+export function readSessionLog(sessionId) {
+  const logPath = getSessionLogPath(sessionId);
+  if (!existsSync(logPath)) return [];
+  try {
+    const content = readFileSync(logPath, 'utf8').trim();
+    if (!content) return [];
+    return content.split('\n').map(line => {
+      try { return JSON.parse(line); } catch { return null; }
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get session summary from event log
+ */
+export function getSessionSummary(sessionId) {
+  const events = readSessionLog(sessionId);
+  if (events.length === 0) return null;
+
+  const summary = {
+    sessionId,
+    totalEvents: events.length,
+    turns: 0,
+    filesCreated: 0,
+    filesModified: 0,
+    testsRun: 0,
+    testsPassed: 0,
+    testsFailed: 0,
+    blocks: 0,
+    warnings: 0,
+    startedAt: events[0]?.ts || null,
+    lastEventAt: events[events.length - 1]?.ts || null,
+  };
+
+  for (const event of events) {
+    switch (event.type) {
+      case 'turn':
+        summary.turns++;
+        break;
+      case 'file-edit':
+        summary.filesModified++;
+        break;
+      case 'file-create':
+        summary.filesCreated++;
+        break;
+      case 'test-run':
+        summary.testsRun++;
+        if (event.passed) summary.testsPassed++;
+        else summary.testsFailed++;
+        break;
+      case 'block':
+        summary.blocks++;
+        break;
+      case 'warn':
+        summary.warnings++;
+        break;
+    }
+  }
+
+  return summary;
+}
+
+/**
+ * List all session log files
+ */
+export function listSessions() {
+  if (!existsSync(SESSION_ROOT)) return [];
+  return readdirSync(SESSION_ROOT)
+    .filter(f => f.endsWith('.jsonl'))
+    .map(f => f.replace('.jsonl', ''))
+    .sort();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-prism",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "AI coding problem decomposition tool — Understand, Decompose, Execute, Checkpoint.",
   "type": "module",
   "bin": {
@@ -36,6 +36,14 @@
     "README.md",
     "README.ko.md"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lazysaturday91/claude-prism.git"
+  },
+  "homepage": "https://github.com/lazysaturday91/claude-prism#readme",
+  "bugs": {
+    "url": "https://github.com/lazysaturday91/claude-prism/issues"
+  },
   "author": "lazysaturday91",
   "license": "MIT"
 }

package/templates/runners/post-tool.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { runPipelineAsync } from '../lib/pipeline.mjs';
+import { debugLoop } from '../rules/debug-loop.mjs';
+import { scopeGuard } from '../rules/scope-guard.mjs';
+import { testTracker } from '../rules/test-tracker.mjs';
+import { alignment } from '../rules/alignment.mjs';
+
+await runPipelineAsync([
+  { name: 'debug-loop', rule: debugLoop },
+  { name: 'scope-guard', rule: scopeGuard },
+  { name: 'test-tracker', rule: testTracker },
+  { name: 'alignment', rule: alignment },
+], 'PostToolUse');

package/templates/runners/pre-tool.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runPipelineAsync } from '../lib/pipeline.mjs';
+import { commitGuard } from '../rules/commit-guard.mjs';
+import { alignment } from '../rules/alignment.mjs';
+
+await runPipelineAsync([
+  { name: 'commit-guard', rule: commitGuard },
+  { name: 'alignment', rule: alignment },
+], 'PreToolUse');

package/templates/runners/user-prompt.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { runPipelineAsync } from '../lib/pipeline.mjs';
+import { turnReporter } from '../rules/turn-reporter.mjs';
+
+await runPipelineAsync([
+  { name: 'turn-reporter', rule: turnReporter },
+], 'UserPromptSubmit');

package/templates/settings.json

@@ -6,40 +6,31 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node .claude/hooks/commit-guard.mjs",
-            "timeout": 5
+            "command": "node .claude/hooks/pre-tool.mjs",
+            "timeout": 5000
           }
         ]
       }
     ],
     "PostToolUse": [
       {
-        "matcher": "Edit|Write",
+        "matcher": "Edit|Write|Bash",
         "hooks": [
           {
             "type": "command",
-            "command": "node .claude/hooks/debug-loop.mjs",
-            "timeout": 5
+            "command": "node .claude/hooks/post-tool.mjs",
+            "timeout": 5000
           }
         ]
-      },
-      {
-        "matcher": "Edit|Write",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node .claude/hooks/scope-guard.mjs",
-            "timeout": 5
-          }
-        ]
-      },
+      }
+    ],
+    "UserPromptSubmit": [
       {
-        "matcher": "Bash",
         "hooks": [
           {
             "type": "command",
-            "command": "node .claude/hooks/test-tracker.mjs",
-            "timeout": 5
+            "command": "node .claude/hooks/user-prompt.mjs",
+            "timeout": 5000
           }
         ]
       }