synabun 1.3.0

package/hooks/claude-code/pre-compact.mjs

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+
+/**
+ * SynaBun PreCompact Hook for Claude Code
+ *
+ * Fires BEFORE context compaction (manual or auto). Reads the session
+ * transcript and caches a lightweight session summary so the post-compact
+ * SessionStart hook can inject it as context for automatic conversation
+ * indexing in SynaBun.
+ *
+ * Input (stdin JSON):
+ *   { session_id, transcript_path, cwd, trigger: "manual"|"auto", custom_instructions? }
+ *
+ * Output: exit code 0 (PreCompact hooks cannot inject context or block)
+ *
+ * Enable in .claude/settings.json:
+ * {
+ *   "hooks": {
+ *     "PreCompact": [{
+ *       "matcher": "",
+ *       "hooks": [{
+ *         "type": "command",
+ *         "command": "node \"<path-to-synabun>/hooks/claude-code/pre-compact.mjs\"",
+ *         "timeout": 10
+ *       }]
+ *     }]
+ *   }
+ * }
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, unlinkSync, statSync, appendFileSync } from 'node:fs';
+import { dirname, join, basename } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CACHE_DIR = join(__dirname, '..', '..', 'data', 'precompact');
+const PENDING_DIR = join(__dirname, '..', '..', 'data', 'pending-compact');
+const DEBUG_LOG = join(__dirname, '..', '..', 'data', 'compact-debug.log');
+
+// --- Stdin ---
+
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve('{}');
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => resolve(data));
+    setTimeout(() => resolve(data || '{}'), 3000);
+  });
+}
+
+// --- Transcript parsing ---
+
+function parseTranscript(transcriptPath) {
+  const userMessages = [];
+  const assistantSnippets = [];
+  const toolsUsed = new Set();
+  const filesModified = new Set();
+  const filesRead = new Set();
+  let totalTurns = 0;
+
+  try {
+    const content = readFileSync(transcriptPath, 'utf-8');
+    const lines = content.split('\n').filter(l => l.trim());
+
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+
+        if (entry.role === 'user') {
+          totalTurns++;
+          // Extract text from user messages (string or content array)
+          if (typeof entry.content === 'string') {
+            const text = entry.content.trim();
+            if (text && !text.startsWith('{') && text.length > 5) {
+              userMessages.push(text.slice(0, 300));
+            }
+          } else if (Array.isArray(entry.content)) {
+            for (const block of entry.content) {
+              if (block.type === 'text' && block.text) {
+                const text = block.text.trim();
+                if (text && !text.startsWith('{') && text.length > 5) {
+                  userMessages.push(text.slice(0, 300));
+                }
+              }
+            }
+          }
+        }
+
+        if (entry.role === 'assistant' && Array.isArray(entry.content)) {
+          for (const block of entry.content) {
+            // Capture tool usage
+            if (block.type === 'tool_use') {
+              toolsUsed.add(block.name);
+              const input = block.input || {};
+
+              // Track file modifications
+              if (['Edit', 'Write', 'NotebookEdit'].includes(block.name) && input.file_path) {
+                filesModified.add(input.file_path);
+              }
+              if (block.name === 'Read' && input.file_path) {
+                filesRead.add(input.file_path);
+              }
+              // Track bash commands that modify files
+              if (block.name === 'Bash' && input.command) {
+                const cmd = input.command;
+                if (/\bgit\s+(add|commit|push|merge|rebase|checkout)/.test(cmd)) {
+                  toolsUsed.add('git');
+                }
+                if (/\bnpm\s+(install|run|test|build)/.test(cmd)) {
+                  toolsUsed.add('npm');
+                }
+              }
+            }
+
+            // Capture assistant text snippets (first few)
+            if (block.type === 'text' && block.text && assistantSnippets.length < 5) {
+              const text = block.text.trim();
+              if (text.length > 20) {
+                assistantSnippets.push(text.slice(0, 200));
+              }
+            }
+          }
+        }
+      } catch { /* skip malformed lines */ }
+    }
+  } catch { /* transcript unreadable */ }
+
+  return {
+    userMessages: userMessages.slice(0, 15),
+    assistantSnippets,
+    toolsUsed: [...toolsUsed],
+    filesModified: [...filesModified],
+    filesRead: [...filesRead].slice(0, 20),
+    totalTurns,
+  };
+}
+
+// --- Cleanup old cache files (older than 2 hours) ---
+
+function cleanupOldCache() {
+  try {
+    if (!existsSync(CACHE_DIR)) return;
+    const cutoff = Date.now() - 2 * 60 * 60 * 1000;
+    for (const file of readdirSync(CACHE_DIR)) {
+      const filePath = join(CACHE_DIR, file);
+      try {
+        const stat = statSync(filePath);
+        if (stat.mtimeMs < cutoff) unlinkSync(filePath);
+      } catch { /* skip */ }
+    }
+  } catch { /* ignore cleanup errors */ }
+}
+
+// --- Main ---
+
+async function main() {
+  let input = {};
+  try {
+    const raw = await readStdin();
+    input = JSON.parse(raw);
+  } catch { /* proceed with defaults */ }
+
+  const sessionId = input.session_id || '';
+  const transcriptPath = input.transcript_path || '';
+  const trigger = input.trigger || 'unknown';
+  const cwd = input.cwd || '';
+
+  if (!sessionId || !transcriptPath) {
+    process.exit(0);
+    return;
+  }
+
+  // Parse transcript for key data
+  const parsed = parseTranscript(transcriptPath);
+
+  // Build cache object
+  const cache = {
+    session_id: sessionId,
+    transcript_path: transcriptPath,
+    trigger,
+    cwd,
+    cached_at: new Date().toISOString(),
+    user_message_count: parsed.userMessages.length,
+    total_turns: parsed.totalTurns,
+    user_messages: parsed.userMessages,
+    assistant_snippets: parsed.assistantSnippets,
+    tools_used: parsed.toolsUsed,
+    files_modified: parsed.filesModified,
+    files_read: parsed.filesRead,
+  };
+
+  // Capture active loop state for compaction recovery
+  const LOOP_DIR = join(__dirname, '..', '..', 'data', 'loop');
+  const loopPath = join(LOOP_DIR, `${sessionId}.json`);
+  if (existsSync(loopPath)) {
+    try {
+      const loopState = JSON.parse(readFileSync(loopPath, 'utf-8'));
+      if (loopState.active) {
+        cache.loop = {
+          active: true,
+          task: loopState.task,
+          context: loopState.context,
+          currentIteration: loopState.currentIteration,
+          totalIterations: loopState.totalIterations,
+          maxMinutes: loopState.maxMinutes,
+          startedAt: loopState.startedAt,
+          progressSummary: loopState.progressSummary || null,
+          journal: (loopState.journal || []).slice(-5),
+          lastMemoryAt: loopState.lastMemoryAt || 0,
+          usesBrowser: loopState.usesBrowser || false,
+        };
+      }
+    } catch { /* skip */ }
+  }
+
+  // Write cache
+  if (!existsSync(CACHE_DIR)) mkdirSync(CACHE_DIR, { recursive: true });
+  writeFileSync(join(CACHE_DIR, `${sessionId}.json`), JSON.stringify(cache, null, 2));
+
+  // Write pending flag — Stop hook will block until this is cleared by PostToolUse
+  if (!existsSync(PENDING_DIR)) mkdirSync(PENDING_DIR, { recursive: true });
+  writeFileSync(join(PENDING_DIR, `${sessionId}.json`), JSON.stringify({
+    session_id: sessionId,
+    created_at: new Date().toISOString(),
+    retries: 0,
+  }));
+
+  // Debug logging
+  try {
+    appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] PRE-COMPACT session_id=${sessionId} trigger=${trigger} cwd=${cwd}\n`);
+  } catch { /* ok */ }
+
+  // Cleanup old files
+  cleanupOldCache();
+
+  process.exit(0);
+}
+
+main().catch(() => process.exit(0));

package/hooks/claude-code/pre-websearch.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+/**
+ * SynaBun PreToolUse Hook — Block WebSearch/WebFetch when browser is active
+ *
+ * Matches: ^WebSearch$|^WebFetch$
+ *
+ * Blocks these tools when SynaBun's Neural Interface is reachable AND:
+ *   1. An active loop with usesBrowser=true exists, OR
+ *   2. Any browser session is currently open
+ *
+ * If the Neural Interface is unreachable (SynaBun offline), all checks are
+ * skipped — loop files on disk may be stale and cannot be trusted.
+ *
+ * Input (stdin JSON):
+ *   { session_id, tool_name, tool_input: { ... } }
+ *
+ * Output (stdout JSON):
+ *   - If blocked: { decision: "block", reason: "..." }
+ *   - If allowed: {}
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SYNABUN_ROOT = join(__dirname, '..', '..');
+const LOOP_DIR = join(SYNABUN_ROOT, 'data', 'loop');
+const NI_BASE = process.env.SYNABUN_NI_URL || 'http://localhost:3344';
+
+const BLOCK_REASON = (toolName) =>
+  `BLOCKED: ${toolName} is not allowed while a SynaBun browser session is open. Use the SynaBun browser tools (browser_navigate, browser_click, browser_content, etc.) instead. If the page requires login or CAPTCHA, STOP and tell the user what they need to do in the browser panel. Do NOT fall back to web search.`;
+
+let input = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', async () => {
+  try {
+    const { session_id, tool_name } = JSON.parse(input);
+
+    // First, check if the Neural Interface is reachable.
+    // If it's down, skip all checks — loop files may be stale.
+    let niReachable = false;
+    let activeBrowserSessions = [];
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 2000);
+      const res = await fetch(`${NI_BASE}/api/browser/sessions`, { signal: controller.signal });
+      clearTimeout(timeout);
+      if (res.ok) {
+        niReachable = true;
+        const data = await res.json();
+        activeBrowserSessions = data.sessions || [];
+      }
+    } catch {
+      // Neural Interface not reachable — allow all tools
+    }
+
+    if (!niReachable) {
+      process.stdout.write(JSON.stringify({}));
+      return;
+    }
+
+    // Check 1: Active loop with usesBrowser (only trusted when NI is reachable)
+    if (existsSync(LOOP_DIR)) {
+      const files = readdirSync(LOOP_DIR).filter(f => f.endsWith('.json') && !f.startsWith('pending-'));
+      for (const file of files) {
+        try {
+          const loop = JSON.parse(readFileSync(join(LOOP_DIR, file), 'utf-8'));
+          if (loop.active && loop.usesBrowser) {
+            process.stdout.write(JSON.stringify({ decision: 'block', reason: BLOCK_REASON(tool_name) }));
+            return;
+          }
+        } catch { /* skip corrupt files */ }
+      }
+    }
+
+    // Check 2: Any active browser session via the NI response we already fetched
+    if (activeBrowserSessions.length > 0) {
+      process.stdout.write(JSON.stringify({ decision: 'block', reason: BLOCK_REASON(tool_name) }));
+      return;
+    }
+
+    // No browser activity — allow the tool
+    process.stdout.write(JSON.stringify({}));
+  } catch {
+    process.stdout.write(JSON.stringify({}));
+  }
+});