autoctxd 0.4.1

package/src/hooks/post-tool-use.ts

@@ -0,0 +1,205 @@
+#!/usr/bin/env bun
+// PostToolUse hook: captures and classifies each tool use as an observation
+
+import { getDb, closeDb } from "../db/sqlite/schema";
+import { insertObservation } from "../db/sqlite/observations";
+import { createSession } from "../db/sqlite/sessions";
+import { classifyObservation, extractFilePaths } from "../ai/classifier";
+import { recordExplorationCall, recordFirstEdit } from "../util/metrics";
+import { normalizePaths } from "../util/path";
+import { shouldIgnorePaths } from "../util/ignore";
+
+interface HookInput {
+  session_id: string;
+  transcript_path: string;
+  cwd: string;
+  hook_event_name: string;
+  tool_name: string;
+  tool_input: Record<string, any>;
+  tool_response?: any;
+  tool_use_id: string;
+}
+
+async function main() {
+  let input: HookInput;
+  try {
+    const raw = await Bun.stdin.text();
+    input = JSON.parse(raw);
+  } catch {
+    process.exit(0);
+  }
+
+  if (input.hook_event_name !== "PostToolUse") {
+    process.exit(0);
+  }
+
+  // Exploration tools: track for metrics but don't save as observations
+  const EXPLORATION_TOOLS = new Set(["Read", "Glob", "Grep"]);
+  // Tools that are pure noise — skip entirely
+  const SKIP_TOOLS = new Set(["TodoWrite", "AskUserQuestion"]);
+  // Substantive edit tools — trigger "first edit" recording
+  const EDIT_TOOLS = new Set(["Edit", "Write", "Bash"]);
+
+  if (SKIP_TOOLS.has(input.tool_name) || input.tool_name.startsWith("mcp__")) {
+    process.exit(0);
+  }
+
+  try {
+    // Ensure session exists
+    createSession({
+      session_id: input.session_id,
+      project_path: input.cwd,
+      git_repo: await getGitRepo(input.cwd),
+      git_branch: await getGitBranch(input.cwd),
+    });
+
+    // Track exploration calls for metrics (Read/Glob/Grep)
+    if (EXPLORATION_TOOLS.has(input.tool_name)) {
+      const exploredPath = input.tool_input.file_path
+        || input.tool_input.pattern
+        || input.tool_input.path
+        || "";
+      if (exploredPath) {
+        recordExplorationCall(input.session_id, exploredPath);
+      }
+      process.exit(0); // Don't save as observation
+    }
+
+    // Track first substantive action
+    if (EDIT_TOOLS.has(input.tool_name)) {
+      recordFirstEdit(input.session_id);
+    }
+
+    // Build a summary from tool input/response
+    const summary = buildSummary(input);
+    const filePaths = extractFilePathsFromInput(input);
+
+    // Honor .autoctxd-ignore at the project root before persisting anything.
+    if (shouldIgnorePaths(input.cwd, [input.cwd, ...filePaths])) {
+      process.exit(0);
+    }
+
+    const classification = classifyObservation(input.tool_name, summary, filePaths);
+
+    insertObservation({
+      session_id: input.session_id,
+      type: classification.type,
+      tool_name: input.tool_name,
+      summary,
+      file_paths: filePaths.join(","),
+      importance_score: classification.importance,
+    });
+  } catch (e) {
+    // Silently fail - don't interrupt Claude
+    const errorLog = Bun.file(`${import.meta.dir}/../../data/error.log`);
+    await Bun.write(errorLog, `${new Date().toISOString()} PostToolUse error: ${e}\n`);
+  } finally {
+    closeDb();
+  }
+
+  process.exit(0);
+}
+
+function buildSummary(input: HookInput): string {
+  const { tool_name, tool_input, tool_response } = input;
+
+  switch (tool_name) {
+    case "Edit": {
+      const file = tool_input.file_path || "file";
+      const oldSnippet = firstMeaningfulLine(tool_input.old_string || "", 80);
+      const newSnippet = firstMeaningfulLine(tool_input.new_string || "", 80);
+      return `Edited ${file}: ${oldSnippet} → ${newSnippet}`;
+    }
+
+    case "Write": {
+      const file = tool_input.file_path || "file";
+      const content = tool_input.content || "";
+      const firstLines = content.split("\n").filter((l: string) => l.trim()).slice(0, 3).join(" | ");
+      return `Wrote ${file} (${content.length} chars): ${truncate(firstLines, 160)}`;
+    }
+
+    case "Bash": {
+      const cmd = tool_input.command || "";
+      const desc = tool_input.description || "";
+      if (desc) {
+        return `Bash: ${truncate(desc, 200)}`;
+      }
+      const shortCmd = extractBashIntent(cmd);
+      return `Bash: ${truncate(shortCmd, 200)}`;
+    }
+
+    case "Agent":
+      return `Spawned agent: ${tool_input.description || ""} — ${truncate(tool_input.prompt || "", 160)}`;
+
+    case "WebFetch":
+      return `WebFetch ${tool_input.url || ""}: ${truncate(tool_input.prompt || "", 120)}`;
+
+    case "WebSearch":
+      return `WebSearch: ${tool_input.query || ""}`;
+
+    case "NotebookEdit":
+      return `Notebook ${tool_input.edit_mode || "edit"} ${tool_input.notebook_path || ""}`;
+
+    default:
+      return `${tool_name}: ${truncate(JSON.stringify(tool_input), 160)}`;
+  }
+}
+
+function firstMeaningfulLine(text: string, maxLen: number): string {
+  const line = text.split("\n").find(l => l.trim()) || text;
+  return truncate(line.trim(), maxLen);
+}
+
+function extractFilePathsFromInput(input: HookInput): string[] {
+  const raw: string[] = [];
+
+  if (input.tool_input.file_path) {
+    raw.push(input.tool_input.file_path);
+  }
+
+  if (input.tool_input.command) {
+    for (const fp of extractFilePaths(input.tool_input.command)) {
+      raw.push(fp);
+    }
+  }
+
+  return normalizePaths(raw);
+}
+
+async function getGitRepo(cwd: string): Promise<string | undefined> {
+  try {
+    const proc = Bun.spawn(["git", "remote", "get-url", "origin"], { cwd, stdout: "pipe", stderr: "pipe" });
+    const text = await new Response(proc.stdout).text();
+    return text.trim() || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function getGitBranch(cwd: string): Promise<string | undefined> {
+  try {
+    const proc = Bun.spawn(["git", "branch", "--show-current"], { cwd, stdout: "pipe", stderr: "pipe" });
+    const text = await new Response(proc.stdout).text();
+    return text.trim() || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function extractBashIntent(cmd: string): string {
+  const first = cmd.split("&&")[0].split(";")[0].trim();
+  if (/\b(npm|bun|pnpm|yarn)\s+(install|add|i|remove|run|test)\b/i.test(first)) return first;
+  if (/\b(git)\s+(commit|push|pull|merge|rebase|checkout|branch)\b/i.test(first)) return first;
+  if (/\b(pip|cargo|go)\s+(install|add|get|build|test)\b/i.test(first)) return first;
+  if (/\bcd\s+/.test(first) && cmd.includes("&&")) {
+    return extractBashIntent(cmd.split("&&").slice(1).join("&&"));
+  }
+  return first.length > 120 ? first.slice(0, 117) + "..." : first;
+}
+
+function truncate(s: string, max: number): string {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 3) + "...";
+}
+
+main();

package/src/hooks/pre-tool-use.ts

@@ -0,0 +1,305 @@
+#!/usr/bin/env bun
+// PreToolUse hook: session-start logic - injects semantic context on first tool use
+
+import { getDb, closeDb } from "../db/sqlite/schema";
+import { createSession, getRecentSessions } from "../db/sqlite/sessions";
+import { getRecentSummaries } from "../db/sqlite/summaries";
+import { getDecisionsByProject } from "../db/sqlite/decisions";
+import { formatContextBlock } from "../context/formatter";
+import { generateEmbedding } from "../db/vector/embeddings";
+import { searchSimilar, closeVectorDb } from "../db/vector/client";
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { debug } from "../util/debug";
+import { recordInjection } from "../util/metrics";
+import { getUnfinishedItems } from "../ai/proactive";
+import { normalizePath } from "../util/path";
+
+interface HookInput {
+  session_id: string;
+  transcript_path: string;
+  cwd: string;
+  hook_event_name: string;
+  tool_name: string;
+  tool_input: Record<string, any>;
+  tool_use_id: string;
+}
+
+const STATE_DIR = join(import.meta.dir, "..", "..", "data");
+const ACTIVE_SESSION_FILE = join(STATE_DIR, "active-session.json");
+
+async function main() {
+  let input: HookInput;
+  try {
+    const raw = await Bun.stdin.text();
+    input = JSON.parse(raw);
+  } catch {
+    process.exit(0);
+  }
+
+  if (input.hook_event_name !== "PreToolUse") {
+    process.exit(0);
+  }
+
+  try {
+    // Check if this is the first tool use of the session
+    const isFirstUse = checkAndSetActiveSession(input.session_id);
+
+    if (!isFirstUse) {
+      process.exit(0);
+    }
+
+    // Create session record
+    const gitBranch = await getGitBranch(input.cwd);
+    const gitRepo = await getGitRepo(input.cwd);
+
+    createSession({
+      session_id: input.session_id,
+      project_path: input.cwd,
+      git_repo: gitRepo,
+      git_branch: gitBranch,
+    });
+
+    // Build context from multiple sources in parallel
+    const [recentSummaries, decisions, hotFiles, patterns, semanticResults] = await Promise.all([
+      Promise.resolve(getRecentSummaries(input.cwd, 1, 3)),
+      Promise.resolve(getDecisionsByProject(input.cwd)),
+      Promise.resolve(getHotFiles(input.cwd)),
+      Promise.resolve(getPatterns(input.cwd)),
+      semanticSearch(input.cwd, gitBranch),
+    ]);
+
+    const recentSessions = getRecentSessions(input.cwd, 3);
+
+    // Only inject if we have something useful
+    if (recentSummaries.length === 0 && decisions.length === 0 && semanticResults.length === 0) {
+      process.exit(0);
+    }
+
+    // Merge semantic results into summaries if they're from different sessions
+    const allSummaries = [...recentSummaries];
+    for (const sr of semanticResults) {
+      if (!allSummaries.some(s => s.session_id === sr.session_id)) {
+        allSummaries.push({
+          session_id: sr.session_id,
+          level: sr.level,
+          text: sr.text,
+          project_path: sr.project_path,
+          created_at: sr.created_at,
+        });
+      }
+    }
+
+    const unfinished = getUnfinishedItems(input.cwd, 3);
+
+    const contextBlock = formatContextBlock({
+      projectPath: input.cwd,
+      gitBranch,
+      recentSessions,
+      recentSummaries: allSummaries.slice(0, 5),
+      decisions: decisions.slice(0, 5),
+      hotFiles,
+      patterns,
+      unfinished,
+    });
+
+    // Collect all files mentioned in context for hit-rate tracking
+    const injectedFiles: string[] = [...hotFiles];
+    for (const dec of decisions.slice(0, 5)) {
+      if (dec.files_affected) {
+        for (const f of dec.files_affected.split(",")) {
+          const trimmed = f.trim();
+          if (trimmed) injectedFiles.push(trimmed);
+        }
+      }
+    }
+
+    recordInjection(input.session_id, contextBlock, input.cwd, injectedFiles);
+    debug("pre-tool-use", "injected context", {
+      session: input.session_id.slice(0, 8),
+      project: input.cwd,
+      chars: contextBlock.length,
+      decisions: decisions.length,
+      summaries: allSummaries.length,
+      semantic: semanticResults.length,
+      unfinished: unfinished.length,
+    });
+
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        additionalContext: contextBlock,
+      },
+    };
+
+    console.log(JSON.stringify(output));
+  } catch (e) {
+    const errorLog = Bun.file(`${import.meta.dir}/../../data/error.log`);
+    await Bun.write(errorLog, `${new Date().toISOString()} PreToolUse error: ${e}\n`);
+  } finally {
+    closeDb();
+    await closeVectorDb();
+  }
+
+  process.exit(0);
+}
+
+function checkAndSetActiveSession(sessionId: string): boolean {
+  try {
+    if (existsSync(ACTIVE_SESSION_FILE)) {
+      const data = JSON.parse(readFileSync(ACTIVE_SESSION_FILE, "utf8"));
+      if (data.session_id === sessionId) {
+        return false;
+      }
+    }
+  } catch {
+    // Treat as first use
+  }
+
+  mkdirSync(STATE_DIR, { recursive: true });
+  writeFileSync(ACTIVE_SESSION_FILE, JSON.stringify({
+    session_id: sessionId,
+    started_at: new Date().toISOString(),
+  }));
+  return true;
+}
+
+async function semanticSearch(cwd: string, branch?: string): Promise<Array<{
+  session_id: string;
+  project_path: string;
+  text: string;
+  level: number;
+  created_at: string;
+}>> {
+  try {
+    // Build a richer query from actual project state rather than the path
+    const queryText = buildSemanticQuery(cwd, branch);
+    const embedding = await generateEmbedding(queryText);
+    // Cross-project search (no filter) so similar work in other repos can surface too
+    const results = await searchSimilar(Array.from(embedding), 8);
+    // Prefer same-project results but keep the richest matches overall
+    const sameProject = results.filter(r => r.project_path === cwd);
+    const otherProject = results.filter(r => r.project_path !== cwd).slice(0, 2);
+    return [...sameProject, ...otherProject].slice(0, 5);
+  } catch {
+    return [];
+  }
+}
+
+function buildSemanticQuery(cwd: string, branch?: string): string {
+  const db = getDb();
+  const parts: string[] = [];
+
+  // Project name + branch provide baseline signal
+  const projectName = cwd.split(/[/\\]/).filter(Boolean).slice(-2).join(" ");
+  parts.push(projectName);
+  if (branch) parts.push(`branch ${branch}`);
+
+  try {
+    // Pull titles of recent decisions — these describe the project's stack/architecture
+    const decs = db.prepare(
+      "SELECT title FROM decisions WHERE project_path = ? ORDER BY created_at DESC LIMIT 5"
+    ).all(cwd) as Array<{ title: string }>;
+    for (const d of decs) parts.push(d.title);
+
+    // Pull last session's first 200 chars — captures what we were just working on
+    const lastSum = db.prepare(
+      "SELECT text FROM summaries WHERE project_path = ? AND level = 1 ORDER BY created_at DESC LIMIT 1"
+    ).get(cwd) as { text: string } | undefined;
+    if (lastSum?.text) parts.push(lastSum.text.slice(0, 200));
+
+    // Recent hot files by basename
+    const hotRows = db.prepare(`
+      SELECT file_paths FROM observations o
+      JOIN sessions s ON o.session_id = s.session_id
+      WHERE s.project_path = ? AND o.file_paths IS NOT NULL
+      ORDER BY o.timestamp DESC LIMIT 40
+    `).all(cwd) as Array<{ file_paths: string }>;
+    const basenames = new Set<string>();
+    for (const r of hotRows) {
+      for (const fp of r.file_paths.split(",")) {
+        const base = fp.trim().split(/[/\\]/).pop();
+        if (base) basenames.add(base);
+      }
+    }
+    parts.push([...basenames].slice(0, 8).join(" "));
+  } catch {
+    // Missing historical data — fall back to project name alone
+  }
+
+  return parts.filter(Boolean).join(" ").slice(0, 1000);
+}
+
+function getHotFiles(projectPath: string): string[] {
+  const db = getDb();
+  try {
+    const rows = db.prepare(`
+      SELECT file_paths FROM observations o
+      JOIN sessions s ON o.session_id = s.session_id
+      WHERE s.project_path = ? AND o.file_paths IS NOT NULL AND o.file_paths != ''
+      ORDER BY o.timestamp DESC
+      LIMIT 100
+    `).all(projectPath) as Array<{ file_paths: string }>;
+
+    const counts = new Map<string, number>();
+    for (const row of rows) {
+      for (const fp of row.file_paths.split(",")) {
+        const norm = normalizePath(fp);
+        if (norm) {
+          counts.set(norm, (counts.get(norm) || 0) + 1);
+        }
+      }
+    }
+
+    return [...counts.entries()]
+      .filter(([, count]) => count >= 3)
+      .sort((a, b) => b[1] - a[1])
+      .map(([f]) => f);
+  } catch {
+    return [];
+  }
+}
+
+function getPatterns(projectPath: string): Array<{ pattern_type: string; description: string }> {
+  const db = getDb();
+  try {
+    // Dedupe by pattern_type — keep the highest-frequency row per type so two
+    // rows for the same insight (legacy duplicates) never both render.
+    return db.prepare(`
+      SELECT p.pattern_type, p.description
+      FROM patterns p
+      JOIN (
+        SELECT pattern_type, MAX(frequency) AS max_freq
+        FROM patterns WHERE project_path = ?
+        GROUP BY pattern_type
+      ) m ON m.pattern_type = p.pattern_type AND m.max_freq = p.frequency
+      WHERE p.project_path = ?
+      ORDER BY p.frequency DESC, p.last_seen DESC
+      LIMIT 5
+    `).all(projectPath, projectPath) as Array<{ pattern_type: string; description: string }>;
+  } catch {
+    return [];
+  }
+}
+
+async function getGitRepo(cwd: string): Promise<string | undefined> {
+  try {
+    const proc = Bun.spawn(["git", "remote", "get-url", "origin"], { cwd, stdout: "pipe", stderr: "pipe" });
+    const text = await new Response(proc.stdout).text();
+    return text.trim() || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function getGitBranch(cwd: string): Promise<string | undefined> {
+  try {
+    const proc = Bun.spawn(["git", "branch", "--show-current"], { cwd, stdout: "pipe", stderr: "pipe" });
+    const text = await new Response(proc.stdout).text();
+    return text.trim() || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+main();