autoctxd 0.4.1

package/src/ai/compressor.ts

@@ -0,0 +1,129 @@
+// Heuristic session compressor - generates summaries without API calls
+
+import type { Observation } from "../db/sqlite/observations";
+import { normalizePath } from "../util/path";
+
+interface SessionSummary {
+  text: string;
+  keyFiles: string[];
+  decisionsDetected: string[];
+  unfinished: string[];
+}
+
+export function compressSession(observations: Observation[], projectPath?: string): SessionSummary {
+  const keyFiles = extractTopFiles(observations);
+  const decisionsDetected = extractDecisions(observations);
+  const unfinished = extractUnfinished(observations);
+
+  // Deduce what the session was about from the work done
+  const workFocus = deduceWorkFocus(observations);
+
+  const lines: string[] = [];
+
+  // One-line session summary instead of raw dump
+  const projectName = projectPath ? projectPath.split(/[/\\]/).filter(Boolean).pop() || projectPath : "unknown";
+  lines.push(`${projectName}: ${workFocus} (${observations.length} actions)`);
+
+  if (keyFiles.length > 0) {
+    lines.push(`Files: ${keyFiles.slice(0, 5).map(f => f.split(/[/\\]/).pop()).join(", ")}`);
+  }
+
+  if (decisionsDetected.length > 0) {
+    lines.push("Decisions:");
+    for (const d of decisionsDetected) {
+      lines.push(`  • ${d}`);
+    }
+  }
+
+  if (unfinished.length > 0) {
+    lines.push("Blocked:");
+    for (const u of unfinished) {
+      lines.push(`  ⚠ ${u}`);
+    }
+  }
+
+  return {
+    text: lines.join("\n"),
+    keyFiles,
+    decisionsDetected,
+    unfinished,
+  };
+}
+
+function deduceWorkFocus(observations: Observation[]): string {
+  const typeCounts = new Map<string, number>();
+  for (const o of observations) {
+    typeCounts.set(o.type, (typeCounts.get(o.type) || 0) + 1);
+  }
+
+  const sorted = [...typeCounts.entries()].sort((a, b) => b[1] - a[1]);
+  const primary = sorted[0]?.[0] || "other";
+
+  const focusLabels: Record<string, string> = {
+    bug_fix: "Bug fixing",
+    refactor: "Refactoring",
+    new_feature: "Building new features",
+    config: "Configuration & setup",
+    research: "Research & exploration",
+    test: "Testing",
+    decision: "Architecture decisions",
+    blocked: "Debugging blockers",
+    deploy: "Deployment",
+    other: "General work",
+  };
+
+  // Add detail from high-importance observations
+  const topObs = observations
+    .filter(o => (o.importance_score ?? 0) >= 6)
+    .sort((a, b) => (b.importance_score ?? 0) - (a.importance_score ?? 0))
+    .slice(0, 3);
+
+  const details = topObs.map(o => {
+    const s = o.summary;
+    // Extract just the meaningful part (file edited, package installed, etc)
+    if (s.startsWith("Edited ")) return s.split(":")[0];
+    if (s.startsWith("Wrote ")) return `Created ${s.split(" ")[1]?.split(/[/\\]/).pop() || "file"}`;
+    if (s.startsWith("Bash: ")) return s.slice(6);
+    return truncate(s, 60);
+  });
+
+  const label = focusLabels[primary] || "General work";
+  if (details.length > 0) {
+    return `${label} — ${details.join(", ")}`;
+  }
+  return label;
+}
+
+function extractTopFiles(observations: Observation[]): string[] {
+  const fileCounts = new Map<string, number>();
+  for (const obs of observations) {
+    if (obs.file_paths) {
+      for (const fp of obs.file_paths.split(",")) {
+        const norm = normalizePath(fp);
+        if (norm) {
+          fileCounts.set(norm, (fileCounts.get(norm) || 0) + 1);
+        }
+      }
+    }
+  }
+  return [...fileCounts.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .map(([f]) => f);
+}
+
+function extractDecisions(observations: Observation[]): string[] {
+  return observations
+    .filter(o => o.type === "decision")
+    .map(o => truncate(o.summary, 100));
+}
+
+function extractUnfinished(observations: Observation[]): string[] {
+  return observations
+    .filter(o => o.type === "blocked")
+    .map(o => truncate(o.summary, 100));
+}
+
+function truncate(text: string, maxLen: number): string {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen - 3) + "...";
+}

package/src/ai/decision-chains.ts

@@ -0,0 +1,100 @@
+// Detects cross-session decision chains like "switched A → B" then later "replaced B → C".
+// Writes them into the patterns table as type 'decision_chain' for surfacing in the dashboard.
+
+import { getDb } from "../db/sqlite/schema";
+
+interface DecisionNode {
+  id: number;
+  title: string;
+  decision_text: string;
+  created_at: string;
+}
+
+export function detectDecisionChains(projectPath: string): void {
+  const db = getDb();
+
+  const decisions = db.prepare(`
+    SELECT id, title, decision_text, created_at
+    FROM decisions
+    WHERE project_path = ?
+    ORDER BY created_at ASC
+  `).all(projectPath) as DecisionNode[];
+
+  if (decisions.length < 2) return;
+
+  // Extract { from, to } tuples from each decision
+  const tuples = decisions
+    .map(d => ({ d, tuple: extractTransition(d.decision_text + " " + d.title) }))
+    .filter(x => x.tuple !== null) as Array<{ d: DecisionNode; tuple: { from: string; to: string } }>;
+
+  // Build chains: if A→B exists and later B→C exists, record A→B→C
+  const chains: string[][] = [];
+  for (let i = 0; i < tuples.length; i++) {
+    const chain = [tuples[i].tuple.from, tuples[i].tuple.to];
+    let current = tuples[i].tuple.to;
+    for (let j = i + 1; j < tuples.length; j++) {
+      if (normalize(tuples[j].tuple.from) === normalize(current)) {
+        chain.push(tuples[j].tuple.to);
+        current = tuples[j].tuple.to;
+      }
+    }
+    if (chain.length >= 3) {
+      chains.push(chain);
+    }
+  }
+
+  // Deduplicate chains by their stringified form
+  const seen = new Set<string>();
+  for (const chain of chains) {
+    const description = chain.join(" → ");
+    if (seen.has(description)) continue;
+    seen.add(description);
+
+    const existing = db.prepare(`
+      SELECT id, frequency FROM patterns
+      WHERE project_path = ? AND pattern_type = 'decision_chain' AND description = ?
+    `).get(projectPath, description) as any;
+
+    if (existing) {
+      db.prepare(`
+        UPDATE patterns SET frequency = frequency + 1, last_seen = datetime('now') WHERE id = ?
+      `).run(existing.id);
+    } else {
+      db.prepare(`
+        INSERT INTO patterns (project_path, pattern_type, description, frequency, examples)
+        VALUES (?, 'decision_chain', ?, 1, ?)
+      `).run(projectPath, description, `Chain spans ${chain.length} decisions`);
+    }
+  }
+}
+
+const TRANSITION_PATTERNS = [
+  /(?:switched|migrated)\s+(?:from\s+)?([\w\-/@.]+?)\s+to\s+([\w\-/@.]+)/i,
+  /replaced\s+([\w\-/@.]+?)\s+with\s+([\w\-/@.]+)/i,
+  /chose\s+([\w\-/@.]+?)\s+over\s+([\w\-/@.]+)/i,
+  /([\w\-/@.]+?)\s+(?:instead\s+of|rather\s+than)\s+([\w\-/@.]+)/i,
+  // Dependency add: from nothing to pkg
+  /(?:npm|bun|pnpm|yarn|pip|cargo)\s+(?:install|add|i)\s+([@\w\-/\.]+)/i,
+];
+
+function extractTransition(text: string): { from: string; to: string } | null {
+  // Dependency decisions: "from" is implicit (no prior choice)
+  const depMatch = text.match(TRANSITION_PATTERNS[4]);
+  if (depMatch) {
+    return { from: "∅", to: depMatch[1] };
+  }
+
+  for (let i = 0; i < 4; i++) {
+    const m = text.match(TRANSITION_PATTERNS[i]);
+    if (m) {
+      // Pattern 3 is "X instead of Y" — X is chosen, Y is rejected
+      if (i === 3) return { from: m[2], to: m[1] };
+      return { from: m[1], to: m[2] };
+    }
+  }
+  return null;
+}
+
+function normalize(s: string): string {
+  return s.toLowerCase().replace(/[^a-z0-9]/g, "");
+}

package/src/ai/decision-extractor.ts

@@ -0,0 +1,148 @@
+// Extracts architectural decisions from observation summaries
+
+import type { Observation } from "../db/sqlite/observations";
+import type { Decision } from "../db/sqlite/decisions";
+
+const DECISION_PATTERNS = [
+  /chose\s+(.+?)\s+(?:over|instead\s+of|rather\s+than)\s+(.+)/i,
+  /decided\s+(?:to\s+)?(?:use|go\s+with|switch\s+to)\s+(.+?)(?:\s+because|\s+since|\.|$)/i,
+  /switched\s+(?:from\s+(.+?)\s+)?to\s+(.+?)(?:\s+because|\s+since|\.|$)/i,
+  /replaced\s+(.+?)\s+with\s+(.+)/i,
+  /migrated?\s+(?:from\s+(.+?)\s+)?to\s+(.+)/i,
+  /picked\s+(.+?)\s+(?:over|for)/i,
+];
+
+export function extractDecisionsFromObservations(
+  observations: Observation[],
+  projectPath?: string
+): Decision[] {
+  const decisions: Decision[] = [];
+  const seen = new Set<string>();
+
+  for (const obs of observations) {
+    const dep = detectDependencyDecision(obs.summary);
+    if (dep) {
+      const key = `dep:${dep.pkg}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      decisions.push({
+        project_path: projectPath,
+        title: `Added ${dep.manager} dep: ${dep.pkg}`,
+        decision_text: obs.summary,
+        alternatives: undefined,
+        rationale: `Installed via ${dep.manager}`,
+        files_affected: obs.file_paths || undefined,
+      });
+      continue;
+    }
+
+    if (obs.type !== "decision") continue;
+
+    // Promote to architectural decision ONLY when the summary actually matches
+    // one of our decision patterns (chose/switched/migrated/replaced/...).
+    // Without this, anything the classifier scored as `decision` due to a stray
+    // keyword (e.g. an Agent prompt mentioning "architecture") leaks in.
+    if (!matchesDecisionPattern(obs.summary)) continue;
+
+    // Belt-and-suspenders: never let tool-prefixed noise through. The list
+    // grew over time as new shapes of fake decisions surfaced in real DBs:
+    // raw Bash/PowerShell outputs, Edit summaries, Monitor JSON, etc.
+    if (/^(Wrote |mcp__|Created |Spawned agent:|WebFetch |WebSearch:|Notebook |Bash:|PowerShell:|Edit:|Edited |Monitor:|ToolSearch:|TodoWrite|TaskStop:|TaskOutput:)/.test(obs.summary)) continue;
+
+    const title = extractTitle(obs.summary);
+    const key = `title:${title.toLowerCase()}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+
+    const { alternatives, rationale } = parseDecisionDetails(obs.summary);
+
+    decisions.push({
+      project_path: projectPath,
+      title,
+      decision_text: obs.summary,
+      alternatives: alternatives || undefined,
+      rationale: rationale || undefined,
+      files_affected: obs.file_paths || undefined,
+    });
+  }
+
+  return decisions;
+}
+
+function matchesDecisionPattern(summary: string): boolean {
+  return DECISION_PATTERNS.some(p => p.test(summary));
+}
+
+// Generic words that appear in logs/monitors/task descriptions and were being
+// captured as if they were package names. None of these are real npm/pip/cargo
+// packages — they're metadata leaking from surrounding text.
+const PACKAGE_REJECT_LIST = new Set([
+  "output", "progress", "tsx", "tests", "test", "dev", "prod", "build",
+  "start", "all", "true", "false", "yes", "no", "latest", "beta", "alpha",
+  "rc", "stable", "debug", "verbose", "help", "version", "init", "run",
+  "fix", "lint", "format", "check", "watch", "serve", "clean",
+]);
+
+function detectDependencyDecision(summary: string): { manager: string; pkg: string } | null {
+  const m = summary.match(/\b(npm|bun|pnpm|yarn|pip|cargo|go)\s+(?:install|add|i)\s+([@\w\-/\.]+)/i);
+  if (!m) return null;
+  const pkg = m[2];
+
+  // Skip common generic flags
+  if (/^(-|--)/.test(pkg)) return null;
+  if (!isLikelyPackageName(pkg)) return null;
+
+  return { manager: m[1].toLowerCase(), pkg };
+}
+
+function isLikelyPackageName(pkg: string): boolean {
+  // Scoped packages are always valid (@scope/name)
+  if (pkg.startsWith("@") && pkg.includes("/")) return true;
+
+  // Reject known noise words that appear in log streams
+  if (PACKAGE_REJECT_LIST.has(pkg.toLowerCase())) return false;
+
+  // Reject very short bare words unless they contain @, -, _ or /
+  if (pkg.length < 3 && !/[@\-_/]/.test(pkg)) return false;
+
+  // Reject numeric-only tokens (versions, etc.)
+  if (/^[\d.]+$/.test(pkg)) return false;
+
+  // Reject tokens with no letters at all
+  if (!/[a-z]/i.test(pkg)) return false;
+
+  return true;
+}
+
+function extractTitle(summary: string): string {
+  // Try to find a concise title from the decision
+  for (const pattern of DECISION_PATTERNS) {
+    const match = summary.match(pattern);
+    if (match) {
+      const relevant = match.slice(1).filter(Boolean).join(" → ");
+      return relevant.slice(0, 80);
+    }
+  }
+  // Fallback: first sentence, truncated
+  const firstSentence = summary.split(/[.!?\n]/)[0];
+  return firstSentence.slice(0, 80);
+}
+
+function parseDecisionDetails(summary: string): { alternatives: string | null; rationale: string | null } {
+  let alternatives: string | null = null;
+  let rationale: string | null = null;
+
+  // Extract "instead of X" / "over X"
+  const altMatch = summary.match(/(?:instead\s+of|over|rather\s+than|rejected?)\s+(.+?)(?:\.|,|because|since|$)/i);
+  if (altMatch) {
+    alternatives = altMatch[1].trim();
+  }
+
+  // Extract "because X" / "since X"
+  const reasonMatch = summary.match(/(?:because|since|reason:|rationale:)\s+(.+?)(?:\.|$)/i);
+  if (reasonMatch) {
+    rationale = reasonMatch[1].trim();
+  }
+
+  return { alternatives, rationale };
+}

package/src/ai/pattern-detector.ts

@@ -0,0 +1,147 @@
+// Detects recurring patterns in user's work based on observations
+
+import { getDb } from "../db/sqlite/schema";
+import type { Observation } from "../db/sqlite/observations";
+import { normalizePath } from "../util/path";
+
+interface PatternCandidate {
+  pattern_type: string;
+  description: string;
+  examples: string;
+}
+
+export function detectPatterns(observations: Observation[], projectPath: string): void {
+  const db = getDb();
+  const candidates = analyzeObservations(observations, projectPath);
+
+  for (const candidate of candidates) {
+    // Check if this pattern already exists
+    const existing = db.prepare(`
+      SELECT id, frequency FROM patterns
+      WHERE project_path = ? AND pattern_type = ? AND description = ?
+    `).get(projectPath, candidate.pattern_type, candidate.description) as any;
+
+    if (existing) {
+      // Update frequency
+      db.prepare(`
+        UPDATE patterns SET frequency = frequency + 1, last_seen = datetime('now'),
+        examples = ? WHERE id = ?
+      `).run(candidate.examples, existing.id);
+    } else {
+      // Insert new pattern
+      db.prepare(`
+        INSERT INTO patterns (project_path, pattern_type, description, frequency, examples)
+        VALUES (?, ?, ?, 1, ?)
+      `).run(projectPath, candidate.pattern_type, candidate.description, candidate.examples);
+    }
+  }
+}
+
+function analyzeObservations(observations: Observation[], projectPath: string): PatternCandidate[] {
+  const patterns: PatternCandidate[] = [];
+  const db = getDb();
+
+  // Pattern 1: Tool usage patterns
+  const toolCounts = new Map<string, number>();
+  for (const obs of observations) {
+    if (obs.tool_name) {
+      toolCounts.set(obs.tool_name, (toolCounts.get(obs.tool_name) || 0) + 1);
+    }
+  }
+
+  const dominantTool = [...toolCounts.entries()].sort((a, b) => b[1] - a[1])[0];
+  if (dominantTool && dominantTool[1] >= 5) {
+    // Description must be stable so the (project_path, pattern_type, description)
+    // upsert key matches across sessions — otherwise every session with a
+    // different count inserts a fresh row ("Heavily uses Bash (7 times...)" vs
+    // "(32 times...)" both showing in the same context block).
+    patterns.push({
+      pattern_type: "tool_preference",
+      description: `Heavily uses ${dominantTool[0]}`,
+      examples: `Last session: ${dominantTool[1]}/${observations.length} actions`,
+    });
+  }
+
+  // Pattern 2: Work type patterns (from historical data)
+  const typeCounts = new Map<string, number>();
+  for (const obs of observations) {
+    typeCounts.set(obs.type, (typeCounts.get(obs.type) || 0) + 1);
+  }
+
+  const dominantType = [...typeCounts.entries()].sort((a, b) => b[1] - a[1])[0];
+  if (dominantType && dominantType[1] >= 3) {
+    patterns.push({
+      pattern_type: "work_focus",
+      description: `Sessions focused on ${dominantType[0]}`,
+      examples: observations.filter(o => o.type === dominantType[0]).map(o => o.summary.slice(0, 60)).slice(0, 3).join("; "),
+    });
+  }
+
+  // Pattern 3: File hotspots
+  const fileCounts = new Map<string, number>();
+  for (const obs of observations) {
+    if (obs.file_paths) {
+      for (const fp of obs.file_paths.split(",")) {
+        const norm = normalizePath(fp);
+        if (norm) {
+          fileCounts.set(norm, (fileCounts.get(norm) || 0) + 1);
+        }
+      }
+    }
+  }
+
+  const hotFiles = [...fileCounts.entries()].filter(([, c]) => c >= 3).sort((a, b) => b[1] - a[1]);
+  if (hotFiles.length > 0) {
+    patterns.push({
+      pattern_type: "file_hotspot",
+      description: `Frequently modifies: ${hotFiles.slice(0, 3).map(([f]) => f.split(/[/\\]/).pop()).join(", ")}`,
+      examples: hotFiles.map(([f, c]) => `${f} (${c}x)`).join("; "),
+    });
+  }
+
+  // Pattern 4: Testing pattern detection
+  const hasTests = observations.some(o => o.type === "test");
+  const hasBugFix = observations.some(o => o.type === "bug_fix");
+  const hasNewFeature = observations.some(o => o.type === "new_feature");
+
+  if (hasBugFix && hasTests) {
+    const bugFixIdx = observations.findIndex(o => o.type === "bug_fix");
+    const testIdx = observations.findIndex(o => o.type === "test");
+    if (testIdx > bugFixIdx) {
+      patterns.push({
+        pattern_type: "workflow",
+        description: "Writes tests after fixing bugs (fix-then-test pattern)",
+        examples: "",
+      });
+    } else {
+      patterns.push({
+        pattern_type: "workflow",
+        description: "Writes tests before fixing bugs (TDD pattern)",
+        examples: "",
+      });
+    }
+  }
+
+  // Pattern 5: Time-of-day pattern (from historical)
+  try {
+    const hourRows = db.prepare(`
+      SELECT CAST(strftime('%H', started_at) AS INTEGER) as hour, COUNT(*) as c
+      FROM sessions WHERE project_path = ?
+      GROUP BY hour ORDER BY c DESC LIMIT 3
+    `).all(projectPath) as Array<{ hour: number; c: number }>;
+
+    if (hourRows.length > 0 && hourRows[0].c >= 3) {
+      const peakHour = hourRows[0].hour;
+      const period = peakHour < 12 ? "morning" : peakHour < 18 ? "afternoon" : "evening";
+      patterns.push({
+        pattern_type: "schedule",
+        description: `Most active in the ${period} (around ${peakHour}:00)`,
+        examples: hourRows.map(h => `${h.hour}:00 (${h.c} sessions)`).join(", "),
+      });
+    }
+  } catch {
+    // Historical data not available yet
+  }
+
+  return patterns;
+}

package/src/ai/proactive.ts

@@ -0,0 +1,78 @@
+// Proactive suggestions: surface unfinished work and pending blockers from past sessions
+
+import { getDb } from "../db/sqlite/schema";
+
+export interface UnfinishedItem {
+  summary: string;
+  session_id: string;
+  timestamp: string;
+  age_days: number;
+  file_paths?: string;
+}
+
+export function getUnfinishedItems(projectPath: string, limit = 3): UnfinishedItem[] {
+  const db = getDb();
+
+  try {
+    // Look for blocked observations in the last 30 days for this project
+    const rows = db.prepare(`
+      SELECT o.summary, o.session_id, o.timestamp, o.file_paths
+      FROM observations o
+      JOIN sessions s ON o.session_id = s.session_id
+      WHERE s.project_path = ?
+        AND o.type = 'blocked'
+        AND o.timestamp >= datetime('now', '-30 days')
+      ORDER BY o.timestamp DESC
+      LIMIT ?
+    `).all(projectPath, limit * 2) as Array<{
+      summary: string;
+      session_id: string;
+      timestamp: string;
+      file_paths: string | null;
+    }>;
+
+    const items: UnfinishedItem[] = rows.map(r => ({
+      summary: r.summary,
+      session_id: r.session_id,
+      timestamp: r.timestamp,
+      age_days: ageDays(r.timestamp),
+      file_paths: r.file_paths || undefined,
+    }));
+
+    // Filter: skip items from the currently active session
+    const active = db.prepare(`
+      SELECT session_id FROM sessions
+      WHERE project_path = ? AND ended_at IS NULL
+      ORDER BY started_at DESC LIMIT 1
+    `).get(projectPath) as { session_id: string } | undefined;
+
+    const filtered = active
+      ? items.filter(i => i.session_id !== active.session_id)
+      : items;
+
+    // Dedup near-identical summaries
+    const seen = new Set<string>();
+    const deduped: UnfinishedItem[] = [];
+    for (const item of filtered) {
+      const key = item.summary.slice(0, 60).toLowerCase();
+      if (!seen.has(key)) {
+        seen.add(key);
+        deduped.push(item);
+      }
+      if (deduped.length >= limit) break;
+    }
+
+    return deduped;
+  } catch {
+    return [];
+  }
+}
+
+function ageDays(timestamp: string): number {
+  try {
+    const diff = Date.now() - new Date(timestamp).getTime();
+    return Math.floor(diff / (1000 * 60 * 60 * 24));
+  } catch {
+    return 0;
+  }
+}