clawmem 0.1.0

package/src/hooks/postcompact-inject.ts

@@ -0,0 +1,226 @@
+/**
+ * PostCompact inject hook — re-injects ClawMem context after compaction.
+ *
+ * Fires via SessionStart with matcher "compact". Reads the precompact-state.md
+ * file (written by precompact-extract), loads recent decisions from the vault,
+ * and injects authoritative context to compensate for summarization losses.
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+import {
+  type HookInput,
+  type HookOutput,
+  makeContextOutput,
+  makeEmptyOutput,
+  estimateTokens,
+  smartTruncate,
+} from "../hooks.ts";
+import type { Store } from "../store.ts";
+import { extractSnippet } from "../store.ts";
+import { sanitizeSnippet } from "../promptguard.ts";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const MAX_TOKEN_BUDGET = 1200;
+const PRECOMPACT_STATE_BUDGET = 600;
+const DECISIONS_BUDGET = 400;
+const VAULT_CONTEXT_BUDGET = 200;
+
+// ---------------------------------------------------------------------------
+// Auto-memory path discovery (same logic as precompact-extract)
+// ---------------------------------------------------------------------------
+
+function getAutoMemoryDir(transcriptPath?: string): string | null {
+  // Derive from transcript_path: ~/.claude/projects/<project-dir>/<session>.jsonl
+  if (transcriptPath) {
+    const projectDir = resolve(transcriptPath, "..");
+    const memDir = join(projectDir, "memory");
+    if (existsSync(memDir)) return memDir;
+  }
+
+  // Fallback: CWD-based lookup
+  const cwd = process.cwd();
+  const sanitized = cwd.replace(/\//g, "-").replace(/^-/, "");
+  const memDir = join(
+    process.env.HOME || "/tmp",
+    ".claude",
+    "projects",
+    sanitized,
+    "memory"
+  );
+  if (existsSync(memDir)) return memDir;
+
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Main hook
+// ---------------------------------------------------------------------------
+
+export async function postcompactInject(
+  store: Store,
+  input: HookInput
+): Promise<HookOutput> {
+  const sections: string[] = [];
+  let totalTokens = 0;
+
+  // Section 1: Precompact state (if available)
+  const memDir = getAutoMemoryDir(input.transcriptPath);
+  if (memDir) {
+    const statePath = join(memDir, "precompact-state.md");
+    if (existsSync(statePath)) {
+      try {
+        let stateContent = readFileSync(statePath, "utf-8").trim();
+        const stateTokens = estimateTokens(stateContent);
+
+        if (stateTokens > PRECOMPACT_STATE_BUDGET) {
+          stateContent = smartTruncate(stateContent, PRECOMPACT_STATE_BUDGET * 4);
+        }
+
+        if (stateContent.length > 0) {
+          sections.push(stateContent);
+          totalTokens += Math.min(stateTokens, PRECOMPACT_STATE_BUDGET);
+        }
+      } catch {
+        // ignore read errors
+      }
+    }
+  }
+
+  // Section 2: Recent decisions from vault (last 7 days)
+  if (totalTokens < MAX_TOKEN_BUDGET) {
+    try {
+      const cutoff = new Date();
+      cutoff.setDate(cutoff.getDate() - 7);
+      const recentDocs = store.getDocumentsByType("decision", 5);
+
+      const recentDecisions = recentDocs.filter(
+        (d) => d.modifiedAt && d.modifiedAt >= cutoff.toISOString()
+      );
+
+      if (recentDecisions.length > 0) {
+        const decisionLines: string[] = ["## Recent Decisions (from vault)", ""];
+
+        let budgetLeft = DECISIONS_BUDGET;
+        for (const doc of recentDecisions) {
+          const line = `- **${doc.title}** (${doc.modifiedAt?.slice(0, 10)})`;
+          const lineTokens = estimateTokens(line);
+          if (budgetLeft - lineTokens < 0) break;
+          decisionLines.push(line);
+          budgetLeft -= lineTokens;
+        }
+
+        if (decisionLines.length > 2) {
+          sections.push(decisionLines.join("\n"));
+          totalTokens += DECISIONS_BUDGET - budgetLeft;
+        }
+      }
+    } catch {
+      // non-critical
+    }
+  }
+
+  // Section 2b: Recent antipatterns (last 7 days)
+  if (totalTokens < MAX_TOKEN_BUDGET) {
+    try {
+      const cutoff = new Date();
+      cutoff.setDate(cutoff.getDate() - 7);
+      const recentAnti = store.getDocumentsByType("antipattern", 3);
+      const filteredAnti = recentAnti.filter(
+        (d) => d.modifiedAt && d.modifiedAt >= cutoff.toISOString()
+      );
+
+      if (filteredAnti.length > 0) {
+        const antiLines: string[] = ["## Recent Antipatterns (avoid these)", ""];
+        let budgetLeft = 150; // small budget for antipatterns
+        for (const doc of filteredAnti) {
+          const line = `- **Avoid:** ${doc.title} (${doc.modifiedAt?.slice(0, 10)})`;
+          const lineTokens = estimateTokens(line);
+          if (budgetLeft - lineTokens < 0) break;
+          antiLines.push(line);
+          budgetLeft -= lineTokens;
+        }
+        if (antiLines.length > 2) {
+          sections.push(antiLines.join("\n"));
+          totalTokens += 150 - budgetLeft;
+        }
+      }
+    } catch {
+      // non-critical
+    }
+  }
+
+  // Section 3: Vault context search (if we have a last request to search for)
+  if (totalTokens < MAX_TOKEN_BUDGET && memDir) {
+    try {
+      const statePath = join(memDir, "precompact-state.md");
+      if (existsSync(statePath)) {
+        const stateContent = readFileSync(statePath, "utf-8");
+        // Extract the last user request from the state file
+        const requestMatch = stateContent.match(
+          /## Last User Request\n\n([\s\S]*?)(?:\n##|\n$)/
+        );
+        if (requestMatch?.[1]) {
+          const query = requestMatch[1].trim().slice(0, 200);
+          if (query.length > 10) {
+            const results = store.searchFTS(query, 3);
+            if (results.length > 0) {
+              const contextLines: string[] = ["## Relevant Vault Context", ""];
+              let budgetLeft = VAULT_CONTEXT_BUDGET;
+
+              for (const r of results) {
+                const snippet = sanitizeSnippet(extractSnippet(r.body || "", query, 150).snippet);
+                const line = `- **${sanitizeSnippet(r.title)}** (${r.displayPath}): ${snippet}`;
+                const lineTokens = estimateTokens(line);
+                if (budgetLeft - lineTokens < 0) break;
+                contextLines.push(line);
+                budgetLeft -= lineTokens;
+              }
+
+              if (contextLines.length > 2) {
+                sections.push(contextLines.join("\n"));
+                totalTokens += VAULT_CONTEXT_BUDGET - budgetLeft;
+              }
+            }
+          }
+        }
+      }
+    } catch {
+      // non-critical
+    }
+  }
+
+  // Nothing to inject
+  if (sections.length === 0) {
+    return makeEmptyOutput("postcompact-inject");
+  }
+
+  // Build final output with authoritative framing
+  const context = [
+    `<vault-postcompact>`,
+    `IMPORTANT: Context was just compacted. The following is authoritative`,
+    `and takes precedence over any paraphrased version in the compacted summary.`,
+    ``,
+    sections.join("\n\n---\n\n"),
+    `</vault-postcompact>`,
+  ].join("\n");
+
+  // Audit trail
+  try {
+    store.insertUsage({
+      sessionId: input.sessionId || "unknown",
+      timestamp: new Date().toISOString(),
+      hookName: "postcompact-inject",
+      injectedPaths: [],
+      estimatedTokens: estimateTokens(context),
+      wasReferenced: 0,
+    });
+  } catch {
+    // non-critical
+  }
+
+  return makeContextOutput("postcompact-inject", context);
+}

package/src/hooks/precompact-extract.ts

@@ -0,0 +1,314 @@
+/**
+ * PreCompact hook — extracts session state before auto-compaction.
+ *
+ * Reads the full uncompressed transcript, extracts decisions and working
+ * state via regex (no LLM calls), and writes a handoff file to Claude Code's
+ * auto-memory directory. This file survives compaction and is automatically
+ * reloaded by Claude Code.
+ */
+
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+import {
+  type HookInput,
+  type HookOutput,
+  makeEmptyOutput,
+  readTranscript,
+  validateTranscriptPath,
+  estimateTokens,
+} from "../hooks.ts";
+import type { Store } from "../store.ts";
+import { extractDecisions } from "./decision-extractor.ts";
+import { indexCollection } from "../indexer.ts";
+import { loadConfig } from "../collections.ts";
+
+// ---------------------------------------------------------------------------
+// Auto-memory path discovery
+// ---------------------------------------------------------------------------
+
+function getAutoMemoryDir(transcriptPath?: string): string | null {
+  // Best source: derive from transcript_path which is already
+  // ~/.claude/projects/<project-dir>/<session>.jsonl
+  if (transcriptPath) {
+    const projectDir = resolve(transcriptPath, "..");
+    const memDir = join(projectDir, "memory");
+    if (existsSync(memDir)) return memDir;
+    // Create it if the project dir exists
+    if (existsSync(projectDir)) {
+      try {
+        mkdirSync(memDir, { recursive: true });
+        return memDir;
+      } catch { /* fall through */ }
+    }
+  }
+
+  // Fallback: CWD-based lookup
+  const cwd = process.cwd();
+  const sanitized = cwd.replace(/\//g, "-").replace(/^-/, "");
+  const memDir = join(
+    process.env.HOME || "/tmp",
+    ".claude",
+    "projects",
+    sanitized,
+    "memory"
+  );
+  if (existsSync(memDir)) return memDir;
+
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// File path extraction from transcript
+// ---------------------------------------------------------------------------
+
+const FILE_OP_PATTERNS = [
+  /(?:Read|Edit|Write|NotebookEdit)\s+(?:tool\s+)?(?:on\s+)?['"`]?([/~][^\s'"`,;]+)/gi,
+  /file_path['":\s]+([/~][^\s'"`,;]+)/gi,
+  /(?:Created|Modified|Wrote|Updated|Edited)\s+['"`]?([/~][^\s'"`,;]+)/gi,
+];
+
+function extractFilePaths(messages: { role: string; content: string }[]): string[] {
+  const paths = new Set<string>();
+
+  for (const msg of messages) {
+    if (msg.role !== "assistant") continue;
+    for (const pattern of FILE_OP_PATTERNS) {
+      pattern.lastIndex = 0;
+      let match;
+      while ((match = pattern.exec(msg.content)) !== null) {
+        const p = match[1]!;
+        if (p.length > 10 && p.length < 300 && !p.includes("*")) {
+          paths.add(p);
+        }
+      }
+    }
+  }
+
+  return [...paths].slice(0, 30); // cap at 30
+}
+
+// ---------------------------------------------------------------------------
+// Last user request extraction
+// ---------------------------------------------------------------------------
+
+function getLastUserRequest(messages: { role: string; content: string }[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]!;
+    if (msg.role === "user" && msg.content.length > 10) {
+      return msg.content.slice(0, 500);
+    }
+  }
+  return "";
+}
+
+// ---------------------------------------------------------------------------
+// Tool output pruning — strip verbose tool results from messages
+// ---------------------------------------------------------------------------
+
+/**
+ * Prune verbose tool output blocks from message content.
+ * Keeps tool invocation lines but strips their large result payloads.
+ */
+function pruneToolOutputs(content: string): string {
+  // Strip Read/Grep/Glob/Bash tool result blocks (multi-line outputs)
+  let pruned = content;
+
+  // Remove large indented tool output blocks (lines starting with spaces/tabs after tool mention)
+  pruned = pruned.replace(
+    /(?:Result of (?:calling |)(?:the )?(?:Read|Grep|Glob|Bash|Write|Edit|NotebookEdit) tool[^\n]*\n)(?:[ \t]+[^\n]*\n)*/gi,
+    ""
+  );
+
+  // Remove file content dumps (numbered lines like "     1→...")
+  pruned = pruned.replace(/(?:^ *\d+→[^\n]*\n){5,}/gm, "[file content pruned]\n");
+
+  return pruned;
+}
+
+// ---------------------------------------------------------------------------
+// Open question extraction (simple heuristics)
+// ---------------------------------------------------------------------------
+
+const QUESTION_PATTERNS = [
+  /\b(?:should we|do you want|which (?:approach|option)|how should|what about)\b[^.!]*\?/gi,
+  /\b(?:TODO|FIXME|HACK|open question|unresolved|needs?\s+(?:investigation|decision))\b[^.!]*/gi,
+];
+
+function extractOpenQuestions(messages: { role: string; content: string }[]): string[] {
+  const questions: string[] = [];
+  const seen = new Set<string>();
+
+  // Look at last 20 messages for recency
+  const recent = messages.slice(-20);
+
+  for (const msg of recent) {
+    for (const pattern of QUESTION_PATTERNS) {
+      pattern.lastIndex = 0;
+      let match;
+      while ((match = pattern.exec(msg.content)) !== null) {
+        const q = match[0].trim();
+        const key = q.slice(0, 60).toLowerCase();
+        if (!seen.has(key) && q.length > 15 && q.length < 300) {
+          seen.add(key);
+          questions.push(q);
+        }
+      }
+    }
+  }
+
+  return questions.slice(0, 10);
+}
+
+// ---------------------------------------------------------------------------
+// Query-aware decision ranking (E9)
+// ---------------------------------------------------------------------------
+
+/**
+ * Rank decisions by relevance to the last user request.
+ * Decisions mentioning terms from the active task get priority.
+ */
+function rankDecisionsByRelevance(
+  decisions: { text: string; context: string }[],
+  lastRequest: string
+): { text: string; context: string }[] {
+  if (!lastRequest || decisions.length <= 1) return decisions;
+
+  const queryTerms = lastRequest
+    .toLowerCase()
+    .split(/\s+/)
+    .filter(t => t.length > 3);
+
+  if (queryTerms.length === 0) return decisions;
+
+  return [...decisions].sort((a, b) => {
+    const aText = a.text.toLowerCase();
+    const bText = b.text.toLowerCase();
+    const aScore = queryTerms.filter(t => aText.includes(t)).length;
+    const bScore = queryTerms.filter(t => bText.includes(t)).length;
+    return bScore - aScore;
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Main hook
+// ---------------------------------------------------------------------------
+
+export async function precompactExtract(
+  store: Store,
+  input: HookInput
+): Promise<HookOutput> {
+  const transcriptPath = validateTranscriptPath(input.transcriptPath ?? "");
+  if (!transcriptPath) {
+    return makeEmptyOutput("precompact-extract");
+  }
+
+  const messages = readTranscript(transcriptPath, 200);
+  if (messages.length === 0) {
+    return makeEmptyOutput("precompact-extract");
+  }
+
+  // Prune verbose tool outputs before extraction (keeps messages focused)
+  const prunedMessages = messages.map(m => ({
+    ...m,
+    content: m.role === "assistant" ? pruneToolOutputs(m.content) : m.content,
+  }));
+
+  // Extract components (use pruned messages for decisions/questions, raw for file paths)
+  let decisions = extractDecisions(prunedMessages);
+  const lastRequest = getLastUserRequest(messages); // raw — need full user request
+  const filePaths = extractFilePaths(messages); // raw — need exact paths
+  const openQuestions = extractOpenQuestions(prunedMessages);
+
+  // Query-aware ranking: prioritize decisions relevant to the active task (E9)
+  decisions = rankDecisionsByRelevance(decisions, lastRequest);
+
+  // Skip if nothing meaningful extracted
+  if (decisions.length === 0 && !lastRequest && filePaths.length === 0) {
+    return makeEmptyOutput("precompact-extract");
+  }
+
+  // Build the handoff document
+  const now = new Date().toISOString();
+  const sections: string[] = [
+    `# Pre-Compaction State`,
+    ``,
+    `_Extracted ${now.slice(0, 19)} before auto-compaction. This is authoritative._`,
+    ``,
+  ];
+
+  if (lastRequest) {
+    sections.push(`## Last User Request`, ``, lastRequest, ``);
+  }
+
+  if (decisions.length > 0) {
+    sections.push(`## Key Decisions This Session`, ``);
+    for (const d of decisions.slice(0, 15)) {
+      sections.push(`- ${d.text}`);
+      if (d.context) {
+        sections.push(`  > Context: ${d.context.slice(0, 150)}`);
+      }
+    }
+    sections.push(``);
+  }
+
+  if (openQuestions.length > 0) {
+    sections.push(`## Open Questions / Unresolved`, ``);
+    for (const q of openQuestions) {
+      sections.push(`- ${q}`);
+    }
+    sections.push(``);
+  }
+
+  if (filePaths.length > 0) {
+    sections.push(`## Files Modified This Session`, ``);
+    for (const p of filePaths) {
+      sections.push(`- ${p}`);
+    }
+    sections.push(``);
+  }
+
+  const content = sections.join("\n");
+
+  // Write to auto-memory
+  const memDir = getAutoMemoryDir(input.transcriptPath);
+  if (memDir) {
+    const statePath = join(memDir, "precompact-state.md");
+    try {
+      writeFileSync(statePath, content, "utf-8");
+    } catch (e) {
+      process.stderr.write(`precompact-extract: failed to write state: ${e}\n`);
+    }
+
+    // Reindex the auto-memory collection so extracted memories are immediately searchable
+    try {
+      const config = loadConfig();
+      const collectionsMap = config.collections || {};
+      // Find collection covering this memory dir
+      const memEntry = Object.entries(collectionsMap).find(([, c]) =>
+        memDir.startsWith(c.path) || c.path.startsWith(memDir)
+      );
+      if (memEntry) {
+        const [colName, col] = memEntry;
+        await indexCollection(store, colName, col.path, col.pattern || "**/*.md");
+      }
+    } catch (e) {
+      process.stderr.write(`precompact-extract: archive reindex failed (non-fatal): ${e}\n`);
+    }
+  }
+
+  // Audit trail
+  try {
+    store.insertUsage({
+      sessionId: input.sessionId || "unknown",
+      timestamp: now,
+      hookName: "precompact-extract",
+      injectedPaths: [],
+      estimatedTokens: estimateTokens(content),
+      wasReferenced: 0,
+    });
+  } catch {
+    // non-critical
+  }
+
+  return makeEmptyOutput("precompact-extract");
+}

package/src/hooks/pretool-inject.ts

@@ -0,0 +1,79 @@
+/**
+ * PreToolUse inject hook — injects file-specific vault context before Read/Edit/Write.
+ *
+ * Fires via PreToolUse with matcher "Read|Edit|Write". Searches the vault for
+ * context related to the target file path and injects relevant decisions,
+ * antipatterns, and notes about that specific file.
+ */
+
+import type { Store } from "../store.ts";
+import { extractSnippet } from "../store.ts";
+import { sanitizeSnippet } from "../promptguard.ts";
+import {
+  type HookInput,
+  type HookOutput,
+  makeEmptyOutput,
+  estimateTokens,
+} from "../hooks.ts";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const MAX_TOKEN_BUDGET = 200;
+const MAX_RESULTS = 3;
+
+// ---------------------------------------------------------------------------
+// Main hook
+// ---------------------------------------------------------------------------
+
+export async function pretoolInject(
+  store: Store,
+  input: HookInput
+): Promise<HookOutput> {
+  // Extract file_path from tool input
+  const toolInput = input.toolInput as { file_path?: string } | undefined;
+  if (!toolInput?.file_path) return makeEmptyOutput("pretool-inject");
+
+  const filePath = toolInput.file_path;
+
+  // Skip very short paths or non-file paths
+  if (filePath.length < 5) return makeEmptyOutput("pretool-inject");
+
+  // Search vault for context about this specific file
+  let results;
+  try {
+    results = store.searchFTS(filePath, MAX_RESULTS);
+  } catch {
+    return makeEmptyOutput("pretool-inject");
+  }
+
+  if (!results || results.length === 0) return makeEmptyOutput("pretool-inject");
+
+  // Build compact context within budget
+  const lines: string[] = [];
+  let totalTokens = 0;
+
+  for (const r of results) {
+    if (totalTokens >= MAX_TOKEN_BUDGET) break;
+
+    const snippet = sanitizeSnippet(extractSnippet(r.body || "", filePath, 100).snippet);
+    const line = `- **${sanitizeSnippet(r.title)}**: ${snippet}`;
+    const lineTokens = estimateTokens(line);
+
+    if (totalTokens + lineTokens > MAX_TOKEN_BUDGET && lines.length > 0) break;
+    lines.push(line);
+    totalTokens += lineTokens;
+  }
+
+  if (lines.length === 0) return makeEmptyOutput("pretool-inject");
+
+  // PreToolUse hooks cannot inject additionalContext (only UserPromptSubmit can).
+  // Use the `reason` field to surface file-specific vault context.
+  const context = lines.join("\n");
+  return {
+    continue: true,
+    suppressOutput: false,
+    reason: `vault-file-context: ${context}`,
+  };
+}