clawmem 0.1.0

package/src/hooks/feedback-loop.ts

@@ -0,0 +1,214 @@
+/**
+ * Feedback Loop Hook - Stop
+ *
+ * Fires when a session ends. Detects which surfaced notes were actually
+ * referenced by the assistant, and boosts their access counts.
+ * This closes the learning loop: notes that prove useful rise in confidence,
+ * unused notes gradually decay.
+ *
+ * Silent — does not inject context back to Claude.
+ */
+
+import type { Store } from "../store.ts";
+import type { HookInput, HookOutput } from "../hooks.ts";
+import {
+  makeEmptyOutput,
+  readTranscript,
+  validateTranscriptPath,
+} from "../hooks.ts";
+
+// =============================================================================
+// Handler
+// =============================================================================
+
+export async function feedbackLoop(
+  store: Store,
+  input: HookInput
+): Promise<HookOutput> {
+  const transcriptPath = validateTranscriptPath(input.transcriptPath);
+  const sessionId = input.sessionId;
+  if (!transcriptPath || !sessionId) return makeEmptyOutput("feedback-loop");
+
+  // Get all notes injected during this session
+  const usages = store.getUsageForSession(sessionId);
+  if (usages.length === 0) return makeEmptyOutput("feedback-loop");
+
+  // Collect all injected paths
+  const injectedPaths = new Set<string>();
+  for (const u of usages) {
+    try {
+      const paths = JSON.parse(u.injectedPaths) as string[];
+      for (const p of paths) injectedPaths.add(p);
+    } catch {
+      // Skip malformed
+    }
+  }
+
+  if (injectedPaths.size === 0) return makeEmptyOutput("feedback-loop");
+
+  // Read assistant messages from transcript
+  const assistantMessages = readTranscript(transcriptPath, 200, "assistant");
+  if (assistantMessages.length === 0) return makeEmptyOutput("feedback-loop");
+
+  // Build full assistant text for reference detection
+  const assistantText = assistantMessages.map(m => m.content).join("\n");
+
+  // Detect references: check if the assistant mentioned any injected path or title
+  const referencedPaths: string[] = [];
+
+  for (const path of injectedPaths) {
+    // Check for path reference
+    if (assistantText.includes(path)) {
+      referencedPaths.push(path);
+      continue;
+    }
+
+    // Check for filename reference
+    const filename = path.split("/").pop()?.replace(/\.(md|txt)$/i, "");
+    if (filename && filename.length > 3 && assistantText.toLowerCase().includes(filename.toLowerCase())) {
+      referencedPaths.push(path);
+      continue;
+    }
+
+    // Check for title reference (look up from DB)
+    const titleMatch = checkTitleReference(store, path, assistantText);
+    if (titleMatch) {
+      referencedPaths.push(path);
+    }
+  }
+
+  // Boost access counts for referenced notes
+  if (referencedPaths.length > 0) {
+    store.incrementAccessCount(referencedPaths);
+
+    // Mark usage records as referenced
+    for (const u of usages) {
+      try {
+        const paths = JSON.parse(u.injectedPaths) as string[];
+        if (paths.some(p => referencedPaths.includes(p))) {
+          store.markUsageReferenced(u.id);
+        }
+      } catch {
+        // Skip
+      }
+    }
+
+    // Record usage relations between co-referenced documents
+    if (referencedPaths.length >= 2) {
+      try {
+        const docIds = new Map<string, number>();
+        for (const path of referencedPaths) {
+          const parts = path.split("/");
+          if (parts.length < 2) continue;
+          const collection = parts[0]!;
+          const docPath = parts.slice(1).join("/");
+          const doc = store.findActiveDocument(collection, docPath);
+          if (doc) docIds.set(path, doc.id);
+        }
+        const ids = [...docIds.values()];
+        for (let i = 0; i < ids.length; i++) {
+          for (let j = i + 1; j < ids.length; j++) {
+            store.insertRelation(ids[i]!, ids[j]!, "usage");
+          }
+        }
+      } catch {
+        // Non-critical — don't block feedback loop on relation errors
+      }
+    }
+
+    // Record co-activations for the referenced paths
+    if (referencedPaths.length >= 2) {
+      store.recordCoActivation(referencedPaths);
+    }
+  }
+
+  // Utility tracking: detect pin/snooze candidates based on usage patterns
+  try {
+    trackUtilitySignals(store, injectedPaths, referencedPaths);
+  } catch {
+    // Non-critical — don't block feedback loop on utility tracking errors
+  }
+
+  // Silent return — feedback loop doesn't inject context
+  return makeEmptyOutput("feedback-loop");
+}
+
+// =============================================================================
+// Utility Signal Tracking
+// =============================================================================
+
+/**
+ * Track utility signals for lifecycle automation (ReMe-inspired u/f ratio).
+ *
+ * For each injected path, records whether it was referenced (useful) or not (noise).
+ * Over time this builds a utility profile per document:
+ * - High utility (referenced often) → pin candidate
+ * - Low utility (surfaced often, never referenced) → snooze candidate
+ *
+ * Writes to `utility_signals` table (created lazily).
+ */
+function trackUtilitySignals(
+  store: Store,
+  injectedPaths: Set<string>,
+  referencedPaths: string[]
+): void {
+  store.db.exec(`
+    CREATE TABLE IF NOT EXISTS utility_signals (
+      path TEXT NOT NULL,
+      surfaced_count INTEGER NOT NULL DEFAULT 0,
+      referenced_count INTEGER NOT NULL DEFAULT 0,
+      last_surfaced TEXT,
+      last_referenced TEXT,
+      PRIMARY KEY (path)
+    )
+  `);
+
+  const referencedSet = new Set(referencedPaths);
+  const now = new Date().toISOString();
+
+  const upsert = store.db.prepare(`
+    INSERT INTO utility_signals (path, surfaced_count, referenced_count, last_surfaced, last_referenced)
+    VALUES (?, 1, ?, ?, ?)
+    ON CONFLICT(path) DO UPDATE SET
+      surfaced_count = surfaced_count + 1,
+      referenced_count = referenced_count + ?,
+      last_surfaced = ?,
+      last_referenced = CASE WHEN ? > 0 THEN ? ELSE last_referenced END
+  `);
+
+  for (const path of injectedPaths) {
+    const wasReferenced = referencedSet.has(path) ? 1 : 0;
+    upsert.run(
+      path,
+      wasReferenced,
+      now,
+      wasReferenced > 0 ? now : null,
+      wasReferenced,
+      now,
+      wasReferenced,
+      now
+    );
+  }
+}
+
+// =============================================================================
+// Reference Detection
+// =============================================================================
+
+function checkTitleReference(store: Store, path: string, text: string): boolean {
+  try {
+    const parts = path.split("/");
+    if (parts.length < 2) return false;
+    const collection = parts[0]!;
+    const docPath = parts.slice(1).join("/");
+    const doc = store.findActiveDocument(collection, docPath);
+    if (!doc?.title) return false;
+
+    // Skip generic titles
+    if (doc.title.length < 5) return false;
+
+    return text.toLowerCase().includes(doc.title.toLowerCase());
+  } catch {
+    return false;
+  }
+}

package/src/hooks/handoff-generator.ts

@@ -0,0 +1,345 @@
+/**
+ * Handoff Generator Hook - Stop
+ *
+ * Fires when a Claude Code session ends. Analyzes the transcript
+ * to generate a handoff note summarizing: what was done, current state,
+ * decisions made, and next steps. Stored in _clawmem collection.
+ */
+
+import type { Store } from "../store.ts";
+import type { HookInput, HookOutput } from "../hooks.ts";
+import {
+  makeContextOutput,
+  makeEmptyOutput,
+  readTranscript,
+  validateTranscriptPath,
+  type TranscriptMessage,
+} from "../hooks.ts";
+import { extractSummary, type SessionSummary } from "../observer.ts";
+import { updateDirectoryContext } from "../directory-context.ts";
+import { loadConfig } from "../collections.ts";
+
+// =============================================================================
+// Config
+// =============================================================================
+
+const MIN_MESSAGES_FOR_HANDOFF = 4;
+
+// =============================================================================
+// Handler
+// =============================================================================
+
+export async function handoffGenerator(
+  store: Store,
+  input: HookInput
+): Promise<HookOutput> {
+  const transcriptPath = validateTranscriptPath(input.transcriptPath);
+  if (!transcriptPath) return makeEmptyOutput("handoff-generator");
+
+  const messages = readTranscript(transcriptPath, 200);
+  if (messages.length < MIN_MESSAGES_FOR_HANDOFF) return makeEmptyOutput("handoff-generator");
+
+  const sessionId = input.sessionId || `session-${Date.now()}`;
+  const now = new Date();
+  const timestamp = now.toISOString();
+  const dateStr = timestamp.slice(0, 10);
+
+  // Try observer for rich summary, fall back to regex
+  const summary = await extractSummary(messages);
+  const handoff = summary
+    ? buildHandoffFromSummary(summary, messages, sessionId, dateStr)
+    : buildHandoff(messages, sessionId, dateStr);
+
+  // Use saveMemory API with dedup protection.
+  // semanticPayload = session ID + core summary fields.
+  // Include sessionId so different sessions never dedup even if content is similar.
+  // SessionSummary fields: request, investigated, learned, completed, nextSteps (all strings)
+  const semanticPayload = summary
+    ? [sessionId, summary.request, summary.investigated, summary.learned, summary.completed, summary.nextSteps].filter(Boolean).join("\n")
+    : [sessionId, extractSummaryLine(messages) || handoff].join("\n");
+
+  const handoffPath = `handoffs/${dateStr}-${sessionId.slice(0, 8)}.md`;
+  const result = store.saveMemory({
+    collection: "_clawmem",
+    path: handoffPath,
+    title: `Handoff ${dateStr}`,
+    body: handoff,
+    contentType: "handoff",
+    confidence: 0.60,
+    semanticPayload,
+  });
+
+  if (result.action === 'deduplicated') {
+    process.stderr.write(`[handoff-generator] Dedup: existing handoff within window (doc ${result.docId}, count=${result.duplicateCount})\n`);
+  }
+
+  // Update session record with handoff path
+  try {
+    store.updateSession(sessionId, {
+      endedAt: timestamp,
+      handoffPath,
+      summary: extractSummaryLine(messages),
+    });
+  } catch {
+    // Non-fatal
+  }
+
+  // Extract files changed from transcript
+  const filesChanged = extractFilesChanged(messages);
+  if (filesChanged.length > 0) {
+    try {
+      store.updateSession(sessionId, { filesChanged });
+    } catch { /* non-fatal */ }
+
+    // Trigger directory context update if enabled
+    const config = loadConfig();
+    if (config.directoryContext) {
+      try {
+        updateDirectoryContext(store, filesChanged);
+      } catch { /* non-fatal */ }
+    }
+  }
+
+  return makeContextOutput(
+    "handoff-generator",
+    `<vault-handoff>Handoff note saved: ${handoffPath}</vault-handoff>`
+  );
+}
+
+// =============================================================================
+// Observer-based Handoff Builder
+// =============================================================================
+
+function buildHandoffFromSummary(
+  summary: SessionSummary,
+  messages: TranscriptMessage[],
+  sessionId: string,
+  dateStr: string
+): string {
+  const filesChanged = extractFilesChanged(messages);
+
+  const lines = [
+    `---`,
+    `content_type: handoff`,
+    `tags: [auto-generated, observer]`,
+    `---`,
+    ``,
+    `# Session Handoff — ${dateStr}`,
+    ``,
+    `Session: \`${sessionId.slice(0, 8)}\``,
+    ``,
+  ];
+
+  if (summary.request !== "None") {
+    lines.push(`## Request`, ``, summary.request, ``);
+  }
+
+  if (summary.investigated !== "None") {
+    lines.push(`## What Was Investigated`, ``, summary.investigated, ``);
+  }
+
+  if (summary.learned !== "None") {
+    lines.push(`## What Was Learned`, ``, summary.learned, ``);
+  }
+
+  if (summary.completed !== "None") {
+    lines.push(`## What Was Done`, ``, summary.completed, ``);
+  }
+
+  if (filesChanged.length > 0) {
+    lines.push(`## Files Changed`, ``);
+    for (const f of filesChanged.slice(0, 20)) {
+      lines.push(`- \`${f}\``);
+    }
+    lines.push(``);
+  }
+
+  if (summary.nextSteps !== "None") {
+    lines.push(`## Next Session Should`, ``, summary.nextSteps, ``);
+  }
+
+  return lines.join("\n");
+}
+
+// =============================================================================
+// Regex-based Handoff Builder (Fallback)
+// =============================================================================
+
+function buildHandoff(
+  messages: TranscriptMessage[],
+  sessionId: string,
+  dateStr: string
+): string {
+  const topics = extractTopics(messages);
+  const actions = extractActions(messages);
+  const nextSteps = extractNextSteps(messages);
+  const filesChanged = extractFilesChanged(messages);
+
+  const lines = [
+    `---`,
+    `content_type: handoff`,
+    `tags: [auto-generated]`,
+    `---`,
+    ``,
+    `# Session Handoff — ${dateStr}`,
+    ``,
+    `Session: \`${sessionId.slice(0, 8)}\``,
+    ``,
+  ];
+
+  if (topics.length > 0) {
+    lines.push(`## Current State`, ``);
+    for (const topic of topics) {
+      lines.push(`- ${topic}`);
+    }
+    lines.push(``);
+  }
+
+  if (actions.length > 0) {
+    lines.push(`## What Was Done`, ``);
+    for (const action of actions) {
+      lines.push(`- ${action}`);
+    }
+    lines.push(``);
+  }
+
+  if (filesChanged.length > 0) {
+    lines.push(`## Files Changed`, ``);
+    for (const f of filesChanged.slice(0, 20)) {
+      lines.push(`- \`${f}\``);
+    }
+    lines.push(``);
+  }
+
+  if (nextSteps.length > 0) {
+    lines.push(`## Next Session Should`, ``);
+    for (const step of nextSteps) {
+      lines.push(`- ${step}`);
+    }
+    lines.push(``);
+  }
+
+  return lines.join("\n");
+}
+
+// =============================================================================
+// Content Extraction
+// =============================================================================
+
+function extractTopics(messages: TranscriptMessage[]): string[] {
+  const topics: string[] = [];
+  const seen = new Set<string>();
+
+  // Get themes from user messages
+  for (const msg of messages) {
+    if (msg.role !== "user") continue;
+    const first = msg.content.split("\n")[0]?.trim();
+    if (!first || first.length < 10 || first.length > 200) continue;
+    if (first.startsWith("/")) continue; // slash commands
+
+    const key = first.slice(0, 50).toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    topics.push(first);
+  }
+
+  return topics.slice(0, 5);
+}
+
+function extractActions(messages: TranscriptMessage[]): string[] {
+  const actions: string[] = [];
+  const seen = new Set<string>();
+
+  const actionPatterns = [
+    /\b(?:created|wrote|added|implemented|built|set up|configured|installed|fixed|updated|modified|refactored|deleted|removed)\b/i,
+  ];
+
+  for (const msg of messages) {
+    if (msg.role !== "assistant") continue;
+
+    const sentences = msg.content.split(/(?<=[.!?])\s+/);
+    for (const sentence of sentences) {
+      if (sentence.length < 15 || sentence.length > 300) continue;
+      if (!actionPatterns.some(p => p.test(sentence))) continue;
+
+      const key = sentence.slice(0, 60).toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      actions.push(sentence.trim());
+    }
+  }
+
+  return actions.slice(0, 10);
+}
+
+function extractNextSteps(messages: TranscriptMessage[]): string[] {
+  const nextSteps: string[] = [];
+  const seen = new Set<string>();
+
+  const nextPatterns = [
+    /\bnext\s+(?:step|task|we\s+(?:need|should|can)|up|thing)\b/i,
+    /\btodo\b/i,
+    /\bremaining\b/i,
+    /\blater\b.*\b(?:we|you)\s+(?:can|should|need)\b/i,
+    /\bstill\s+need\s+to\b/i,
+    /\bnot\s+yet\s+(?:done|implemented|completed)\b/i,
+  ];
+
+  // Scan last 30 messages (most relevant for next steps)
+  const tail = messages.slice(-30);
+  for (const msg of tail) {
+    if (msg.role !== "assistant") continue;
+
+    const sentences = msg.content.split(/(?<=[.!?])\s+/);
+    for (const sentence of sentences) {
+      if (sentence.length < 15 || sentence.length > 300) continue;
+      if (!nextPatterns.some(p => p.test(sentence))) continue;
+
+      const key = sentence.slice(0, 60).toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      nextSteps.push(sentence.trim());
+    }
+  }
+
+  return nextSteps.slice(0, 5);
+}
+
+const MAX_FILES_EXTRACTED = 200;
+
+function extractFilesChanged(messages: TranscriptMessage[]): string[] {
+  const files = new Set<string>();
+
+  const filePatterns = [
+    /(?:created|wrote|edited|modified|updated|deleted)\s+(?:file\s+)?[`"]?([^\s`"]+\.\w{1,10})[`"]?/gi,
+    /(?:Write|Edit|Read)\s+tool.*?[`"]([^\s`"]+\.\w{1,10})[`"]?/gi,
+    /^\s*(?:[-+]){3}\s+(a|b)\/(.+\.\w{1,10})/gm,
+  ];
+
+  for (const msg of messages) {
+    if (msg.role !== "assistant") continue;
+    if (files.size >= MAX_FILES_EXTRACTED) break;
+    for (const pattern of filePatterns) {
+      pattern.lastIndex = 0;
+      let match;
+      while ((match = pattern.exec(msg.content)) !== null) {
+        if (files.size >= MAX_FILES_EXTRACTED) break;
+        const file = match[2] || match[1];
+        if (file && !file.includes("*") && file.length < 200) {
+          files.add(file);
+        }
+      }
+    }
+  }
+
+  return [...files];
+}
+
+function extractSummaryLine(messages: TranscriptMessage[]): string {
+  // Get first user message as summary theme
+  const firstUser = messages.find(m => m.role === "user");
+  if (!firstUser) return "Unknown session";
+
+  const first = firstUser.content.split("\n")[0]?.trim() || "";
+  return first.length > 100 ? first.slice(0, 100) + "..." : first;
+}