composto-ai 0.3.0 → 0.4.1

package/dist/memory/api.js

@@ -0,0 +1,986 @@
+#!/usr/bin/env node
+
+// src/memory/db.ts
+import Database from "better-sqlite3";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+function openDatabase(path) {
+  mkdirSync(dirname(path), { recursive: true });
+  const db = new Database(path);
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  db.pragma("foreign_keys = ON");
+  return db;
+}
+
+// src/memory/schema.ts
+var CURRENT_VERSION = 1;
+var V1_SQL = `
+CREATE TABLE IF NOT EXISTS index_state (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS commits (
+  sha         TEXT PRIMARY KEY,
+  parent_sha  TEXT,
+  author      TEXT NOT NULL,
+  timestamp   INTEGER NOT NULL,
+  subject     TEXT NOT NULL,
+  is_fix      INTEGER NOT NULL,
+  is_revert   INTEGER NOT NULL,
+  reverts_sha TEXT,
+  FOREIGN KEY (reverts_sha) REFERENCES commits(sha)
+);
+CREATE INDEX IF NOT EXISTS idx_commits_timestamp ON commits(timestamp);
+CREATE INDEX IF NOT EXISTS idx_commits_is_fix    ON commits(is_fix) WHERE is_fix = 1;
+
+CREATE TABLE IF NOT EXISTS file_touches (
+  commit_sha    TEXT NOT NULL,
+  file_path     TEXT NOT NULL,
+  adds          INTEGER NOT NULL,
+  dels          INTEGER NOT NULL,
+  change_type   TEXT NOT NULL,
+  renamed_from  TEXT,
+  PRIMARY KEY (commit_sha, file_path),
+  FOREIGN KEY (commit_sha) REFERENCES commits(sha)
+);
+CREATE INDEX IF NOT EXISTS idx_ft_file ON file_touches(file_path);
+
+CREATE TABLE IF NOT EXISTS symbols (
+  id              INTEGER PRIMARY KEY,
+  file_path       TEXT NOT NULL,
+  kind            TEXT NOT NULL,
+  qualified_name  TEXT NOT NULL,
+  first_seen_sha  TEXT NOT NULL,
+  last_seen_sha   TEXT,
+  UNIQUE (file_path, kind, qualified_name)
+);
+CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file_path);
+
+CREATE TABLE IF NOT EXISTS symbol_touches (
+  commit_sha    TEXT NOT NULL,
+  symbol_id     INTEGER NOT NULL,
+  change_type   TEXT NOT NULL,
+  PRIMARY KEY (commit_sha, symbol_id),
+  FOREIGN KEY (commit_sha) REFERENCES commits(sha),
+  FOREIGN KEY (symbol_id)  REFERENCES symbols(id)
+);
+CREATE INDEX IF NOT EXISTS idx_st_symbol ON symbol_touches(symbol_id);
+
+CREATE TABLE IF NOT EXISTS fix_links (
+  fix_commit_sha       TEXT NOT NULL,
+  suspected_break_sha  TEXT NOT NULL,
+  evidence_type        TEXT NOT NULL,
+  confidence           REAL NOT NULL,
+  window_hours         INTEGER,
+  PRIMARY KEY (fix_commit_sha, suspected_break_sha, evidence_type),
+  FOREIGN KEY (fix_commit_sha)      REFERENCES commits(sha),
+  FOREIGN KEY (suspected_break_sha) REFERENCES commits(sha)
+);
+CREATE INDEX IF NOT EXISTS idx_fl_break ON fix_links(suspected_break_sha);
+
+CREATE TABLE IF NOT EXISTS signal_calibration (
+  signal_type        TEXT PRIMARY KEY,
+  precision          REAL NOT NULL,
+  sample_size        INTEGER NOT NULL,
+  last_computed_sha  TEXT NOT NULL,
+  computed_at        INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS file_index_state (
+  file_path            TEXT PRIMARY KEY,
+  last_commit_indexed  TEXT NOT NULL,
+  last_blob_indexed    TEXT,
+  indexed_at           INTEGER NOT NULL,
+  parse_failed         INTEGER NOT NULL DEFAULT 0,
+  FOREIGN KEY (last_commit_indexed) REFERENCES commits(sha)
+);
+`;
+function runMigrations(db) {
+  const current = db.pragma("user_version", { simple: true });
+  if (current >= CURRENT_VERSION) return;
+  db.exec("BEGIN");
+  try {
+    db.exec(V1_SQL);
+    db.pragma(`user_version = ${CURRENT_VERSION}`);
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+
+// src/memory/git.ts
+import { execSync } from "child_process";
+function run(cwd, cmd, timeoutMs = 1e4) {
+  return execSync(cmd, { cwd, encoding: "utf-8", timeout: timeoutMs }).trim();
+}
+function revParseHead(cwd) {
+  return run(cwd, "git rev-parse HEAD");
+}
+function isShallowRepo(cwd) {
+  return run(cwd, "git rev-parse --is-shallow-repository") === "true";
+}
+function revListCount(cwd, from, to) {
+  if (from === to) return 0;
+  const out = run(cwd, `git rev-list --count ${from}..${to}`);
+  return parseInt(out, 10);
+}
+function isAncestor(cwd, ancestor, descendant) {
+  try {
+    execSync(`git merge-base --is-ancestor ${ancestor} ${descendant}`, {
+      cwd,
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function countCommits(cwd) {
+  const out = run(cwd, "git rev-list --count HEAD");
+  return parseInt(out, 10);
+}
+
+// src/memory/freshness.ts
+function ensureFresh(db, repoPath) {
+  const head = revParseHead(repoPath);
+  const row = db.prepare("SELECT value FROM index_state WHERE key = 'last_indexed_sha'").get();
+  if (!row) {
+    return {
+      tazelik: "bootstrapping",
+      head,
+      delta: { from: null, to: head },
+      behind_by: 0,
+      rewritten: false
+    };
+  }
+  const last = row.value;
+  if (last === head) {
+    return { tazelik: "fresh", head, delta: null, behind_by: 0, rewritten: false };
+  }
+  const reachable = isAncestor(repoPath, last, head);
+  if (!reachable) {
+    return {
+      tazelik: "bootstrapping",
+      head,
+      delta: { from: null, to: head },
+      behind_by: 0,
+      rewritten: true
+    };
+  }
+  const behind_by = revListCount(repoPath, last, head);
+  return {
+    tazelik: "catching_up",
+    head,
+    delta: { from: last, to: head },
+    behind_by,
+    rewritten: false
+  };
+}
+
+// src/memory/signals/calibration-lookup.ts
+function getCalibration(db, type, fallbackPrecision) {
+  const row = db.prepare("SELECT precision, sample_size FROM signal_calibration WHERE signal_type = ?").get(type);
+  if (!row) {
+    return { precision: fallbackPrecision, sampleSize: 0, source: "heuristic" };
+  }
+  return {
+    precision: row.precision,
+    sampleSize: row.sample_size,
+    source: "repo-calibrated"
+  };
+}
+
+// src/memory/signals/revert-match.ts
+var STRENGTH_BY_EVIDENCE = {
+  revert_marker: 1,
+  short_followup_fix: 0.7,
+  same_region_fix_chain: 0.4
+};
+var FALLBACK_PRECISION = 0.5;
+var MAX_EVIDENCE = 5;
+function computeRevertMatch(db, filePath) {
+  const rows = db.prepare(`
+      SELECT fl.evidence_type, fl.confidence, fl.suspected_break_sha,
+             c.subject, c.timestamp
+        FROM fix_links fl
+        JOIN file_touches ft ON ft.commit_sha = fl.suspected_break_sha
+        JOIN commits c ON c.sha = fl.suspected_break_sha
+       WHERE ft.file_path = ?
+       ORDER BY c.timestamp DESC
+       LIMIT ?
+    `).all(filePath, MAX_EVIDENCE);
+  const cal = getCalibration(db, "revert_match", FALLBACK_PRECISION);
+  if (rows.length === 0) {
+    return {
+      type: "revert_match",
+      strength: 0,
+      precision: cal.precision,
+      sample_size: cal.sampleSize,
+      evidence: []
+    };
+  }
+  let strength = 0;
+  const evidence = [];
+  const now = Math.floor(Date.now() / 1e3);
+  for (const r of rows) {
+    const s = STRENGTH_BY_EVIDENCE[r.evidence_type] ?? 0;
+    if (s > strength) strength = s;
+    evidence.push({
+      commit_sha: r.suspected_break_sha,
+      subject: r.subject,
+      days_ago: Math.floor((now - r.timestamp) / 86400),
+      evidence_type: r.evidence_type
+    });
+  }
+  return {
+    type: "revert_match",
+    strength,
+    precision: cal.precision,
+    sample_size: cal.sampleSize,
+    evidence
+  };
+}
+
+// src/memory/signals/hotspot.ts
+var WINDOW_SECONDS = 90 * 86400;
+var SATURATION_TOUCHES = 30;
+var FALLBACK_PRECISION2 = 0.3;
+function computeHotspot(db, filePath) {
+  const now = Math.floor(Date.now() / 1e3);
+  const lowerBound = now - WINDOW_SECONDS;
+  const row = db.prepare(`
+      SELECT COUNT(*) AS n
+      FROM file_touches ft
+      JOIN commits c ON c.sha = ft.commit_sha
+      WHERE ft.file_path = ? AND c.timestamp >= ?
+    `).get(filePath, lowerBound);
+  const touches = row.n;
+  const strength = Math.min(1, touches / SATURATION_TOUCHES);
+  const cal = getCalibration(db, "hotspot", FALLBACK_PRECISION2);
+  return {
+    type: "hotspot",
+    strength,
+    precision: cal.precision,
+    sample_size: cal.sampleSize,
+    evidence: [],
+    touches_90d: touches
+  };
+}
+
+// src/memory/signals/fix-ratio.ts
+var WINDOW_COMMITS = 30;
+var DEAD_ZONE = 0.3;
+var SATURATION_OVER_DEAD_ZONE = 0.5;
+var FALLBACK_PRECISION3 = 0.3;
+function computeFixRatio(db, filePath) {
+  const rows = db.prepare(`
+      SELECT c.is_fix
+      FROM file_touches ft
+      JOIN commits c ON c.sha = ft.commit_sha
+      WHERE ft.file_path = ?
+      ORDER BY c.timestamp DESC
+      LIMIT ?
+    `).all(filePath, WINDOW_COMMITS);
+  const cal = getCalibration(db, "fix_ratio", FALLBACK_PRECISION3);
+  if (rows.length === 0) {
+    return {
+      type: "fix_ratio",
+      strength: 0,
+      precision: cal.precision,
+      sample_size: cal.sampleSize,
+      evidence: [],
+      ratio: 0
+    };
+  }
+  const fixes = rows.filter((r) => r.is_fix === 1).length;
+  const ratio = fixes / rows.length;
+  const strength = Math.max(0, Math.min(1, (ratio - DEAD_ZONE) / SATURATION_OVER_DEAD_ZONE));
+  return {
+    type: "fix_ratio",
+    strength,
+    precision: cal.precision,
+    sample_size: cal.sampleSize,
+    evidence: [],
+    ratio
+  };
+}
+
+// src/trends/git-log-parser.ts
+import { execSync as execSync2 } from "child_process";
+var BUG_FIX_PATTERNS = [
+  /\bfix\b/i,
+  /\bbugfix\b/i,
+  /\bhotfix\b/i,
+  /\bpatch\b/i,
+  /\bresolve\b/i,
+  /\bbug\b/i
+];
+function isBugFixCommit(message) {
+  return BUG_FIX_PATTERNS.some((p) => p.test(message));
+}
+function parseGitLogOutput(output) {
+  const entries = [];
+  const lines = output.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i].trim();
+    if (!line || !line.includes("|")) {
+      i++;
+      continue;
+    }
+    const [hash, author, date, ...messageParts] = line.split("|");
+    const message = messageParts.join("|");
+    const files = [];
+    i++;
+    while (i < lines.length && lines[i].trim() !== "" && !lines[i].includes("|")) {
+      const fileLine = lines[i].trim();
+      if (fileLine) files.push(fileLine);
+      i++;
+    }
+    entries.push({ hash, author, date, message, files });
+  }
+  return entries;
+}
+function getGitLog(repoPath, count = 100) {
+  try {
+    const output = execSync2(
+      `git log --format="%h|%an|%as|%s" --name-only -n ${count}`,
+      { cwd: repoPath, encoding: "utf-8", timeout: 1e4 }
+    );
+    return parseGitLogOutput(output);
+  } catch {
+    return [];
+  }
+}
+
+// src/trends/hotspot.ts
+function detectHotspots(entries, options) {
+  const fileStats = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const isFix = isBugFixCommit(entry.message);
+    for (const file of entry.files) {
+      const stats = fileStats.get(file) ?? { changes: 0, fixes: 0, authors: /* @__PURE__ */ new Set() };
+      stats.changes++;
+      if (isFix) stats.fixes++;
+      stats.authors.add(entry.author);
+      fileStats.set(file, stats);
+    }
+  }
+  const hotspots = [];
+  for (const [file, stats] of fileStats) {
+    const fixRatio = stats.changes > 0 ? stats.fixes / stats.changes : 0;
+    if (stats.changes >= options.threshold && fixRatio >= options.fixRatioThreshold) {
+      hotspots.push({
+        file,
+        changesInLast30Commits: stats.changes,
+        bugFixRatio: fixRatio,
+        authorCount: stats.authors.size
+      });
+    }
+  }
+  return hotspots.sort((a, b) => b.changesInLast30Commits - a.changesInLast30Commits);
+}
+
+// src/trends/decay.ts
+function detectDecay(entries) {
+  const fileChanges = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const file of entry.files) {
+      const changes = fileChanges.get(file) ?? [];
+      changes.push({ date: entry.date });
+      fileChanges.set(file, changes);
+    }
+  }
+  const signals = [];
+  for (const [file, changes] of fileChanges) {
+    if (changes.length < 4) continue;
+    const sorted = [...changes].sort((a, b) => a.date.localeCompare(b.date));
+    const firstDate = new Date(sorted[0].date).getTime();
+    const lastDate = new Date(sorted[sorted.length - 1].date).getTime();
+    const midDate = firstDate + (lastDate - firstDate) / 2;
+    const firstHalfCount = sorted.filter((c) => new Date(c.date).getTime() <= midDate).length;
+    const secondHalfCount = sorted.length - firstHalfCount;
+    if (secondHalfCount > firstHalfCount) {
+      signals.push({
+        file,
+        metric: "churn",
+        trend: "declining",
+        dataPoints: sorted.map((c, i) => ({ date: c.date, value: i + 1 }))
+      });
+    }
+  }
+  return signals;
+}
+
+// src/trends/inconsistency.ts
+function detectInconsistencies(entries, minAuthors = 3) {
+  const fileAuthors = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const file of entry.files) {
+      const authors = fileAuthors.get(file) ?? /* @__PURE__ */ new Map();
+      const commits = authors.get(entry.author) ?? [];
+      commits.push(entry.message);
+      authors.set(entry.author, commits);
+      fileAuthors.set(file, authors);
+    }
+  }
+  const inconsistencies = [];
+  for (const [file, authors] of fileAuthors) {
+    if (authors.size >= minAuthors) {
+      const patterns = Array.from(authors.entries()).map(([author, commits]) => ({
+        author,
+        style: categorizeStyle(commits)
+      }));
+      inconsistencies.push({ file, patterns });
+    }
+  }
+  return inconsistencies;
+}
+function categorizeStyle(commits) {
+  const types = commits.map((m) => {
+    if (m.match(/^fix/i)) return "fix";
+    if (m.match(/^feat/i)) return "feature";
+    if (m.match(/^refactor/i)) return "refactor";
+    return "other";
+  });
+  const primary = mode(types);
+  return `primarily ${primary} (${commits.length} commits)`;
+}
+function mode(arr) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of arr) {
+    counts.set(item, (counts.get(item) ?? 0) + 1);
+  }
+  return Array.from(counts.entries()).sort((a, b) => b[1] - a[1])[0]?.[0] ?? "unknown";
+}
+
+// src/ir/health.ts
+function computeHealthFromTrends(file, trends) {
+  const hotspot = trends.hotspots.find((h) => h.file === file);
+  const decay = trends.decaySignals.find((d) => d.file === file);
+  const inconsistency = trends.inconsistencies.find((i) => i.file === file);
+  return {
+    churn: hotspot?.changesInLast30Commits ?? 0,
+    fixRatio: hotspot?.bugFixRatio ?? 0,
+    coverageTrend: decay?.trend === "declining" ? "down" : decay?.trend === "improving" ? "up" : "stable",
+    staleness: "",
+    authorCount: hotspot?.authorCount ?? 0,
+    consistency: inconsistency ? "low" : "high"
+  };
+}
+
+// src/memory/signals/coverage-decline.ts
+var FALLBACK_PRECISION4 = 0.3;
+function computeCoverageDecline(db, repoPath, filePath) {
+  const cal = getCalibration(db, "coverage_decline", FALLBACK_PRECISION4);
+  let strength = 0;
+  try {
+    const entries = getGitLog(repoPath, 200);
+    const trends = {
+      hotspots: detectHotspots(entries, { threshold: 10, fixRatioThreshold: 0.5 }),
+      decaySignals: detectDecay(entries),
+      inconsistencies: detectInconsistencies(entries)
+    };
+    const health = computeHealthFromTrends(filePath, trends);
+    if (health.coverageTrend === "down") strength = 1;
+  } catch {
+    strength = 0;
+  }
+  return {
+    type: "coverage_decline",
+    strength,
+    precision: cal.precision,
+    sample_size: cal.sampleSize,
+    evidence: []
+  };
+}
+
+// src/memory/signals/author-churn.ts
+var WINDOW_SECONDS2 = 90 * 86400;
+var INACTIVE_THRESHOLD = 5;
+var FALLBACK_PRECISION5 = 0.3;
+function computeAuthorChurn(db, filePath) {
+  const cal = getCalibration(db, "author_churn", FALLBACK_PRECISION5);
+  const base = {
+    type: "author_churn",
+    precision: cal.precision,
+    sample_size: cal.sampleSize,
+    evidence: []
+  };
+  const lastTouch = db.prepare(`
+      SELECT c.author, c.timestamp
+      FROM file_touches ft
+      JOIN commits c ON c.sha = ft.commit_sha
+      WHERE ft.file_path = ?
+      ORDER BY c.timestamp DESC
+      LIMIT 1
+    `).get(filePath);
+  if (!lastTouch) return { ...base, strength: 0 };
+  const now = Math.floor(Date.now() / 1e3);
+  const lowerBound = now - WINDOW_SECONDS2;
+  const activity = db.prepare(`SELECT COUNT(*) AS n FROM commits WHERE author = ? AND timestamp >= ?`).get(lastTouch.author, lowerBound);
+  let strength = 0;
+  if (activity.n === 0) strength = 1;
+  else if (activity.n < INACTIVE_THRESHOLD) strength = 0.5;
+  return { ...base, strength };
+}
+
+// src/memory/signals/index.ts
+function collectSignals(db, repoPath, filePath) {
+  return [
+    computeRevertMatch(db, filePath),
+    computeHotspot(db, filePath),
+    computeFixRatio(db, filePath),
+    computeCoverageDecline(db, repoPath, filePath),
+    computeAuthorChurn(db, filePath)
+  ];
+}
+
+// src/memory/confidence.ts
+var USABLE_SAMPLE_THRESHOLD = 20;
+function coverageFactor(signals) {
+  const usable = signals.filter(
+    (s) => s.strength > 0 && s.sample_size >= USABLE_SAMPLE_THRESHOLD
+  ).length;
+  return Math.min(1, usable / 3);
+}
+function calibrationFactor(signals) {
+  const firing = signals.filter((s) => s.strength > 0);
+  if (firing.length === 0) return 1;
+  const avg = firing.reduce((acc, s) => acc + s.sample_size, 0) / firing.length;
+  if (avg < 20) return 0.3;
+  if (avg < 100) return 0.6;
+  return 1;
+}
+function freshnessFactor(ctx) {
+  if (ctx.partial) return 0.4;
+  switch (ctx.tazelik) {
+    case "fresh":
+      return 1;
+    case "catching_up":
+      return 0.8;
+    case "partial":
+      return 0.4;
+    case "bootstrapping":
+      return 0.2;
+  }
+}
+function historyFactor(totalCommits) {
+  if (totalCommits < 50) return 0.2;
+  if (totalCommits < 200) return 0.5;
+  if (totalCommits < 1e3) return 0.8;
+  return 1;
+}
+function computeScoreAndConfidence(signals, ctx) {
+  let num = 0;
+  let den = 0;
+  for (const s of signals) {
+    if (s.strength <= 0 || s.precision <= 0) continue;
+    num += s.strength * s.precision;
+    den += s.precision;
+  }
+  const score = den === 0 ? 0 : num / den;
+  const confidence = Math.min(
+    coverageFactor(signals),
+    calibrationFactor(signals),
+    freshnessFactor(ctx),
+    historyFactor(ctx.totalCommits)
+  );
+  return { score, confidence };
+}
+
+// src/memory/verdict.ts
+function mapVerdict(score, confidence) {
+  if (confidence < 0.3) return "unknown";
+  if (score < 0.3) return "low";
+  if (score < 0.6) return "medium";
+  return "high";
+}
+
+// src/memory/envelope.ts
+var CONFIDENCE_CAP = {
+  ok: 1,
+  empty_repo: 0,
+  insufficient_history: 0.3,
+  shallow_clone: 0,
+  indexing: 0.4,
+  squashed_history: 0.5,
+  reindexing: 0,
+  internal_error: 0,
+  disabled: 0
+};
+var USABLE_SAMPLE_THRESHOLD2 = 20;
+function inferCalibrationSource(signals) {
+  return signals.some((s) => s.sample_size > 0) ? "repo-calibrated" : "heuristic";
+}
+function buildEnvelope(args) {
+  const cap = CONFIDENCE_CAP[args.status];
+  const cappedConfidence = Math.min(args.confidence, cap);
+  const verdict = mapVerdict(args.score, cappedConfidence);
+  const usable = args.signals.filter(
+    (s) => s.strength > 0 && s.sample_size >= USABLE_SAMPLE_THRESHOLD2
+  ).length;
+  return {
+    status: args.status,
+    reason: args.reason,
+    verdict,
+    score: args.score,
+    confidence: cappedConfidence,
+    signals: args.signals,
+    calibration: inferCalibrationSource(args.signals),
+    retry_hint_ms: args.retry_hint_ms,
+    confidence_cap: args.status === "ok" ? void 0 : cap,
+    metadata: {
+      tazelik: args.tazelik,
+      index_version: 1,
+      indexed_commits_through: args.indexedThrough,
+      indexed_commits_total: args.indexedTotal,
+      query_ms: args.queryMs,
+      signal_coverage: `${usable}/${args.signals.length}`
+    }
+  };
+}
+
+// src/memory/pool.ts
+import { Worker } from "worker_threads";
+import { fileURLToPath } from "url";
+import { dirname as dirname2, join } from "path";
+function resolveWorkerPath() {
+  const here = dirname2(fileURLToPath(import.meta.url));
+  if (here.endsWith("/memory") || here.endsWith("\\memory")) {
+    return join(here, "worker.js");
+  }
+  return join(here, "memory", "worker.js");
+}
+var WorkerPool = class {
+  workers = [];
+  nextJobId = 1;
+  pending = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    const size = Math.max(1, opts.size ?? 1);
+    for (let i = 0; i < size; i++) this.spawn();
+  }
+  spawn() {
+    const worker = new Worker(resolveWorkerPath());
+    worker.on("message", (msg) => {
+      const job = this.pending.get(msg.jobId);
+      if (!job) return;
+      this.pending.delete(msg.jobId);
+      if (msg.type === "ingest_done") {
+        job.resolve({ status: "done", commits: msg.commits });
+      } else if (msg.type === "ingest_error") {
+        job.reject(new Error(msg.message));
+      }
+    });
+    worker.on("error", (err) => {
+      const error = err instanceof Error ? err : new Error(String(err));
+      for (const job of this.pending.values()) job.reject(error);
+      this.pending.clear();
+    });
+    this.workers.push(worker);
+  }
+  runIngest(args) {
+    const jobId = this.nextJobId++;
+    const worker = this.workers[jobId % this.workers.length];
+    return new Promise((resolve, reject) => {
+      this.pending.set(jobId, { resolve, reject });
+      worker.postMessage({ type: "ingest", jobId, ...args });
+    });
+  }
+  async close() {
+    await Promise.all(this.workers.map((w) => w.terminate()));
+    this.workers = [];
+    this.pending.clear();
+  }
+};
+
+// src/memory/detectors.ts
+function detectSquashed(db) {
+  const row = db.prepare(`
+    SELECT author, COUNT(*) AS n, MIN(timestamp) AS t0, MAX(timestamp) AS t1
+    FROM commits
+    GROUP BY author
+    ORDER BY n DESC
+    LIMIT 1
+  `).get();
+  if (!row || row.n < 50) return false;
+  const span = row.t1 - row.t0;
+  return span < 86400;
+}
+
+// src/memory/failure-tracker.ts
+import { readFileSync, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+var STRIKE_THRESHOLD = 3;
+var WINDOW_SECONDS3 = 300;
+function createFailureTracker(composto_dir) {
+  const path = join2(composto_dir, "failures.json");
+  try {
+    mkdirSync2(composto_dir, { recursive: true });
+  } catch {
+  }
+  function load() {
+    try {
+      const raw = readFileSync(path, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return { failures: [], disabled: false };
+    }
+  }
+  function save(s) {
+    try {
+      writeFileSync(path, JSON.stringify(s), "utf-8");
+    } catch {
+    }
+  }
+  function now() {
+    return Math.floor(Date.now() / 1e3);
+  }
+  return {
+    recordFailure: (failureClass) => {
+      const s = load();
+      s.failures.push({ class: failureClass, t: now() });
+      s.failures = s.failures.filter((f) => now() - f.t <= WINDOW_SECONDS3);
+      const sameClass = s.failures.filter((f) => f.class === failureClass);
+      if (sameClass.length >= STRIKE_THRESHOLD) s.disabled = true;
+      save(s);
+    },
+    recordSuccess: () => {
+      save({ failures: [], disabled: false });
+    },
+    isDisabled: () => {
+      return load().disabled;
+    }
+  };
+}
+
+// src/memory/log.ts
+import { appendFileSync, mkdirSync as mkdirSync3, readdirSync, renameSync, statSync, unlinkSync } from "fs";
+import { join as join3 } from "path";
+var LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
+var RETENTION_DAYS = 7;
+function currentThreshold() {
+  const raw = (process.env.COMPOSTO_LOG ?? "info").toLowerCase();
+  if (raw === "debug" || raw === "info" || raw === "warn" || raw === "error") return raw;
+  return "info";
+}
+function rotateIfNeeded(dir) {
+  const logPath = join3(dir, "index.log");
+  try {
+    const s = statSync(logPath);
+    const age = (Date.now() - s.mtimeMs) / 864e5;
+    if (age < 1) return;
+    const files = readdirSync(dir).filter((f) => /^index\.log(\.\d+)?$/.test(f));
+    const numbered = files.map((f) => {
+      const m = f.match(/^index\.log\.(\d+)$/);
+      return { name: f, n: m ? parseInt(m[1], 10) : 0 };
+    }).sort((a, b) => b.n - a.n);
+    for (const f of numbered) {
+      if (f.n >= RETENTION_DAYS) {
+        unlinkSync(join3(dir, f.name));
+        continue;
+      }
+      if (f.n === 0) {
+        renameSync(join3(dir, f.name), join3(dir, "index.log.1"));
+      } else {
+        renameSync(join3(dir, f.name), join3(dir, `index.log.${f.n + 1}`));
+      }
+    }
+  } catch {
+  }
+}
+function createLogger(composto_dir) {
+  let disabled = false;
+  try {
+    mkdirSync3(composto_dir, { recursive: true });
+    rotateIfNeeded(composto_dir);
+  } catch {
+    disabled = true;
+  }
+  const path = join3(composto_dir, "index.log");
+  const threshold = currentThreshold();
+  function write(level, evt, extras) {
+    if (disabled) return;
+    if (LEVEL_ORDER[level] < LEVEL_ORDER[threshold]) return;
+    const line = JSON.stringify({
+      t: Math.floor(Date.now() / 1e3),
+      lvl: level,
+      evt,
+      ...extras ?? {}
+    });
+    try {
+      appendFileSync(path, line + "\n", "utf-8");
+    } catch {
+      disabled = true;
+    }
+  }
+  return {
+    debug: (evt, extras) => write("debug", evt, extras),
+    info: (evt, extras) => write("info", evt, extras),
+    warn: (evt, extras) => write("warn", evt, extras),
+    error: (evt, extras) => write("error", evt, extras),
+    close: () => {
+    }
+  };
+}
+
+// src/memory/api.ts
+import { dirname as dirname3 } from "path";
+var EMPTY_REPO_THRESHOLD = 10;
+var MemoryAPI = class {
+  db;
+  pool;
+  dbPath;
+  repoPath;
+  compostoDir;
+  log;
+  failures;
+  bootstrapPromise = null;
+  constructor(opts) {
+    this.dbPath = opts.dbPath;
+    this.repoPath = opts.repoPath;
+    this.compostoDir = dirname3(opts.dbPath);
+    this.log = createLogger(this.compostoDir);
+    this.failures = createFailureTracker(this.compostoDir);
+    this.db = openDatabase(opts.dbPath);
+    runMigrations(this.db);
+    this.pool = new WorkerPool({ size: opts.workerPoolSize ?? 1 });
+    this.log.info("api_open", { dbPath: opts.dbPath });
+  }
+  async bootstrapIfNeeded() {
+    if (this.bootstrapPromise) return this.bootstrapPromise;
+    const fresh = ensureFresh(this.db, this.repoPath);
+    if (fresh.tazelik === "fresh" || !fresh.delta) return;
+    this.bootstrapPromise = this.pool.runIngest({ dbPath: this.dbPath, repoPath: this.repoPath, range: fresh.delta }).then(() => {
+      this.log.info("bootstrap_done", { through: fresh.delta?.to });
+    }).catch((err) => {
+      this.log.error("bootstrap_failed", { message: err.message });
+      this.failures.recordFailure("ingest_failure");
+      throw err;
+    }).finally(() => {
+      this.bootstrapPromise = null;
+    });
+    return this.bootstrapPromise;
+  }
+  async blastradius(input) {
+    const start = Date.now();
+    if (this.failures.isDisabled()) {
+      this.log.warn("call_on_disabled", { file: input.file });
+      return buildEnvelope({
+        status: "disabled",
+        signals: [],
+        score: 0,
+        confidence: 0,
+        tazelik: "fresh",
+        indexedThrough: "",
+        indexedTotal: 0,
+        queryMs: Date.now() - start,
+        reason: "tool disabled after repeated failures; clear .composto/failures.json to re-enable"
+      });
+    }
+    try {
+      return await this.runQuery(input, start);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.log.error("internal_error", { file: input.file, message });
+      this.failures.recordFailure("internal_error");
+      return buildEnvelope({
+        status: "internal_error",
+        signals: [],
+        score: 0,
+        confidence: 0,
+        tazelik: "fresh",
+        indexedThrough: "",
+        indexedTotal: 0,
+        queryMs: Date.now() - start,
+        reason: `internal error: ${message}; see .composto/index.log`
+      });
+    }
+  }
+  async runQuery(input, start) {
+    if (isShallowRepo(this.repoPath)) {
+      return buildEnvelope({
+        status: "shallow_clone",
+        signals: [],
+        score: 0,
+        confidence: 0,
+        tazelik: "fresh",
+        indexedThrough: "",
+        indexedTotal: 0,
+        queryMs: Date.now() - start,
+        reason: "shallow clone detected; run `git fetch --unshallow` or `composto index --deepen`"
+      });
+    }
+    const totalCommits = countCommits(this.repoPath);
+    if (totalCommits < EMPTY_REPO_THRESHOLD) {
+      return buildEnvelope({
+        status: "empty_repo",
+        signals: [],
+        score: 0,
+        confidence: 0,
+        tazelik: "fresh",
+        indexedThrough: "",
+        indexedTotal: totalCommits,
+        queryMs: Date.now() - start,
+        reason: `repo has ${totalCommits} commits; blastradius requires >= ${EMPTY_REPO_THRESHOLD}`
+      });
+    }
+    const fresh = ensureFresh(this.db, this.repoPath);
+    let status = "ok";
+    if (fresh.rewritten) {
+      status = "reindexing";
+      this.log.warn("history_rewritten", { last_indexed: fresh.head });
+    }
+    if (fresh.tazelik === "bootstrapping") {
+      await this.bootstrapIfNeeded();
+    } else if (fresh.tazelik === "catching_up" && fresh.delta) {
+      this.pool.runIngest({ dbPath: this.dbPath, repoPath: this.repoPath, range: fresh.delta }).catch((err) => {
+        this.log.error("delta_ingest_failed", { message: err.message });
+      });
+    }
+    if (status === "ok" && detectSquashed(this.db)) {
+      status = "squashed_history";
+    }
+    const indexedTotalRow = this.db.prepare("SELECT value FROM index_state WHERE key='indexed_commits_total'").get();
+    const indexedTotal = indexedTotalRow ? parseInt(indexedTotalRow.value, 10) : 0;
+    const indexedThrough = this.db.prepare("SELECT value FROM index_state WHERE key='last_indexed_sha'").get()?.value ?? "";
+    const signals = collectSignals(this.db, this.repoPath, input.file);
+    const tazelik = fresh.tazelik === "bootstrapping" ? "fresh" : fresh.tazelik;
+    const { score, confidence } = computeScoreAndConfidence(signals, {
+      tazelik,
+      partial: false,
+      totalCommits: indexedTotal
+    });
+    const response = buildEnvelope({
+      status,
+      signals,
+      score,
+      confidence,
+      tazelik,
+      indexedThrough,
+      indexedTotal,
+      queryMs: Date.now() - start
+    });
+    this.log.info("query", {
+      file: input.file,
+      status: response.status,
+      verdict: response.verdict,
+      confidence: response.confidence,
+      query_ms: response.metadata.query_ms
+    });
+    this.failures.recordSuccess();
+    return response;
+  }
+  async close() {
+    this.log.info("api_close", {});
+    this.log.close();
+    this.db.close();
+    await this.pool.close();
+  }
+};
+export {
+  MemoryAPI
+};