scopecairn 0.9.0 → 0.10.0

package/README.md

@@ -149,7 +149,8 @@ scopecairn agents list
 | `init [path]` | Initial indexing + Skill, Workflow, detected agent skills (`--agents …\|all`; never writes `AGENTS.md`) |
 | `scan` / `rebuild` / `clean` | Manual index management (`scan` incremental; `rebuild` from scratch; `clean` removes `.scopecairn/`) |
 | `status` / `doctor` | Index status (incl. adapters, invocations) and health checks |
-| `context "<task>"` | Main entry point: context + scope (`--escalate`, `--no-refresh`, `--mode NORMAL|FAST|SAFE|AUDIT`, `--max-tokens N`); a path task returns an orientation map |
+| `context "<task>"` | Main entry point: context + scope (`--escalate`, `--no-refresh`, `--mode NORMAL|FAST|SAFE|AUDIT`, `--max-tokens N`, `--no-history`, `--with-diff`); a path task returns an orientation map |
+| `history "<task>" [--limit N] [--json] [--with-diff]` | Analog commit lama paling mirip (BM25 + recency half-life 180 hari + co-change); co-change set ikut ke Optional di `context` |
 | `impact <path\|symbol>` | Change impact: direct, indirect, tests (via TESTS edges + static CALLS backward reachability), UI, queries, routes. Edge evidence tagged EXTRACTED/INFERRED/AMBIGUOUS |
 | `graph <symbol>` | Symbol relations (+ PageRank, community, cycle status) |
 | `path <from> <to>` | Shortest multi-hop call/dependency path between two symbols |
@@ -205,6 +206,16 @@ prompt → scopecairn context (refresh at start) → agent edits code
 
 Measure retrieval quality anytime: `scopecairn benchmark [--tune]`.
 
+## History privacy
+
+`scan` mengindeks pesan commit git lokal ke tabel `commits`/`commit_files` di
+`.scopecairn/scopecairn.db` (dilewati commit >40 file, lockfile, dan generated).
+Isi commit **tidak** masuk `GRAPH.md`/`GRAPH.html`/`export` (sering di-commit dan
+dibagikan) — riwayat hanya hidup di database lokal dan output `context`/`history`.
+Pesan commit bisa memuat info sensitif; karena tidak keluar dari mesin, risikonya
+kecil. Repo tanpa git atau clone dangkal tetap didukung (riwayat parsial/absen,
+dilaporkan `doctor`).
+
 ## License
 
 MIT — see [LICENSE](./LICENSE).

package/dist/chunk-2BIPX6YJ.js

@@ -0,0 +1,326 @@
+#!/usr/bin/env node
+import {
+  logError
+} from "./chunk-OPA4TMAT.js";
+
+// src/retrieval/tokenize.ts
+var STOP = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "of",
+  "to",
+  "in",
+  "for",
+  "on",
+  "with",
+  "and",
+  "or",
+  "src",
+  "lib",
+  "app",
+  "test",
+  "tests",
+  "spec"
+]);
+function stemVariants(t) {
+  const out = /* @__PURE__ */ new Set([t]);
+  if (t.endsWith("ies") && t.length > 4) out.add(t.slice(0, -3) + "y");
+  else if (t.endsWith("es") && t.length > 4 && /(s|x|z|ch|sh)es$/.test(t)) out.add(t.slice(0, -2));
+  else if (t.endsWith("s") && t.length > 3 && !t.endsWith("ss")) out.add(t.slice(0, -1));
+  if (t.endsWith("ing") && t.length > 5) {
+    const base = t.slice(0, -3);
+    out.add(base);
+    out.add(base + "e");
+  }
+  if (t.endsWith("ation") && t.length > 7) {
+    const base = t.slice(0, -5);
+    out.add(base);
+  }
+  return [...out];
+}
+var EXPLICIT_STEM = /* @__PURE__ */ new Map([
+  ["configuration", "config"],
+  ["configurations", "config"],
+  ["configured", "config"],
+  ["ranking", "rank"],
+  ["ranked", "rank"],
+  ["weights", "weight"],
+  ["dependencies", "dependency"],
+  ["dependency", "depend"],
+  ["extraction", "extract"],
+  ["extracted", "extract"]
+]);
+function tokenizeIdentifier(raw) {
+  const parts = raw.replace(/[\\/]/g, " ").replace(/[.:\-_"']/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/g).filter((t) => t.length >= 2 && !STOP.has(t));
+  const out = /* @__PURE__ */ new Set();
+  for (const t of parts) {
+    out.add(t);
+    for (const v of stemVariants(t)) {
+      if (v.length >= 2 && !STOP.has(v)) out.add(v);
+    }
+    const e = EXPLICIT_STEM.get(t);
+    if (e && !STOP.has(e)) out.add(e);
+  }
+  return [...out];
+}
+function tokenizeTask(text) {
+  return tokenizeIdentifier(text);
+}
+
+// src/retrieval/history/index.ts
+function stripConventionalPrefix(subject) {
+  return subject.replace(/^[a-z]+(\([^)]*\))?(!)?:\s*/i, "").replace(/^\[\w+\]\s*/, "").trim();
+}
+function isPoorSubject(subject) {
+  const clean = stripConventionalPrefix(subject);
+  if (/^merge\s+(pr|pull request)\s*#?\d*/i.test(clean)) return true;
+  if (/^(update|updates|wip|tmp|test|fix|patch|changes?)$/i.test(clean)) return true;
+  return tokenizeIdentifier(clean).length < 2;
+}
+function commitTokens(subject, body, paths) {
+  const out = /* @__PURE__ */ new Set();
+  const cleanSubject = stripConventionalPrefix(subject);
+  for (const t of tokenizeIdentifier(cleanSubject)) out.add(t);
+  if (!isPoorSubject(subject)) {
+    for (const t of tokenizeIdentifier(body.slice(0, 2e3))) out.add(t);
+  }
+  for (const p of paths) {
+    for (const t of tokenizeIdentifier(p)) out.add(t);
+  }
+  return [...out];
+}
+function syncCommitFts(db, shas) {
+  let n = 0;
+  try {
+    const del = db.prepare(`DELETE FROM commit_fts WHERE sha = ?`);
+    const ins = db.prepare(`INSERT INTO commit_fts(sha, subject, body, paths) VALUES (?, ?, ?, ?)`);
+    const getCommit = db.prepare(`SELECT subject, body FROM commits WHERE sha = ?`);
+    const getPaths = db.prepare(`SELECT path FROM commit_files WHERE sha = ?`);
+    for (const sha of shas) {
+      const c = getCommit.get(sha);
+      if (!c) continue;
+      const paths = getPaths.all(sha).map((r) => r.path);
+      del.run(sha);
+      ins.run(sha, c.subject, c.body.slice(0, 4e3), paths.join(" "));
+      n++;
+    }
+  } catch (err) {
+    logError("history", err);
+  }
+  return n;
+}
+
+// src/retrieval/history/search.ts
+var HISTORY_HALF_LIFE_DAYS = 180;
+var HISTORY_MIN_SCORE = 0.05;
+var HISTORY_MAX_FILES = 40;
+var BM25_LIMIT = 20;
+function recencyScore(ts, nowSec, halfLifeDays) {
+  if (ts <= 0) return 0.5;
+  const ageDays = Math.max(0, (nowSec - ts) / 86400);
+  return Math.pow(0.5, ageDays / Math.max(1, halfLifeDays));
+}
+function sizePenalty(nFiles) {
+  return 1 / Math.log(2 + Math.max(0, nFiles));
+}
+function jaccard(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  let inter = 0;
+  for (const x of a) if (b.has(x)) inter++;
+  const union = a.size + b.size - inter;
+  return union === 0 ? 0 : inter / union;
+}
+function resolveCurrentPath(db, path) {
+  let cur = path;
+  try {
+    const stmt = db.prepare(`SELECT path FROM commit_files WHERE old_path = ? ORDER BY rowid DESC LIMIT 1`);
+    for (let i = 0; i < 5; i++) {
+      const row = stmt.get(cur);
+      if (!row || row.path === cur) break;
+      cur = row.path;
+    }
+  } catch {
+  }
+  return cur;
+}
+function candidates(db, tokens, asOfTs, excludeShas) {
+  const excluded = new Set(excludeShas ?? []);
+  if (tokens.length === 0) return [];
+  const q = tokens.map((t) => `"${t.replace(/"/g, "")}"`).join(" OR ");
+  try {
+    const rows = db.prepare(
+      `SELECT sha, bm25(commit_fts) AS rank FROM commit_fts
+         WHERE commit_fts MATCH ? ORDER BY rank LIMIT ${BM25_LIMIT}`
+    ).all(q);
+    if (rows.length === 0) return [];
+    const filt = rows.filter((r) => !excluded.has(r.sha));
+    if (filt.length === 0) return [];
+    const worst = Math.min(...filt.map((r) => r.rank));
+    const range = Math.max(1e-9, 0 - worst + 1);
+    void asOfTs;
+    return filt.map((r) => ({
+      sha: r.sha,
+      bm25norm: Math.max(0, Math.min(1, (0 - r.rank + 0.5) / range))
+    }));
+  } catch (err) {
+    logError("history", err);
+  }
+  try {
+    let rows = db.prepare(`SELECT sha, subject, ts FROM commits`).all();
+    if (asOfTs !== void 0) rows = rows.filter((r) => r.ts <= asOfTs);
+    rows = rows.filter((r) => !excluded.has(r.sha));
+    const tset = new Set(tokens);
+    const scored = rows.map((r) => {
+      let paths = [];
+      try {
+        paths = db.prepare(`SELECT path FROM commit_files WHERE sha = ?`).all(r.sha).map((x) => x.path);
+      } catch {
+      }
+      const doc = new Set(commitTokens(r.subject, "", paths));
+      let hit = 0;
+      for (const t of tset) if (doc.has(t)) hit++;
+      return { sha: r.sha, bm25norm: tset.size === 0 ? 0 : hit / tset.size };
+    }).filter((r) => r.bm25norm > 0);
+    scored.sort((a, b) => b.bm25norm - a.bm25norm || (a.sha < b.sha ? -1 : 1));
+    return scored.slice(0, BM25_LIMIT);
+  } catch (err) {
+    logError("history", err);
+    return [];
+  }
+}
+function historySearch(db, task, opts = {}) {
+  const seedFiles = new Set(opts.seedFiles ?? []);
+  const limit = Math.max(1, Math.min(10, opts.limit ?? 3));
+  const halfLife = opts.halfLifeDays ?? HISTORY_HALF_LIFE_DAYS;
+  const minScore = opts.minScore ?? HISTORY_MIN_SCORE;
+  const nowSec = opts.nowSec ?? Math.floor(Date.now() / 1e3);
+  const tokens = tokenizeTask(task);
+  if (tokens.length === 0) return [];
+  let cands;
+  try {
+    cands = candidates(db, tokens, opts.asOfTs, opts.excludeShas);
+  } catch (err) {
+    logError("history", err);
+    return [];
+  }
+  if (cands.length === 0) return [];
+  const out = [];
+  try {
+    const getCommit = db.prepare(`SELECT ts, subject FROM commits WHERE sha = ?`);
+    const getFiles = db.prepare(`SELECT path FROM commit_files WHERE sha = ?`);
+    const fileExists = db.prepare(`SELECT 1 AS ok FROM files WHERE path = ? LIMIT 1`);
+    for (const c of cands) {
+      const commit = getCommit.get(c.sha);
+      if (!commit) continue;
+      if (opts.asOfTs !== void 0 && commit.ts > opts.asOfTs) continue;
+      const rawFiles = getFiles.all(c.sha).map((r) => r.path);
+      if (rawFiles.length > HISTORY_MAX_FILES) continue;
+      const live = [];
+      for (const p of rawFiles) {
+        const cur = resolveCurrentPath(db, p);
+        try {
+          const hit = fileExists.get(cur);
+          if (hit) {
+            if (!live.includes(cur)) live.push(cur);
+          }
+        } catch {
+        }
+      }
+      if (live.length === 0) continue;
+      const rec = recencyScore(commit.ts, nowSec, halfLife);
+      const pen = sizePenalty(rawFiles.length);
+      const ov = jaccard(new Set(live), seedFiles);
+      const score = c.bm25norm * rec * pen * (1 + ov);
+      if (score < minScore) continue;
+      const d = new Date(commit.ts * 1e3);
+      out.push({
+        sha: c.sha,
+        shortSha: c.sha.slice(0, 7),
+        ts: commit.ts,
+        date: Number.isNaN(d.getTime()) ? "-" : d.toISOString().slice(0, 10),
+        subject: commit.subject,
+        files: [...live].sort(),
+        score,
+        sortTs: commit.ts
+      });
+    }
+  } catch (err) {
+    logError("history", err);
+    return [];
+  }
+  out.sort((a, b) => b.score - a.score || b.sortTs - a.sortTs || (a.sha < b.sha ? -1 : a.sha > b.sha ? 1 : 0));
+  return out.slice(0, limit).map(({ sortTs: _s, ...rest }) => rest);
+}
+function coChangeSet(analogs) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const a of analogs) {
+    for (const f of new Set(a.files)) counts.set(f, (counts.get(f) ?? 0) + 1);
+  }
+  return [...counts.entries()].filter(([, n]) => n >= 2).map(([path, count]) => ({ path, count })).sort((a, b) => b.count - a.count || (a.path < b.path ? -1 : 1));
+}
+function groupHistoryFiles(files) {
+  const source = [];
+  const test = [];
+  const config = [];
+  const docs = [];
+  for (const f of files) {
+    const base = f.split("/").pop() ?? f;
+    const lower = f.toLowerCase();
+    if (f.includes(".test.") || f.includes(".spec.") || f.includes("__tests__") || base.startsWith("test_") || base.endsWith("_test.py") || lower.startsWith("tests/")) {
+      test.push(f);
+    } else if (/\.(json|ya?ml|toml|ini|cfg)$/.test(lower) || ["package.json", "dockerfile", "makefile"].includes(base.toLowerCase())) {
+      config.push(f);
+    } else if (/\.mdx?$/.test(lower) || lower.startsWith("docs/")) {
+      docs.push(f);
+    } else {
+      source.push(f);
+    }
+  }
+  return { source, test, config, docs };
+}
+function leaveOneOut(db, shas, opts = {}) {
+  const out = [];
+  try {
+    const getCommit = db.prepare(`SELECT ts, subject FROM commits WHERE sha = ?`);
+    const getFiles = db.prepare(`SELECT path FROM commit_files WHERE sha = ?`);
+    for (const sha of shas) {
+      const commit = getCommit.get(sha);
+      if (!commit) continue;
+      const expected = getFiles.all(sha).map((r) => r.path);
+      const seeds = opts.seedFilesOf ? opts.seedFilesOf(sha) : [];
+      const analogs = historySearch(db, commit.subject, {
+        seedFiles: seeds,
+        limit: opts.limit ?? 3,
+        asOfTs: commit.ts - 1,
+        excludeShas: [sha],
+        nowSec: opts.nowSec
+      });
+      const recalledFiles = /* @__PURE__ */ new Set();
+      for (const a of analogs) for (const f of a.files) recalledFiles.add(f);
+      for (const c of coChangeSet(analogs)) recalledFiles.add(c.path);
+      const recalled = expected.filter((f) => recalledFiles.has(f));
+      out.push({ sha, subject: commit.subject, recalled, expected, recall: expected.length === 0 ? 1 : recalled.length / expected.length });
+    }
+  } catch (err) {
+    logError("history", err);
+  }
+  return out;
+}
+
+export {
+  tokenizeIdentifier,
+  tokenizeTask,
+  syncCommitFts,
+  HISTORY_HALF_LIFE_DAYS,
+  HISTORY_MIN_SCORE,
+  HISTORY_MAX_FILES,
+  recencyScore,
+  sizePenalty,
+  jaccard,
+  resolveCurrentPath,
+  historySearch,
+  coChangeSet,
+  groupHistoryFiles,
+  leaveOneOut
+};

package/dist/{chunk-4ZV67SRY.js → chunk-G5RA43OH.js}

@@ -17,7 +17,7 @@ function loadDatabaseSync() {
 }
 var DATA_DIR_NAME = ".scopecairn";
 var DB_FILE_NAME = "scopecairn.db";
-var SCHEMA_VERSION = 6;
+var SCHEMA_VERSION = 7;
 function dataDir(repoRoot) {
   return path.join(repoRoot, DATA_DIR_NAME);
 }
@@ -118,6 +118,29 @@ function openDb(repoRoot) {
       nodes_json TEXT NOT NULL DEFAULT '[]',
       created_at TEXT NOT NULL DEFAULT (datetime('now'))
     );
+    -- Analogi riwayat: commit git lokal untuk history search (hanya di DB
+    -- lokal .scopecairn/, tidak pernah masuk GRAPH.md/export).
+    CREATE TABLE IF NOT EXISTS commits (
+      sha TEXT PRIMARY KEY,
+      ts INTEGER NOT NULL DEFAULT 0,
+      subject TEXT NOT NULL DEFAULT '',
+      body TEXT NOT NULL DEFAULT '',
+      author TEXT NOT NULL DEFAULT ''
+    );
+    CREATE INDEX IF NOT EXISTS idx_commits_ts ON commits(ts);
+    CREATE TABLE IF NOT EXISTS commit_files (
+      sha TEXT NOT NULL REFERENCES commits(sha) ON DELETE CASCADE,
+      path TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'M',
+      old_path TEXT,
+      additions INTEGER NOT NULL DEFAULT 0,
+      deletions INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE INDEX IF NOT EXISTS idx_commit_files_sha ON commit_files(sha);
+    CREATE INDEX IF NOT EXISTS idx_commit_files_path ON commit_files(path);
+    CREATE VIRTUAL TABLE IF NOT EXISTS commit_fts USING fts5(
+      sha UNINDEXED, subject, body, paths
+    );
   `);
   db.prepare(
     `INSERT INTO meta(key, value) VALUES ('schema_version', ?)
@@ -273,7 +296,7 @@ function ensureProtectedFile(repoRoot) {
 }
 
 // src/scope/scope.ts
-function computeScope(highFiles, mediumFiles, testFiles, patterns) {
+function computeScope(highFiles, mediumFiles, testFiles, patterns, historyOptional) {
   const required = [];
   const optional = [];
   const protectedFiles = [];
@@ -293,6 +316,12 @@ function computeScope(highFiles, mediumFiles, testFiles, patterns) {
     if (isProtected(t, patterns)) protectedFiles.push(t);
     else optional.push(t);
   }
+  for (const h of historyOptional ?? []) {
+    if (seen.has(h)) continue;
+    seen.add(h);
+    if (isProtected(h, patterns)) protectedFiles.push(h);
+    else optional.push(h);
+  }
   return { required, optional, protected: protectedFiles };
 }
 function scopeBlock(scope) {

package/dist/chunk-OPA4TMAT.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+// src/log.ts
+import fs from "fs";
+import path from "path";
+function lastRunLogPath(repoRoot = process.cwd()) {
+  return path.join(repoRoot, ".scopecairn", "last-run.log");
+}
+function append(repoRoot, scope, text) {
+  const root = repoRoot ?? process.cwd();
+  try {
+    fs.mkdirSync(path.dirname(lastRunLogPath(root)), { recursive: true });
+    fs.appendFileSync(lastRunLogPath(root), text + "\n", "utf8");
+  } catch {
+  }
+}
+function logError(scope, err, repoRoot) {
+  const message = err instanceof Error ? err.message : String(err);
+  append(repoRoot, scope, `${(/* @__PURE__ */ new Date()).toISOString()} [${scope}] ${message}`);
+}
+
+export {
+  logError
+};

package/dist/chunk-PR3BGBXP.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+import {
+  logError
+} from "./chunk-OPA4TMAT.js";
+
+// src/retrieval/history/extractor.ts
+import { execFileSync } from "child_process";
+var HISTORY_MAX_COMMITS = 2e3;
+var HISTORY_MAX_FILES_PER_COMMIT = 40;
+function shouldSkipCommit(fileCount) {
+  return fileCount > HISTORY_MAX_FILES_PER_COMMIT;
+}
+var HISTORY_SKIP_BASENAMES = /* @__PURE__ */ new Set([
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "bun.lockb",
+  "cargo.lock",
+  "go.sum",
+  "gemfile.lock",
+  "poetry.lock"
+]);
+var HISTORY_SKIP_SUFFIXES = [".min.js", ".map", ".lock"];
+var HISTORY_SKIP_DIRS = ["dist/", "build/", "coverage/", "node_modules/", ".next/"];
+function isHistorySkipped(posixPath) {
+  const base = posixPath.split("/").pop() ?? posixPath;
+  if (HISTORY_SKIP_BASENAMES.has(base)) return true;
+  for (const s of HISTORY_SKIP_SUFFIXES) if (base.endsWith(s)) return true;
+  for (const d of HISTORY_SKIP_DIRS) if (posixPath.startsWith(d)) return true;
+  return false;
+}
+function runGit(repoRoot, args, timeout = 3e4) {
+  try {
+    return execFileSync("git", args, {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout,
+      maxBuffer: 64 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch (err) {
+    logError("history", err, repoRoot);
+    return null;
+  }
+}
+function isShallowRepo(repoRoot) {
+  try {
+    const out = execFileSync("git", ["rev-parse", "--is-shallow-repository"], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      timeout: 8e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return out === "true";
+  } catch {
+    return false;
+  }
+}
+var FS = String.fromCharCode(1);
+var RS = String.fromCharCode(30);
+var SB = String.fromCharCode(31);
+function parseGitLog(out) {
+  const commits = [];
+  let cur = null;
+  let numstat = /* @__PURE__ */ new Map();
+  let statuses = [];
+  const flush = () => {
+    if (!cur) return;
+    for (const s of statuses) {
+      const n = numstat.get(s.p) ?? { a: 0, d: 0 };
+      cur.files.push({ status: s.st, path: s.p, oldPath: s.old, additions: n.a, deletions: n.d });
+    }
+    commits.push(cur);
+  };
+  for (const rawLine of out.replace(new RegExp(RS, "g"), "").split("\n")) {
+    const line = rawLine.trimEnd();
+    if (!line.trim()) continue;
+    if (line.includes(FS)) {
+      flush();
+      const [sha, tsRaw, author, subjectBody = ""] = line.split(FS);
+      if (!sha || !/^[0-9a-f]{4,}$/.test(sha.trim())) {
+        cur = null;
+        numstat = /* @__PURE__ */ new Map();
+        statuses = [];
+        continue;
+      }
+      const sep = subjectBody.indexOf(SB);
+      cur = {
+        sha: sha.trim(),
+        ts: Number((tsRaw ?? "").trim()) || 0,
+        author: (author ?? "").trim(),
+        subject: (sep === -1 ? subjectBody : subjectBody.slice(0, sep)).trim(),
+        body: (sep === -1 ? "" : subjectBody.slice(sep + 1)).trim(),
+        files: []
+      };
+      numstat = /* @__PURE__ */ new Map();
+      statuses = [];
+      continue;
+    }
+    if (!cur) continue;
+    const t = line.trim();
+    const num = t.match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
+    if (num) {
+      numstat.set(num[3].trim(), {
+        a: num[1] === "-" ? 0 : Number(num[1]),
+        d: num[2] === "-" ? 0 : Number(num[2])
+      });
+      continue;
+    }
+    const m = t.match(/^([AMDRCTUXB])(\d*)\t(.+)$/);
+    if (!m) continue;
+    const parts = m[3].split("	");
+    if (m[1] === "R" && parts.length >= 2) {
+      statuses.push({ st: "R", p: parts[1].trim(), old: parts[0].trim() });
+    } else {
+      statuses.push({ st: m[1], p: parts[0].trim(), old: null });
+    }
+  }
+  flush();
+  return commits;
+}
+function ensureHistoryIndex(db, repoRoot, opts) {
+  const maxCommits = Math.max(1, Math.min(5e3, opts?.maxCommits ?? HISTORY_MAX_COMMITS));
+  const fail = (shallow2 = false) => ({ available: false, indexed: 0, skipped: 0, shallow: shallow2, shas: [] });
+  let before = 0;
+  try {
+    before = db.prepare(`SELECT COUNT(*) AS n FROM commits`).get().n;
+  } catch (err) {
+    logError("history", err, repoRoot);
+    return fail();
+  }
+  const lastRow = (() => {
+    try {
+      return db.prepare(`SELECT value FROM meta WHERE key = 'history_last_sha'`).get();
+    } catch {
+      return void 0;
+    }
+  })();
+  const lastSha = lastRow?.value;
+  const headList = runGit(repoRoot, ["log", "--no-merges", `--max-count=${maxCommits * 2}`, "--format=%H"]);
+  if (!headList) return fail(isShallowRepo(repoRoot));
+  const headShas = headList.split("\n").map((s) => s.trim()).filter(Boolean);
+  if (headShas.length === 0) return { available: true, indexed: 0, skipped: 0, shallow: isShallowRepo(repoRoot), shas: [] };
+  const shallow = isShallowRepo(repoRoot);
+  let range;
+  if (lastSha && headShas.includes(lastSha)) {
+    range = headShas.slice(0, Math.max(0, headShas.indexOf(lastSha)));
+  } else {
+    range = headShas.slice(0, maxCommits);
+  }
+  if (range.length === 0) {
+    return { available: true, indexed: 0, skipped: 0, shallow, shas: [] };
+  }
+  const oldest = range[range.length - 1];
+  const newest = range[0];
+  const detailRange = lastSha && headShas.includes(lastSha) ? `${oldest}..${newest}` : `--max-count=${Math.min(maxCommits, range.length)}`;
+  const format = `%H${FS}%ct${FS}%an${FS}%s${SB}%b${RS}`;
+  const detailArgs = detailRange.startsWith("--max-count") ? ["log", "--no-merges", detailRange, `--format=${format}`, "--name-status", "-M", "--numstat", "--", "."] : ["log", "--no-merges", `--format=${format}`, "--name-status", "-M", "--numstat", detailRange, "--", "."];
+  const detail = runGit(repoRoot, detailArgs);
+  if (!detail) return fail(shallow);
+  let parsed;
+  try {
+    parsed = parseGitLog(detail);
+  } catch (err) {
+    logError("history", err, repoRoot);
+    return fail(shallow);
+  }
+  let indexed = 0;
+  let skipped = 0;
+  const shas = [];
+  try {
+    const insCommit = db.prepare(
+      `INSERT OR IGNORE INTO commits(sha, ts, subject, body, author) VALUES (?, ?, ?, ?, ?)`
+    );
+    const insFile = db.prepare(
+      `INSERT INTO commit_files(sha, path, status, old_path, additions, deletions) VALUES (?, ?, ?, ?, ?, ?)`
+    );
+    const delFiles = db.prepare(`DELETE FROM commit_files WHERE sha = ?`);
+    for (const c of parsed.slice(0, maxCommits)) {
+      const kept = c.files.filter((f) => !isHistorySkipped(f.path));
+      if (shouldSkipCommit(c.files.length)) {
+        skipped++;
+        continue;
+      }
+      const r = insCommit.run(c.sha, c.ts, c.subject, c.body, c.author);
+      if (Number(r.changes) === 0) continue;
+      delFiles.run(c.sha);
+      for (const f of kept) {
+        insFile.run(c.sha, f.path, f.status, f.oldPath, f.additions, f.deletions);
+      }
+      indexed++;
+      shas.push(c.sha);
+    }
+  } catch (err) {
+    logError("history", err, repoRoot);
+  }
+  try {
+    db.prepare(
+      `INSERT INTO meta(key, value) VALUES ('history_last_sha', ?)
+       ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+    ).run(headShas[0]);
+  } catch (err) {
+    logError("history", err, repoRoot);
+  }
+  void before;
+  return { available: true, indexed, skipped, shallow, shas };
+}
+
+export {
+  HISTORY_MAX_COMMITS,
+  HISTORY_MAX_FILES_PER_COMMIT,
+  shouldSkipCommit,
+  isHistorySkipped,
+  isShallowRepo,
+  parseGitLog,
+  ensureHistoryIndex
+};