autoctxd 0.4.1

package/src/hooks/stop.ts

@@ -0,0 +1,334 @@
+#!/usr/bin/env bun
+// Stop hook: session-end logic - compress observations, generate embeddings, detect patterns
+
+import { getDb, closeDb } from "../db/sqlite/schema";
+import { getObservationsBySession, countObservationsBySession } from "../db/sqlite/observations";
+import { endSession } from "../db/sqlite/sessions";
+import { insertSummary } from "../db/sqlite/summaries";
+import { insertDecision } from "../db/sqlite/decisions";
+import { compressSession } from "../ai/compressor";
+import { extractDecisionsFromObservations } from "../ai/decision-extractor";
+import { generateEmbedding } from "../db/vector/embeddings";
+import { addVector, closeVectorDb } from "../db/vector/client";
+import { detectPatterns } from "../ai/pattern-detector";
+import { debug } from "../util/debug";
+import { recordSavings } from "../util/metrics";
+import { detectDecisionChains } from "../ai/decision-chains";
+
+interface HookInput {
+  session_id: string;
+  transcript_path: string;
+  cwd: string;
+  hook_event_name: 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 !== "Stop") {
+    process.exit(0);
+  }
+
+  try {
+    const sessionId = input.session_id;
+
+    // Check if this session has observations
+    const obsCount = countObservationsBySession(sessionId);
+    if (obsCount === 0) {
+      process.exit(0);
+    }
+
+    // Get all observations for this session
+    const observations = getObservationsBySession(sessionId);
+
+    // Compress into session summary (Level 1)
+    const summary = compressSession(observations, input.cwd);
+
+    // Save summary to SQLite
+    insertSummary({
+      session_id: sessionId,
+      level: 1,
+      text: summary.text,
+      project_path: input.cwd,
+    });
+
+    // Generate embedding and save to LanceDB
+    try {
+      const embedding = await generateEmbedding(summary.text);
+      await addVector({
+        id: `summary-${sessionId}`,
+        session_id: sessionId,
+        project_path: input.cwd,
+        text: summary.text,
+        level: 1,
+        created_at: new Date().toISOString(),
+        vector: Array.from(embedding),
+      });
+    } catch (e) {
+      // Vector storage is non-critical
+    }
+
+    // Extract and save decisions
+    const decisions = extractDecisionsFromObservations(observations, input.cwd);
+    for (const decision of decisions) {
+      insertDecision(decision);
+
+      // Also embed decisions for semantic search
+      try {
+        const decEmbedding = await generateEmbedding(`${decision.title} ${decision.decision_text}`);
+        await addVector({
+          id: `decision-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+          session_id: sessionId,
+          project_path: input.cwd,
+          text: `DECISION: ${decision.title} — ${decision.decision_text}`,
+          level: 9, // High priority level for decisions
+          created_at: new Date().toISOString(),
+          vector: Array.from(decEmbedding),
+        });
+      } catch {
+        // Non-critical
+      }
+    }
+
+    // Detect and save patterns
+    try {
+      detectPatterns(observations, input.cwd);
+    } catch {
+      // Non-critical
+    }
+
+    // Update session end
+    endSession(sessionId, obsCount);
+
+    // Token savings estimate
+    recordSavings(sessionId, observations);
+
+    // Detect cross-session decision chains (e.g. A→B then B→C)
+    try {
+      detectDecisionChains(input.cwd);
+    } catch {
+      // Non-critical
+    }
+
+    // Check if we need a weekly digest
+    try {
+      await maybeGenerateWeeklyDigest(input.cwd);
+    } catch {
+      // Non-critical
+    }
+
+    // Check if we need a monthly digest (Level 3)
+    try {
+      await maybeGenerateMonthlyDigest(input.cwd);
+    } catch {
+      // Non-critical
+    }
+
+    debug("stop", "session ended", {
+      session: sessionId.slice(0, 8),
+      observations: obsCount,
+      decisions: decisions.length,
+    });
+
+  } catch (e) {
+    const errorLog = Bun.file(`${import.meta.dir}/../../data/error.log`);
+    await Bun.write(errorLog, `${new Date().toISOString()} Stop error: ${e}\n`);
+  } finally {
+    closeDb();
+    await closeVectorDb();
+  }
+
+  process.exit(0);
+}
+
+async function maybeGenerateWeeklyDigest(projectPath: string) {
+  const db = getDb();
+
+  // Check last weekly digest
+  const lastDigest = db.prepare(`
+    SELECT created_at FROM summaries
+    WHERE project_path = ? AND level = 2
+    ORDER BY created_at DESC LIMIT 1
+  `).get(projectPath) as any;
+
+  const oneWeekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+
+  if (lastDigest && lastDigest.created_at > oneWeekAgo) {
+    return; // Too recent
+  }
+
+  // Get all session summaries since last digest (or last 7 days)
+  const since = lastDigest?.created_at || oneWeekAgo;
+  const sessionSummaries = db.prepare(`
+    SELECT text FROM summaries
+    WHERE project_path = ? AND level = 1 AND created_at >= ?
+    ORDER BY created_at ASC
+  `).all(projectPath, since) as Array<{ text: string }>;
+
+  if (sessionSummaries.length < 2) {
+    return; // Not enough data
+  }
+
+  // Generate weekly digest (heuristic: combine and compress)
+  const combined = sessionSummaries.map(s => s.text).join("\n---\n");
+  const digestLines: string[] = [
+    `Weekly Digest | ${new Date().toISOString().slice(0, 10)}`,
+    `Sessions: ${sessionSummaries.length}`,
+    "",
+  ];
+
+  // Extract key themes by counting common words across summaries
+  const wordCounts = new Map<string, number>();
+  for (const s of sessionSummaries) {
+    const words = s.text.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+    const unique = new Set(words);
+    for (const w of unique) {
+      wordCounts.set(w, (wordCounts.get(w) || 0) + 1);
+    }
+  }
+
+  const themes = [...wordCounts.entries()]
+    .filter(([, c]) => c >= 2)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)
+    .map(([w]) => w);
+
+  if (themes.length > 0) {
+    digestLines.push(`Key themes: ${themes.join(", ")}`);
+  }
+
+  // Take first 2 lines from each session summary
+  digestLines.push("");
+  digestLines.push("Session highlights:");
+  for (const s of sessionSummaries.slice(-5)) {
+    const firstLines = s.text.split("\n").filter(l => l.trim()).slice(0, 2);
+    for (const line of firstLines) {
+      digestLines.push(`  ${line.trim()}`);
+    }
+  }
+
+  const digestText = digestLines.join("\n");
+
+  insertSummary({
+    level: 2,
+    text: digestText,
+    project_path: projectPath,
+  });
+
+  // Embed weekly digest
+  try {
+    const embedding = await generateEmbedding(digestText);
+    await addVector({
+      id: `digest-${Date.now()}`,
+      session_id: "",
+      project_path: projectPath,
+      text: digestText,
+      level: 2,
+      created_at: new Date().toISOString(),
+      vector: Array.from(embedding),
+    });
+  } catch {
+    // Non-critical
+  }
+}
+
+async function maybeGenerateMonthlyDigest(projectPath: string) {
+  const db = getDb();
+
+  const lastDigest = db.prepare(`
+    SELECT created_at FROM summaries
+    WHERE project_path = ? AND level = 3
+    ORDER BY created_at DESC LIMIT 1
+  `).get(projectPath) as any;
+
+  const oneMonthAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
+
+  if (lastDigest && lastDigest.created_at > oneMonthAgo) {
+    return;
+  }
+
+  const since = lastDigest?.created_at || oneMonthAgo;
+
+  // Aggregate from weekly digests (Level 2) if available, else from session summaries
+  const weeklies = db.prepare(`
+    SELECT text FROM summaries
+    WHERE project_path = ? AND level = 2 AND created_at >= ?
+    ORDER BY created_at ASC
+  `).all(projectPath, since) as Array<{ text: string }>;
+
+  if (weeklies.length < 2) return; // Need at least 2 weekly digests
+
+  const lines: string[] = [
+    `Monthly Digest | ${new Date().toISOString().slice(0, 10)}`,
+    `Weekly digests aggregated: ${weeklies.length}`,
+    "",
+  ];
+
+  // Extract recurring themes from weekly digests
+  const themeCounts = new Map<string, number>();
+  for (const w of weeklies) {
+    const m = w.text.match(/Key themes:\s*(.+)/);
+    if (m) {
+      for (const theme of m[1].split(/,\s*/)) {
+        const t = theme.trim().toLowerCase();
+        if (t) themeCounts.set(t, (themeCounts.get(t) || 0) + 1);
+      }
+    }
+  }
+
+  const persistentThemes = [...themeCounts.entries()]
+    .filter(([, c]) => c >= 2)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 8)
+    .map(([t]) => t);
+
+  if (persistentThemes.length > 0) {
+    lines.push(`Persistent themes across the month: ${persistentThemes.join(", ")}`);
+  }
+
+  // Top decisions of the month
+  const topDecs = db.prepare(`
+    SELECT title FROM decisions
+    WHERE project_path = ? AND created_at >= ?
+    ORDER BY created_at DESC LIMIT 10
+  `).all(projectPath, since) as Array<{ title: string }>;
+
+  if (topDecs.length > 0) {
+    lines.push("");
+    lines.push("Key decisions this month:");
+    for (const d of topDecs) {
+      lines.push(`  • ${d.title}`);
+    }
+  }
+
+  const digestText = lines.join("\n");
+
+  insertSummary({
+    level: 3,
+    text: digestText,
+    project_path: projectPath,
+  });
+
+  try {
+    const embedding = await generateEmbedding(digestText);
+    await addVector({
+      id: `monthly-${Date.now()}`,
+      session_id: "",
+      project_path: projectPath,
+      text: digestText,
+      level: 3,
+      created_at: new Date().toISOString(),
+      vector: Array.from(embedding),
+    });
+  } catch {
+    // Non-critical
+  }
+}
+
+main();

package/src/mcp/server.ts

@@ -0,0 +1,293 @@
+#!/usr/bin/env bun
+// autoctxd MCP server — Model Context Protocol server that lets Claude (and
+// any other MCP-compatible client: Cursor, Windsurf, Cline) query memory on
+// demand during reasoning, not just at session start.
+//
+// Exposes 7 tools that Claude can call during a conversation:
+//   - recall_decisions       Look up architectural decisions for a project
+//   - recall_unfinished      Get blocked/pending items from past sessions
+//   - search_memory          Hybrid semantic + FTS search
+//   - get_project_history    Recent session summaries for a project
+//   - check_intent           Active Guard: does this action contradict a past decision?
+//   - record_feedback        Mark a past inject as useful/irrelevant/wrong
+//   - record_decision        Let Claude explicitly log a decision it just made
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { getDb, closeDb } from "../db/sqlite/schema";
+import { getDecisionsByProject, insertDecision } from "../db/sqlite/decisions";
+import { getRecentSummaries } from "../db/sqlite/summaries";
+import { getUnfinishedItems } from "../ai/proactive";
+import { hybridSearch } from "../db/vector/search";
+import { closeVectorDb } from "../db/vector/client";
+import { checkIntent } from "../ai/active-guard";
+import { recordFeedback, type Verdict } from "../db/sqlite/feedback";
+import { debug } from "../util/debug";
+
+const server = new Server(
+  {
+    name: "autoctxd",
+    version: "0.2.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// Log every tool call to mcp_access_log so we can analyze what Claude queries
+function logAccess(tool: string, args: any, resultCount: number) {
+  try {
+    const db = getDb();
+    db.prepare(`
+      INSERT INTO mcp_access_log (tool_name, args, result_count, project_path)
+      VALUES (?, ?, ?, ?)
+    `).run(tool, JSON.stringify(args || {}).slice(0, 1000), resultCount, args?.project_path || null);
+  } catch {}
+}
+
+function textContent(text: string) {
+  return { content: [{ type: "text" as const, text }] };
+}
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "recall_decisions",
+      description:
+        "Retrieve architectural decisions the user has previously made in a project. Use this BEFORE suggesting technologies, patterns, or major changes — the user may have already decided against alternatives. Returns title, decision text, alternatives rejected, and rationale when available.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          project_path: { type: "string", description: "Absolute path of the project. If omitted, returns decisions across all projects." },
+          limit: { type: "number", description: "Max decisions to return (default 10)" },
+        },
+      },
+    },
+    {
+      name: "recall_unfinished",
+      description:
+        "Get items the user was blocked on or left unfinished in past sessions on this project. Surface these at the start of work so the user doesn't need to re-explain what they were stuck on.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          project_path: { type: "string", description: "Absolute path of the project" },
+          limit: { type: "number", description: "Max items (default 5)" },
+        },
+        required: ["project_path"],
+      },
+    },
+    {
+      name: "search_memory",
+      description:
+        "Hybrid semantic + full-text search across the user's entire coding memory (all projects unless filtered). Use when the user asks 'have we done X before?' or when you need to recall past work.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Natural language query" },
+          project_path: { type: "string", description: "Optional filter to a single project" },
+          limit: { type: "number", description: "Max results (default 8)" },
+        },
+        required: ["query"],
+      },
+    },
+    {
+      name: "get_project_history",
+      description:
+        "Get recent session summaries for a project. Each summary covers a past work session: what was done, key files touched, decisions made. Use to understand the arc of recent work.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          project_path: { type: "string" },
+          limit: { type: "number", description: "Default 3" },
+        },
+        required: ["project_path"],
+      },
+    },
+    {
+      name: "check_intent",
+      description:
+        "ACTIVE GUARD. Before you execute a non-trivial action (installing a package, migrating a library, rewriting a subsystem), call this with your intent. Returns warnings if the action contradicts a past decision (e.g. installing a library you previously rejected).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          project_path: { type: "string" },
+          intent: { type: "string", description: "Natural description of what you're about to do, e.g. 'installing prisma for the ORM' or 'switching auth to JWT'" },
+        },
+        required: ["project_path", "intent"],
+      },
+    },
+    {
+      name: "record_feedback",
+      description:
+        "When the user indicates that something surfaced from memory was helpful or unhelpful, record it. This makes autoctxd learn to suppress irrelevant items and amplify useful ones for this user specifically.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          target_type: { type: "string", enum: ["decision", "observation", "summary", "pattern", "unfinished"] },
+          target_id: { type: "string", description: "ID of the item being rated" },
+          target_text: { type: "string", description: "Short description of what was rated (for human review)" },
+          verdict: { type: "string", enum: ["useful", "irrelevant", "wrong"] },
+          reason: { type: "string", description: "Optional explanation from the user" },
+          project_path: { type: "string" },
+        },
+        required: ["target_type", "target_id", "verdict"],
+      },
+    },
+    {
+      name: "record_decision",
+      description:
+        "Explicitly persist a decision the user just made during this conversation. Use when the user says something like 'let's go with X' or 'we're not going to use Y' — decisions recorded this way will never be forgotten and will guide future sessions.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          project_path: { type: "string" },
+          title: { type: "string", description: "Short title like 'Chose Postgres for main DB'" },
+          decision_text: { type: "string", description: "Full explanation of the decision" },
+          alternatives: { type: "string", description: "Comma-separated list of rejected alternatives" },
+          rationale: { type: "string", description: "Why this choice was made" },
+        },
+        required: ["project_path", "title", "decision_text"],
+      },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const name = request.params.name;
+  const args = (request.params.arguments || {}) as any;
+  debug("mcp", `tool called: ${name}`, args);
+
+  try {
+    if (name === "recall_decisions") {
+      const limit = Math.min(50, args.limit || 10);
+      let results: any[];
+      if (args.project_path) {
+        results = getDecisionsByProject(args.project_path).slice(0, limit);
+      } else {
+        const db = getDb();
+        results = db.prepare("SELECT * FROM decisions ORDER BY created_at DESC LIMIT ?").all(limit) as any[];
+      }
+      logAccess(name, args, results.length);
+      if (results.length === 0) {
+        return textContent("No decisions recorded for this project yet.");
+      }
+      const formatted = results.map((d, i) => {
+        const parts = [`${i + 1}. ${d.title} [id=${d.id}]`];
+        parts.push(`   Decision: ${d.decision_text}`);
+        if (d.alternatives) parts.push(`   Rejected: ${d.alternatives}`);
+        if (d.rationale) parts.push(`   Reason: ${d.rationale}`);
+        if (d.files_affected) parts.push(`   Files: ${d.files_affected}`);
+        parts.push(`   When: ${d.created_at}`);
+        return parts.join("\n");
+      }).join("\n\n");
+      return textContent(formatted);
+    }
+
+    if (name === "recall_unfinished") {
+      const items = getUnfinishedItems(args.project_path, args.limit || 5);
+      logAccess(name, args, items.length);
+      if (items.length === 0) {
+        return textContent("No unfinished/blocked items in the past 30 days for this project.");
+      }
+      const formatted = items.map((u, i) => {
+        const age = u.age_days <= 0 ? "today" : u.age_days === 1 ? "yesterday" : `${u.age_days} days ago`;
+        return `${i + 1}. [${age}] ${u.summary}${u.file_paths ? `\n   Files: ${u.file_paths}` : ""}`;
+      }).join("\n\n");
+      return textContent(formatted);
+    }
+
+    if (name === "search_memory") {
+      const results = await hybridSearch(args.query, {
+        limit: args.limit || 8,
+        projectPath: args.project_path,
+      });
+      logAccess(name, args, results.length);
+      if (results.length === 0) {
+        return textContent(`No matches for: ${args.query}`);
+      }
+      const formatted = results.map((r, i) => {
+        const when = r.metadata?.timestamp || r.metadata?.created_at || "";
+        return `${i + 1}. [${r.source}] ${r.text}${when ? `\n   (${when})` : ""}`;
+      }).join("\n\n");
+      return textContent(formatted);
+    }
+
+    if (name === "get_project_history") {
+      const summaries = getRecentSummaries(args.project_path, 1, args.limit || 3);
+      logAccess(name, args, summaries.length);
+      if (summaries.length === 0) {
+        return textContent("No past sessions recorded for this project yet.");
+      }
+      const formatted = summaries.map((s, i) => `### Session ${i + 1} (${s.created_at})\n${s.text}`).join("\n\n---\n\n");
+      return textContent(formatted);
+    }
+
+    if (name === "check_intent") {
+      const warnings = checkIntent(args.project_path, args.intent);
+      logAccess(name, args, warnings.length);
+      if (warnings.length === 0) {
+        return textContent(`No conflicts detected. "${args.intent}" appears consistent with past decisions.`);
+      }
+      const formatted = [
+        `⚠ INTENT CONFLICTS WITH ${warnings.length} PAST DECISION(S):`,
+        "",
+        ...warnings.map((w, i) => {
+          return `${i + 1}. ${w.decision.title} (confidence ${(w.confidence * 100).toFixed(0)}%)
+   Reason: ${w.reason}
+   Original decision: ${w.decision.decision_text}${w.decision.rationale ? `\n   Original rationale: ${w.decision.rationale}` : ""}`;
+        }),
+        "",
+        "Consider: re-confirm with the user before proceeding, or explicitly override the past decision with record_decision.",
+      ].join("\n");
+      return textContent(formatted);
+    }
+
+    if (name === "record_feedback") {
+      const id = recordFeedback({
+        target_type: args.target_type,
+        target_id: String(args.target_id),
+        target_text: args.target_text,
+        verdict: args.verdict as Verdict,
+        reason: args.reason,
+        project_path: args.project_path,
+      });
+      logAccess(name, args, 1);
+      return textContent(`Feedback recorded (id=${id}). Future rankings will adapt.`);
+    }
+
+    if (name === "record_decision") {
+      insertDecision({
+        project_path: args.project_path,
+        title: args.title,
+        decision_text: args.decision_text,
+        alternatives: args.alternatives,
+        rationale: args.rationale,
+      });
+      logAccess(name, args, 1);
+      return textContent(`Decision recorded: "${args.title}". It will surface in all future sessions on this project.`);
+    }
+
+    return textContent(`Unknown tool: ${name}`);
+  } catch (e) {
+    debug("mcp", `tool error: ${name}`, String(e));
+    return textContent(`Error: ${e}`);
+  }
+});
+
+// Cleanup on exit
+const cleanup = async () => {
+  try { closeDb(); } catch {}
+  try { await closeVectorDb(); } catch {}
+};
+process.on("SIGINT", async () => { await cleanup(); process.exit(0); });
+process.on("SIGTERM", async () => { await cleanup(); process.exit(0); });
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+debug("mcp", "autoctxd MCP server started");