autoctxd 0.4.1

package/src/context/builder.ts

@@ -0,0 +1,97 @@
+// Assembles the context block from multiple data sources
+
+import { getDb } from "../db/sqlite/schema";
+import { getRecentSessions } from "../db/sqlite/sessions";
+import { getRecentSummaries } from "../db/sqlite/summaries";
+import { getDecisionsByProject } from "../db/sqlite/decisions";
+import { generateEmbedding } from "../db/vector/embeddings";
+import { searchSimilar } from "../db/vector/client";
+import { formatContextBlock } from "./formatter";
+import { normalizePath } from "../util/path";
+
+export async function buildContext(projectPath: string, gitBranch?: string): Promise<string> {
+  const db = getDb();
+
+  // Gather data from all sources
+  const recentSessions = getRecentSessions(projectPath, 3);
+  const recentSummaries = getRecentSummaries(projectPath, 1, 3);
+  const decisions = getDecisionsByProject(projectPath);
+
+  // Semantic search for similar past work
+  let semanticSummaries: Array<{ session_id: string; text: string; level: number; project_path: string; created_at: string }> = [];
+  try {
+    const contextText = `project ${projectPath} ${gitBranch || ""} development session`;
+    const embedding = await generateEmbedding(contextText);
+    semanticSummaries = await searchSimilar(Array.from(embedding), 5, projectPath);
+  } catch {
+    // Semantic search unavailable
+  }
+
+  // Merge semantic results with recent summaries
+  const allSummaries = [...recentSummaries];
+  for (const sr of semanticSummaries) {
+    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,
+      });
+    }
+  }
+
+  // Hot files
+  const hotFiles = getHotFiles(db, projectPath);
+
+  // Patterns — pick the highest-frequency row per pattern_type so two rows
+  // for the same kind of insight (e.g. "Heavily uses Bash") never both appear.
+  const patterns = 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 }>;
+
+  return formatContextBlock({
+    projectPath,
+    gitBranch,
+    recentSessions,
+    recentSummaries: allSummaries.slice(0, 5),
+    decisions: decisions.slice(0, 5),
+    hotFiles,
+    patterns,
+  });
+}
+
+function getHotFiles(db: any, projectPath: string): string[] {
+  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 [];
+  }
+}

package/src/context/formatter.ts

@@ -0,0 +1,109 @@
+// Formats the context block that gets injected into Claude's session
+
+import type { Decision } from "../db/sqlite/decisions";
+import type { Summary } from "../db/sqlite/summaries";
+import type { Session } from "../db/sqlite/sessions";
+
+interface ContextData {
+  projectPath: string;
+  gitBranch?: string;
+  recentSessions: Session[];
+  recentSummaries: Summary[];
+  decisions: Decision[];
+  hotFiles?: string[];
+  patterns?: Array<{ pattern_type: string; description: string }>;
+  unfinished?: Array<{ summary: string; age_days: number; file_paths?: string }>;
+}
+
+export function formatContextBlock(data: ContextData): string {
+  const lines: string[] = [];
+
+  const branch = data.gitBranch ? ` | Branch: ${data.gitBranch}` : "";
+  lines.push(`╔══════════════════════════════════════════╗`);
+  lines.push(`║  CLAUDE-CTX: SESSION CONTEXT              ║`);
+  lines.push(`║  Project: ${truncPath(data.projectPath, 28)}${branch} ║`);
+  lines.push(`╚══════════════════════════════════════════╝`);
+  lines.push("");
+
+  // Proactive: unfinished items bubble to the top
+  if (data.unfinished && data.unfinished.length > 0) {
+    lines.push("▸ UNFINISHED FROM PAST SESSIONS");
+    for (const u of data.unfinished.slice(0, 3)) {
+      const age = u.age_days === 0 ? "today" : u.age_days === 1 ? "yesterday" : `${u.age_days}d ago`;
+      lines.push(`  ⚠ [${age}] ${truncate(u.summary, 100)}`);
+      if (u.file_paths) {
+        const shortPaths = u.file_paths.split(",").slice(0, 2).map(p => p.trim().split(/[/\\]/).pop()).join(", ");
+        if (shortPaths) lines.push(`      Files: ${shortPaths}`);
+      }
+    }
+    lines.push("");
+  }
+
+  // Decisions (always relevant, never compressed)
+  if (data.decisions.length > 0) {
+    lines.push("▸ ARCHITECTURAL DECISIONS");
+    for (const d of data.decisions.slice(0, 5)) {
+      const date = d.created_at ? formatDate(d.created_at) : "";
+      const alt = d.alternatives ? ` — rejected ${truncate(d.alternatives, 40)}` : "";
+      lines.push(`  • ${d.title} [${date}]${alt}`);
+      if (d.rationale) {
+        lines.push(`    Reason: ${truncate(d.rationale, 60)}`);
+      }
+    }
+    lines.push("");
+  }
+
+  // Recent session summaries — compact format
+  if (data.recentSummaries.length > 0) {
+    lines.push("▸ RECENT SESSIONS");
+    for (const s of data.recentSummaries.slice(0, 3)) {
+      const date = s.created_at ? formatDate(s.created_at) : "";
+      const summaryLines = s.text.split("\n").filter(l => l.trim()).slice(0, 6);
+      lines.push(`  [${date}] ${summaryLines[0] || "Session"}`);
+      for (const line of summaryLines.slice(1)) {
+        lines.push(`    ${line.trim()}`);
+      }
+    }
+    lines.push("");
+  }
+
+  // Hot files
+  if (data.hotFiles && data.hotFiles.length > 0) {
+    lines.push(`▸ HOT FILES (frequently modified)`);
+    lines.push(`  ${data.hotFiles.slice(0, 6).join(", ")}`);
+    lines.push("");
+  }
+
+  // Patterns
+  if (data.patterns && data.patterns.length > 0) {
+    lines.push("▸ YOUR PATTERNS IN THIS PROJECT");
+    for (const p of data.patterns.slice(0, 4)) {
+      lines.push(`  • ${p.description}`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+function truncPath(path: string, maxLen: number): string {
+  if (path.length <= maxLen) return path;
+  const parts = path.split(/[/\\]/);
+  if (parts.length <= 2) return path.slice(-maxLen);
+  return "..." + parts.slice(-2).join("/");
+}
+
+function truncate(text: string, maxLen: number): string {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen - 3) + "...";
+}
+
+function formatDate(dateStr: string): string {
+  try {
+    const d = new Date(dateStr);
+    const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+    return `${months[d.getMonth()]} ${d.getDate()}`;
+  } catch {
+    return dateStr.slice(0, 10);
+  }
+}

package/src/context/ranker.ts

@@ -0,0 +1,84 @@
+// Ranks context items by relevance to prioritize what gets injected
+
+import type { Decision } from "../db/sqlite/decisions";
+import type { Summary } from "../db/sqlite/summaries";
+
+interface RankedItem {
+  type: "decision" | "summary" | "pattern";
+  text: string;
+  score: number;
+  metadata: Record<string, any>;
+}
+
+export function rankContextItems(
+  decisions: Decision[],
+  summaries: Summary[],
+  patterns: Array<{ pattern_type: string; description: string; frequency?: number }>,
+  tokenBudget = 800
+): RankedItem[] {
+  const items: RankedItem[] = [];
+
+  // Decisions always get high priority (never compressed)
+  for (const d of decisions) {
+    const recency = getRecencyScore(d.created_at);
+    items.push({
+      type: "decision",
+      text: `${d.title}: ${d.decision_text}`,
+      score: 10 + recency, // Base 10 for decisions
+      metadata: d,
+    });
+  }
+
+  // Summaries scored by recency and level
+  for (const s of summaries) {
+    const recency = getRecencyScore(s.created_at);
+    const levelBonus = s.level === 2 ? 2 : s.level === 3 ? 3 : 0;
+    items.push({
+      type: "summary",
+      text: s.text,
+      score: 5 + recency + levelBonus,
+      metadata: s,
+    });
+  }
+
+  // Patterns scored by frequency
+  for (const p of patterns) {
+    items.push({
+      type: "pattern",
+      text: p.description,
+      score: 3 + Math.min(5, (p.frequency || 1) / 2),
+      metadata: p,
+    });
+  }
+
+  // Sort by score descending
+  items.sort((a, b) => b.score - a.score);
+
+  // Trim to fit token budget (rough estimate: 4 chars per token)
+  let totalChars = 0;
+  const result: RankedItem[] = [];
+  for (const item of items) {
+    const itemChars = item.text.length + 50; // 50 for formatting overhead
+    if (totalChars + itemChars > tokenBudget * 4) break;
+    totalChars += itemChars;
+    result.push(item);
+  }
+
+  return result;
+}
+
+function getRecencyScore(dateStr?: string): number {
+  if (!dateStr) return 0;
+  try {
+    const ageMs = Date.now() - new Date(dateStr).getTime();
+    const ageDays = ageMs / (1000 * 60 * 60 * 24);
+    if (ageDays < 1) return 5;
+    if (ageDays < 3) return 4;
+    if (ageDays < 7) return 3;
+    if (ageDays < 14) return 2;
+    if (ageDays < 30) return 1;
+    return 0;
+  } catch {
+    return 0;
+  }
+}

package/src/db/sqlite/decisions.ts

@@ -0,0 +1,56 @@
+import { getDb } from "./schema";
+
+export interface Decision {
+  id?: number;
+  project_path?: string;
+  title: string;
+  decision_text: string;
+  alternatives?: string;
+  rationale?: string;
+  files_affected?: string;
+  embedding_id?: string;
+  created_at?: string;
+  last_referenced?: string;
+}
+
+export function insertDecision(decision: Decision): void {
+  const db = getDb();
+  // INSERT OR IGNORE pairs with the unique index on (project_path, title)
+  // declared in schema.ts: re-extracting the same decision across sessions
+  // becomes a no-op instead of duplicating the row.
+  db.prepare(`
+    INSERT OR IGNORE INTO decisions (project_path, title, decision_text, alternatives, rationale, files_affected, embedding_id)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    decision.project_path || null,
+    decision.title,
+    decision.decision_text,
+    decision.alternatives || null,
+    decision.rationale || null,
+    decision.files_affected || null,
+    decision.embedding_id || null
+  );
+}
+
+export function getDecisionsByProject(projectPath: string): Decision[] {
+  const db = getDb();
+  return db.prepare(`
+    SELECT * FROM decisions WHERE project_path = ? ORDER BY created_at DESC
+  `).all(projectPath) as Decision[];
+}
+
+export function searchDecisions(query: string, limit = 5): Decision[] {
+  const db = getDb();
+  return db.prepare(`
+    SELECT d.* FROM decisions d
+    JOIN decisions_fts fts ON d.id = fts.rowid
+    WHERE decisions_fts MATCH ?
+    ORDER BY rank
+    LIMIT ?
+  `).all(query, limit) as Decision[];
+}
+
+export function touchDecision(id: number) {
+  const db = getDb();
+  db.prepare(`UPDATE decisions SET last_referenced = datetime('now') WHERE id = ?`).run(id);
+}

package/src/db/sqlite/feedback.ts

@@ -0,0 +1,92 @@
+// Stores user feedback on what autoctxd surfaced. Used by the adaptive ranker
+// to suppress irrelevant items and amplify useful ones for this specific user.
+
+import { getDb } from "./schema";
+
+export type Verdict = "useful" | "irrelevant" | "wrong";
+
+export interface Feedback {
+  id?: number;
+  target_type: "decision" | "observation" | "summary" | "pattern" | "unfinished";
+  target_id: string;
+  target_text?: string;
+  verdict: Verdict;
+  reason?: string;
+  project_path?: string;
+  session_id?: string;
+  created_at?: string;
+}
+
+export function recordFeedback(fb: Feedback): number {
+  const db = getDb();
+  const info = db.prepare(`
+    INSERT INTO feedback (target_type, target_id, target_text, verdict, reason, project_path, session_id)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    fb.target_type,
+    fb.target_id,
+    fb.target_text || null,
+    fb.verdict,
+    fb.reason || null,
+    fb.project_path || null,
+    fb.session_id || null
+  );
+  return Number(info.lastInsertRowid);
+}
+
+export function getFeedbackFor(targetType: string, targetId: string): Feedback[] {
+  const db = getDb();
+  return db.prepare(`
+    SELECT * FROM feedback WHERE target_type = ? AND target_id = ? ORDER BY created_at DESC
+  `).all(targetType, targetId) as Feedback[];
+}
+
+// Returns a score delta per target: negative if irrelevant/wrong, positive if useful
+export function getScoreDeltas(projectPath?: string): Map<string, number> {
+  const db = getDb();
+  const rows = (projectPath
+    ? db.prepare(`
+        SELECT target_type, target_id, verdict, COUNT(*) as c FROM feedback
+        WHERE project_path = ? GROUP BY target_type, target_id, verdict
+      `).all(projectPath)
+    : db.prepare(`
+        SELECT target_type, target_id, verdict, COUNT(*) as c FROM feedback
+        GROUP BY target_type, target_id, verdict
+      `).all()
+  ) as Array<{ target_type: string; target_id: string; verdict: Verdict; c: number }>;
+
+  const deltas = new Map<string, number>();
+  for (const r of rows) {
+    const key = `${r.target_type}:${r.target_id}`;
+    const sign = r.verdict === "useful" ? 1 : r.verdict === "irrelevant" ? -2 : -3;
+    deltas.set(key, (deltas.get(key) || 0) + sign * r.c);
+  }
+  return deltas;
+}
+
+// Aggregated stats for dashboard/telemetry
+export function getFeedbackStats(): {
+  total: number;
+  useful: number;
+  irrelevant: number;
+  wrong: number;
+  byType: Record<string, { useful: number; irrelevant: number; wrong: number }>;
+} {
+  const db = getDb();
+  const total = (db.prepare("SELECT COUNT(*) as c FROM feedback").get() as any).c;
+  const useful = (db.prepare("SELECT COUNT(*) as c FROM feedback WHERE verdict = 'useful'").get() as any).c;
+  const irrelevant = (db.prepare("SELECT COUNT(*) as c FROM feedback WHERE verdict = 'irrelevant'").get() as any).c;
+  const wrong = (db.prepare("SELECT COUNT(*) as c FROM feedback WHERE verdict = 'wrong'").get() as any).c;
+
+  const byTypeRows = db.prepare(`
+    SELECT target_type, verdict, COUNT(*) as c FROM feedback GROUP BY target_type, verdict
+  `).all() as Array<{ target_type: string; verdict: Verdict; c: number }>;
+
+  const byType: Record<string, { useful: number; irrelevant: number; wrong: number }> = {};
+  for (const r of byTypeRows) {
+    byType[r.target_type] ||= { useful: 0, irrelevant: 0, wrong: 0 };
+    byType[r.target_type][r.verdict] = r.c;
+  }
+
+  return { total, useful, irrelevant, wrong, byType };
+}

package/src/db/sqlite/observations.ts

@@ -0,0 +1,58 @@
+import { getDb } from "./schema";
+
+export interface Observation {
+  id?: number;
+  session_id: string;
+  type: string;
+  tool_name?: string;
+  summary: string;
+  file_paths?: string;
+  timestamp?: string;
+  importance_score?: number;
+}
+
+export function insertObservation(obs: Observation): void {
+  const db = getDb();
+  db.prepare(`
+    INSERT INTO observations (session_id, type, tool_name, summary, file_paths, importance_score)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(
+    obs.session_id,
+    obs.type,
+    obs.tool_name || null,
+    obs.summary,
+    obs.file_paths || null,
+    obs.importance_score ?? 5
+  );
+}
+
+export function getObservationsBySession(sessionId: string): Observation[] {
+  const db = getDb();
+  return db.prepare(`
+    SELECT * FROM observations WHERE session_id = ? ORDER BY importance_score DESC, timestamp DESC
+  `).all(sessionId) as Observation[];
+}
+
+export function getTopObservations(sessionId: string, limit = 5): Observation[] {
+  const db = getDb();
+  return db.prepare(`
+    SELECT * FROM observations WHERE session_id = ? ORDER BY importance_score DESC LIMIT ?
+  `).all(sessionId, limit) as Observation[];
+}
+
+export function searchObservations(query: string, limit = 10): Observation[] {
+  const db = getDb();
+  return db.prepare(`
+    SELECT o.* FROM observations o
+    JOIN observations_fts fts ON o.id = fts.rowid
+    WHERE observations_fts MATCH ?
+    ORDER BY rank
+    LIMIT ?
+  `).all(query, limit) as Observation[];
+}
+
+export function countObservationsBySession(sessionId: string): number {
+  const db = getDb();
+  const row = db.prepare(`SELECT COUNT(*) as count FROM observations WHERE session_id = ?`).get(sessionId) as any;
+  return row?.count ?? 0;
+}