@pratik7368patil/anchor-core 0.1.5 → 0.1.7

package/dist/index.js

@@ -334,6 +334,48 @@ CREATE VIRTUAL TABLE IF NOT EXISTS wisdom_units_fts USING fts5(
   category
 );
 
+CREATE TABLE IF NOT EXISTS code_files (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  repo_id INTEGER NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,
+  path TEXT NOT NULL,
+  language TEXT,
+  size_bytes INTEGER NOT NULL,
+  content_hash TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE(repo_id, path)
+);
+
+CREATE TABLE IF NOT EXISTS code_chunks (
+  id TEXT PRIMARY KEY,
+  repo_id INTEGER NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,
+  file_id INTEGER NOT NULL REFERENCES code_files(id) ON DELETE CASCADE,
+  repo TEXT NOT NULL,
+  file_path TEXT NOT NULL,
+  language TEXT,
+  start_line INTEGER NOT NULL,
+  end_line INTEGER NOT NULL,
+  sanitized_text TEXT NOT NULL,
+  symbols_json TEXT NOT NULL,
+  content_hash TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS code_chunks_fts USING fts5(
+  chunkId UNINDEXED,
+  sanitizedText,
+  filePath,
+  symbols,
+  language
+);
+
+CREATE TABLE IF NOT EXISTS code_index_state (
+  repo TEXT PRIMARY KEY,
+  last_indexed_at TEXT NOT NULL,
+  indexed_files INTEGER NOT NULL,
+  code_chunks INTEGER NOT NULL,
+  skipped_files INTEGER NOT NULL
+);
+
 CREATE TABLE IF NOT EXISTS sync_state (
   repo TEXT PRIMARY KEY,
   last_sync_at TEXT,
@@ -346,6 +388,8 @@ CREATE INDEX IF NOT EXISTS idx_pr_files_path ON pr_files(path);
 CREATE INDEX IF NOT EXISTS idx_pr_comments_source ON pr_comments(source_type);
 CREATE INDEX IF NOT EXISTS idx_wisdom_units_category ON wisdom_units(category);
 CREATE INDEX IF NOT EXISTS idx_wisdom_units_pr ON wisdom_units(pr_id);
+CREATE INDEX IF NOT EXISTS idx_code_files_path ON code_files(path);
+CREATE INDEX IF NOT EXISTS idx_code_chunks_file_path ON code_chunks(file_path);
 `;
 
 // src/db/database.ts
@@ -365,8 +409,10 @@ function initializeSchema(db) {
 function checkSchema(db) {
   try {
     const tables = db.prepare("SELECT name FROM sqlite_master WHERE type IN ('table', 'virtual') AND name = ?").all("wisdom_units_fts");
+    const codeTables = db.prepare("SELECT name FROM sqlite_master WHERE type IN ('table', 'virtual') AND name = ?").all("code_chunks_fts");
     const wisdom = db.prepare("SELECT name FROM sqlite_master WHERE name = ?").all("wisdom_units");
-    return tables.length > 0 && wisdom.length > 0;
+    const code = db.prepare("SELECT name FROM sqlite_master WHERE name = ?").all("code_chunks");
+    return tables.length > 0 && wisdom.length > 0 && codeTables.length > 0 && code.length > 0;
   } catch {
     return false;
   }
@@ -543,6 +589,87 @@ function upsertPullRequest(db, pr, wisdomUnits) {
   const comments = (pr.reviews?.length ?? 0) + (pr.reviewComments?.length ?? 0) + (pr.issueComments?.length ?? 0);
   return { files: pr.files.length, comments, wisdom: wisdomUnits.length };
 }
+function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd) {
+  initializeSchema(db);
+  const repoId = ensureRepository(db, repo);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const transaction = db.transaction(() => {
+    const existingChunks = db.prepare("SELECT id FROM code_chunks WHERE repo_id = ?").all(repoId);
+    const deleteFts = db.prepare("DELETE FROM code_chunks_fts WHERE chunkId = ?");
+    for (const row of existingChunks) deleteFts.run(row.id);
+    db.prepare("DELETE FROM code_chunks WHERE repo_id = ?").run(repoId);
+    db.prepare("DELETE FROM code_files WHERE repo_id = ?").run(repoId);
+    const insertFile = db.prepare(
+      `INSERT INTO code_files
+       (repo_id, path, language, size_bytes, content_hash, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    );
+    for (const file of codeFiles) {
+      insertFile.run(
+        repoId,
+        file.path,
+        file.language ?? null,
+        file.sizeBytes,
+        file.contentHash,
+        file.updatedAt
+      );
+    }
+    const fileRows = db.prepare("SELECT id, path FROM code_files WHERE repo_id = ?").all(repoId);
+    const fileIds = new Map(fileRows.map((row) => [row.path, row.id]));
+    const insertChunk = db.prepare(
+      `INSERT INTO code_chunks
+       (id, repo_id, file_id, repo, file_path, language, start_line, end_line, sanitized_text,
+        symbols_json, content_hash, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    const insertFts = db.prepare(
+      `INSERT INTO code_chunks_fts
+       (chunkId, sanitizedText, filePath, symbols, language)
+       VALUES (?, ?, ?, ?, ?)`
+    );
+    for (const chunk of codeChunks) {
+      const fileId = fileIds.get(chunk.filePath);
+      if (!fileId) continue;
+      insertChunk.run(
+        chunk.id,
+        repoId,
+        fileId,
+        chunk.repo,
+        chunk.filePath,
+        chunk.language ?? null,
+        chunk.startLine,
+        chunk.endLine,
+        chunk.sanitizedText,
+        JSON.stringify(chunk.symbols),
+        chunk.contentHash,
+        chunk.updatedAt
+      );
+      insertFts.run(
+        chunk.id,
+        chunk.sanitizedText,
+        chunk.filePath,
+        chunk.symbols.join(" "),
+        chunk.language ?? ""
+      );
+    }
+    db.prepare(
+      `INSERT INTO code_index_state (repo, last_indexed_at, indexed_files, code_chunks, skipped_files)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(repo) DO UPDATE SET
+         last_indexed_at = excluded.last_indexed_at,
+         indexed_files = excluded.indexed_files,
+         code_chunks = excluded.code_chunks,
+         skipped_files = excluded.skipped_files`
+    ).run(repo, now, codeFiles.length, codeChunks.length, skippedFiles);
+  });
+  transaction();
+  return {
+    indexedFiles: codeFiles.length,
+    codeChunksCreated: codeChunks.length,
+    skippedFiles,
+    databasePath: defaultDatabasePath(cwd)
+  };
+}
 function getIndexStatus(cwd, githubTokenConfigured = Boolean(resolveGitHubToken({ cwd }).token), databasePath = defaultDatabasePath(cwd)) {
   if (!fs2.existsSync(databasePath)) {
     return {
@@ -551,12 +678,15 @@ function getIndexStatus(cwd, githubTokenConfigured = Boolean(resolveGitHubToken(
       fileCount: 0,
       commentCount: 0,
       wisdomUnitCount: 0,
+      codeFileCount: 0,
+      codeChunkCount: 0,
       githubTokenConfigured,
       health: "missing_database"
     };
   }
   const db = openAnchorDatabase(cwd, databasePath);
   try {
+    initializeSchema(db);
     if (!checkSchema(db)) {
       return {
         databasePath,
@@ -564,6 +694,8 @@ function getIndexStatus(cwd, githubTokenConfigured = Boolean(resolveGitHubToken(
         fileCount: 0,
         commentCount: 0,
         wisdomUnitCount: 0,
+        codeFileCount: 0,
+        codeChunkCount: 0,
         githubTokenConfigured,
         health: "schema_invalid"
       };
@@ -571,7 +703,9 @@ function getIndexStatus(cwd, githubTokenConfigured = Boolean(resolveGitHubToken(
     const count = (table) => db.prepare(`SELECT COUNT(*) AS count FROM ${table}`).get().count;
     const repoRow = db.prepare("SELECT full_name FROM repositories ORDER BY id LIMIT 1").get();
     const syncRow = db.prepare("SELECT last_sync_at FROM sync_state ORDER BY updated_at DESC LIMIT 1").get();
+    const codeIndexRow = db.prepare("SELECT last_indexed_at FROM code_index_state ORDER BY last_indexed_at DESC LIMIT 1").get();
     const wisdomUnitCount = count("wisdom_units");
+    const codeChunkCount = count("code_chunks");
     return {
       repo: repoRow?.full_name,
       databasePath,
@@ -579,9 +713,12 @@ function getIndexStatus(cwd, githubTokenConfigured = Boolean(resolveGitHubToken(
       fileCount: count("pr_files"),
       commentCount: count("pr_comments"),
       wisdomUnitCount,
+      codeFileCount: count("code_files"),
+      codeChunkCount,
       lastSyncTime: syncRow?.last_sync_at ?? void 0,
+      lastCodeIndexTime: codeIndexRow?.last_indexed_at ?? void 0,
       githubTokenConfigured,
-      health: wisdomUnitCount > 0 ? "ok" : "empty_index"
+      health: wisdomUnitCount > 0 || codeChunkCount > 0 ? "ok" : "empty_index"
     };
   } finally {
     db.close();
@@ -618,9 +755,260 @@ function chunkHistoricalText(text, maxChunkLength = 700) {
   return expanded.filter((chunk) => chunk.length >= 12 && hasHighSignalLanguage(chunk));
 }
 
-// src/indexer/wisdom-extractor.ts
+// src/indexer/code-chunker.ts
 import crypto from "crypto";
 import path3 from "path";
+var DEFAULT_CHUNK_LINES = 80;
+var DEFAULT_OVERLAP_LINES = 8;
+var FUNCTION_CALL_STOP_WORDS = /* @__PURE__ */ new Set([
+  "catch",
+  "describe",
+  "for",
+  "if",
+  "it",
+  "return",
+  "switch",
+  "test",
+  "while"
+]);
+function stableCodeChunkId(file, startLine, endLine) {
+  const hash = crypto.createHash("sha256").update([file.repo, file.path, file.contentHash, startLine, endLine].join("\0")).digest("hex").slice(0, 24);
+  return `cc_${hash}`;
+}
+function extractCodeSymbols(text, filePath) {
+  const symbols = [];
+  const declarations = text.matchAll(
+    /\b(?:export\s+)?(?:async\s+)?(?:class|function|interface|type|enum|const|let|var)\s+([A-Za-z_$][\w$]*)/g
+  );
+  for (const match of declarations) symbols.push(match[1] ?? "");
+  const objectMethods = text.matchAll(
+    /\b([A-Za-z_$][\w$]{2,})\s*[:=]\s*(?:async\s*)?\([^)]*\)\s*=>/g
+  );
+  for (const match of objectMethods) symbols.push(match[1] ?? "");
+  const calls = text.matchAll(/\b([A-Za-z_$][\w$]{2,})\s*\(/g);
+  for (const match of calls) {
+    const candidate = match[1] ?? "";
+    if (!FUNCTION_CALL_STOP_WORDS.has(candidate)) symbols.push(candidate);
+  }
+  const basename = path3.basename(filePath).replace(/\.[^.]+$/, "");
+  if (/^[A-Za-z_$][\w$-]*$/.test(basename)) symbols.push(basename);
+  return uniqueStrings(symbols).slice(0, 40);
+}
+function chunkCodeFile(file, options = {}) {
+  const chunkLines = options.chunkLines ?? DEFAULT_CHUNK_LINES;
+  const overlapLines = Math.max(
+    0,
+    Math.min(options.overlapLines ?? DEFAULT_OVERLAP_LINES, chunkLines - 1)
+  );
+  const lines = file.content.replace(/\r\n/g, "\n").split("\n");
+  const chunks = [];
+  for (let startIndex = 0; startIndex < lines.length; ) {
+    const endIndex = Math.min(lines.length, startIndex + chunkLines);
+    const rawText = lines.slice(startIndex, endIndex).join("\n");
+    const sanitizedText = sanitizeHistoricalText(rawText);
+    if (sanitizedText) {
+      chunks.push({
+        id: stableCodeChunkId(file, startIndex + 1, endIndex),
+        repo: file.repo,
+        filePath: file.path,
+        language: file.language,
+        startLine: startIndex + 1,
+        endLine: endIndex,
+        sanitizedText,
+        symbols: extractCodeSymbols(sanitizedText, file.path),
+        contentHash: file.contentHash,
+        updatedAt: file.updatedAt
+      });
+    }
+    if (endIndex >= lines.length) break;
+    startIndex = Math.max(startIndex + 1, endIndex - overlapLines);
+  }
+  return chunks;
+}
+
+// src/indexer/code-file-discovery.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import crypto2 from "crypto";
+import fs3 from "fs";
+import path4 from "path";
+var DEFAULT_MAX_CODE_FILE_BYTES = 512 * 1024;
+var HARD_EXCLUDED_SEGMENTS = /* @__PURE__ */ new Set([
+  ".git",
+  ".anchor",
+  ".cursor",
+  ".codex",
+  ".aws",
+  ".ssh",
+  "node_modules",
+  ".nuxt",
+  ".next",
+  "dist",
+  "build",
+  "coverage",
+  ".turbo"
+]);
+var LANGUAGE_BY_EXTENSION = {
+  ".cjs": "javascript",
+  ".css": "css",
+  ".go": "go",
+  ".html": "html",
+  ".java": "java",
+  ".js": "javascript",
+  ".json": "json",
+  ".jsx": "javascript",
+  ".md": "markdown",
+  ".mjs": "javascript",
+  ".py": "python",
+  ".rb": "ruby",
+  ".rs": "rust",
+  ".scss": "scss",
+  ".sh": "shell",
+  ".sql": "sql",
+  ".svelte": "svelte",
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".vue": "vue",
+  ".yaml": "yaml",
+  ".yml": "yaml"
+};
+function normalizeGitPath(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\/+/, "");
+}
+function isHardExcludedCodePath(filePath) {
+  const normalized = normalizeGitPath(filePath);
+  const segments = normalized.split("/");
+  if (segments.some((segment) => HARD_EXCLUDED_SEGMENTS.has(segment))) return true;
+  const basename = path4.posix.basename(normalized).toLowerCase();
+  if ([".netrc", ".npmrc", ".pypirc", ".yarnrc"].includes(basename)) return true;
+  if (basename === ".env" || basename.startsWith(".env.")) return true;
+  if (basename === "id_rsa" || basename === "id_rsa.pub" || basename === "id_dsa" || basename === "id_ecdsa" || basename === "id_ed25519") {
+    return true;
+  }
+  if (/\.(pem|key|p12|pfx)$/i.test(basename)) return true;
+  return false;
+}
+function languageForPath(filePath) {
+  const extension = path4.extname(filePath).toLowerCase();
+  return LANGUAGE_BY_EXTENSION[extension];
+}
+function isProbablyBinary(buffer) {
+  if (buffer.includes(0)) return true;
+  if (buffer.length === 0) return false;
+  let suspicious = 0;
+  for (const byte of buffer) {
+    const isAllowedControl = byte === 9 || byte === 10 || byte === 13;
+    if (byte < 32 && !isAllowedControl) suspicious += 1;
+  }
+  return suspicious / buffer.length > 0.01;
+}
+function discoverGitFiles(cwd) {
+  const output = execFileSync3("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return output.split("\n").map((line) => normalizeGitPath(line.trim())).filter(Boolean);
+}
+function discoverCodeFiles(cwd, repo, options = {}) {
+  const maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_CODE_FILE_BYTES;
+  const rootPath = path4.resolve(cwd);
+  const files = [];
+  let skippedFiles = 0;
+  for (const filePath of discoverGitFiles(cwd)) {
+    if (isHardExcludedCodePath(filePath)) {
+      skippedFiles += 1;
+      continue;
+    }
+    const absolutePath = path4.resolve(cwd, filePath);
+    const relativeToRoot = path4.relative(rootPath, absolutePath);
+    if (relativeToRoot.startsWith("..") || path4.isAbsolute(relativeToRoot)) {
+      skippedFiles += 1;
+      continue;
+    }
+    let stat;
+    try {
+      stat = fs3.statSync(absolutePath);
+    } catch {
+      skippedFiles += 1;
+      continue;
+    }
+    if (!stat.isFile() || stat.size > maxFileBytes) {
+      skippedFiles += 1;
+      continue;
+    }
+    const buffer = fs3.readFileSync(absolutePath);
+    if (isProbablyBinary(buffer)) {
+      skippedFiles += 1;
+      continue;
+    }
+    const content = buffer.toString("utf8");
+    files.push({
+      repo,
+      path: filePath,
+      language: languageForPath(filePath),
+      sizeBytes: stat.size,
+      contentHash: crypto2.createHash("sha256").update(buffer).digest("hex"),
+      updatedAt: stat.mtime.toISOString(),
+      absolutePath,
+      content
+    });
+  }
+  return { files, skippedFiles };
+}
+
+// src/indexer/code-indexer.ts
+function indexCodebase(db, options) {
+  options.onProgress?.({ stage: "discovering_code_files", repo: options.repo });
+  const discovery = discoverCodeFiles(options.cwd, options.repo, {
+    maxFileBytes: options.maxFileBytes
+  });
+  options.onProgress?.({
+    stage: "discovered_code_files",
+    repo: options.repo,
+    files: discovery.files.length,
+    skippedFiles: discovery.skippedFiles
+  });
+  const chunks = [];
+  for (const [index, file] of discovery.files.entries()) {
+    options.onProgress?.({
+      stage: "indexing_code_file",
+      repo: options.repo,
+      current: index + 1,
+      total: discovery.files.length,
+      filePath: file.path
+    });
+    const fileChunks = chunkCodeFile(file);
+    chunks.push(...fileChunks);
+    options.onProgress?.({
+      stage: "indexed_code_file",
+      repo: options.repo,
+      current: index + 1,
+      total: discovery.files.length,
+      filePath: file.path,
+      chunks: fileChunks.length
+    });
+  }
+  return replaceCodeIndex(
+    db,
+    options.repo,
+    discovery.files.map(({ content: _content, absolutePath: _absolutePath, ...file }) => file),
+    chunks,
+    discovery.skippedFiles,
+    options.cwd
+  );
+}
+function emptyCodeIndexSummary(cwd) {
+  return {
+    indexedFiles: 0,
+    codeChunksCreated: 0,
+    skippedFiles: 0,
+    databasePath: defaultDatabasePath(cwd)
+  };
+}
+
+// src/indexer/wisdom-extractor.ts
+import crypto3 from "crypto";
+import path5 from "path";
 var CATEGORY_KEYWORDS = [
   ["security_note", /\b(security|secret|token|bearer|oauth|credential|xss|csrf|injection|sanitize|redact)\b/i],
   ["architecture_decision", /\b(architecture decision|architectural|we intentionally|design decision)\b/i],
@@ -652,7 +1040,7 @@ function extractSymbols(text, filePaths) {
     }
   }
   for (const filePath of filePaths) {
-    const basename = path3.basename(filePath).replace(/\.[^.]+$/, "");
+    const basename = path5.basename(filePath).replace(/\.[^.]+$/, "");
     if (/^[A-Za-z_$][\w$]*$/.test(basename)) symbols.push(basename);
   }
   return uniqueStrings(symbols).slice(0, 30);
@@ -676,7 +1064,7 @@ function confidenceFor(entry, text, category, duplicateCount) {
   return Math.max(0, Math.min(1, Number(confidence.toFixed(2))));
 }
 function stableWisdomId(pr, sourceType, text, filePaths, createdAt, authors) {
-  const hash = crypto.createHash("sha256").update(
+  const hash = crypto3.createHash("sha256").update(
     [pr.repo, pr.number, sourceType, canonicalizeText(text), filePaths.join("|"), createdAt, authors.join("|")].join(
       "\0"
     )
@@ -872,7 +1260,7 @@ function shouldSyncSince(db, repo, fallbackSince) {
 }
 
 // src/retrieval/query-builder.ts
-import path4 from "path";
+import path6 from "path";
 var CATEGORY_HINTS = [
   "security",
   "regression",
@@ -897,8 +1285,8 @@ function buildFtsQuery(input) {
   const baseText = "task" in input ? input.task : input.query;
   const fileTerms = files.flatMap((file) => [
     file,
-    path4.basename(file),
-    ...path4.dirname(file).split(/[\\/]/).filter(Boolean)
+    path6.basename(file),
+    ...path6.dirname(file).split(/[\\/]/).filter(Boolean)
   ]);
   const tokens = uniqueStrings([
     ...tokenizeSearchText(baseText, 24),
@@ -917,7 +1305,7 @@ function clampMaxResults(value, defaultValue) {
 }
 
 // src/retrieval/ranker.ts
-import path5 from "path";
+import path7 from "path";
 function parseJsonArray(value) {
   try {
     const parsed = JSON.parse(value);
@@ -964,11 +1352,11 @@ function filePathMatch(unitPaths, queryFiles) {
   if (queryFiles.length === 0 || unitPaths.length === 0) return 0;
   let best = 0;
   for (const queryFile of queryFiles) {
-    const queryBase = path5.basename(queryFile).toLowerCase();
-    const queryDir = path5.dirname(queryFile).toLowerCase();
+    const queryBase = path7.basename(queryFile).toLowerCase();
+    const queryDir = path7.dirname(queryFile).toLowerCase();
     for (const unitPath of unitPaths) {
-      const unitBase = path5.basename(unitPath).toLowerCase();
-      const unitDir = path5.dirname(unitPath).toLowerCase();
+      const unitBase = path7.basename(unitPath).toLowerCase();
+      const unitDir = path7.dirname(unitPath).toLowerCase();
       const q = queryFile.toLowerCase();
       const u = unitPath.toLowerCase();
       if (q === u) best = Math.max(best, 1);
@@ -1099,6 +1487,159 @@ function rankWisdomUnits(db, input) {
   return [...grouped.values()].sort((a, b) => b.score - a.score || b.confidence - a.confidence).slice(0, limit);
 }
 
+// src/retrieval/code-ranker.ts
+import path8 from "path";
+function parseJsonArray2(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function rowToCodeChunk(row) {
+  return {
+    id: row.id,
+    repo: row.repo,
+    filePath: row.file_path,
+    language: row.language ?? void 0,
+    startLine: row.start_line,
+    endLine: row.end_line,
+    sanitizedText: row.sanitized_text,
+    symbols: parseJsonArray2(row.symbols_json),
+    contentHash: row.content_hash,
+    updatedAt: row.updated_at,
+    bm25: row.bm25 ?? void 0
+  };
+}
+function filePathMatch2(filePath, queryFiles) {
+  if (queryFiles.length === 0) return 0;
+  let best = 0;
+  const unitBase = path8.basename(filePath).toLowerCase();
+  const unitDir = path8.dirname(filePath).toLowerCase();
+  const unit = filePath.toLowerCase();
+  for (const queryFile of queryFiles) {
+    const query = queryFile.toLowerCase();
+    const queryBase = path8.basename(queryFile).toLowerCase();
+    const queryDir = path8.dirname(queryFile).toLowerCase();
+    if (query === unit) best = Math.max(best, 1);
+    else if (queryBase === unitBase) best = Math.max(best, 0.72);
+    else if (queryDir === unitDir) best = Math.max(best, 0.62);
+    else if (unitDir.startsWith(queryDir) || queryDir.startsWith(unitDir))
+      best = Math.max(best, 0.38);
+    else if (queryBase && unitBase && queryBase.split(".")[0] === unitBase.split(".")[0]) {
+      best = Math.max(best, 0.48);
+    }
+  }
+  return best;
+}
+function symbolMatch2(chunk, querySymbols) {
+  if (querySymbols.length === 0) return 0;
+  const chunkSymbols = chunk.symbols.map((symbol) => symbol.toLowerCase());
+  const text = chunk.sanitizedText.toLowerCase();
+  let best = 0;
+  for (const symbol of querySymbols) {
+    const lower = symbol.toLowerCase();
+    if (chunkSymbols.includes(lower)) best = Math.max(best, 1);
+    else if (new RegExp(`\\b${escapeRegExp2(lower)}\\b`, "i").test(text)) best = Math.max(best, 0.7);
+    else if (chunkSymbols.some((candidate) => candidate.includes(lower) || lower.includes(candidate))) {
+      best = Math.max(best, 0.42);
+    }
+  }
+  return best;
+}
+function textMatch2(chunk, input) {
+  const tokens = tokenizeSearchText(
+    `${input.task} ${input.diff ?? ""} ${input.currentCode ?? ""}`,
+    40
+  );
+  const haystack = `${chunk.sanitizedText} ${chunk.filePath} ${chunk.symbols.join(" ")}`.toLowerCase();
+  const overlap = tokens.length ? tokens.filter((token) => haystack.includes(token.toLowerCase())).length / tokens.length : 0;
+  const bm25Signal = chunk.bm25 === void 0 ? 0 : Math.max(0.25, Math.min(1, 1 / (1 + Math.abs(chunk.bm25))));
+  return Math.max(overlap, bm25Signal);
+}
+function recencyScore2(chunk) {
+  const timestamp = Date.parse(chunk.updatedAt);
+  if (Number.isNaN(timestamp)) return 0.25;
+  const ageDays = Math.max(0, (Date.now() - timestamp) / (1e3 * 60 * 60 * 24));
+  if (ageDays < 30) return 1;
+  if (ageDays < 180) return 0.75;
+  if (ageDays < 730) return 0.45;
+  return 0.25;
+}
+function escapeRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function escapeLike(value) {
+  return value.replace(/[\\%_]/g, (match) => `\\${match}`);
+}
+function loadCodeCandidates(db, input) {
+  const candidates = /* @__PURE__ */ new Map();
+  const ftsQuery = buildFtsQuery(input);
+  if (ftsQuery) {
+    const rows = db.prepare(
+      `SELECT cc.*, bm25(code_chunks_fts) AS bm25
+         FROM code_chunks_fts
+         JOIN code_chunks cc ON cc.id = code_chunks_fts.chunkId
+         WHERE code_chunks_fts MATCH ?
+         ORDER BY bm25(code_chunks_fts)
+         LIMIT 150`
+    ).all(ftsQuery);
+    for (const row of rows) {
+      const chunk = rowToCodeChunk(row);
+      candidates.set(chunk.id, chunk);
+    }
+  }
+  for (const file of input.files ?? []) {
+    const basename = path8.basename(file);
+    const rows = db.prepare(
+      `SELECT cc.*, NULL AS bm25
+         FROM code_chunks cc
+         WHERE cc.file_path = ?
+            OR cc.file_path LIKE ? ESCAPE '\\'
+         LIMIT 80`
+    ).all(file, `%/${escapeLike(basename)}`);
+    for (const row of rows) {
+      const chunk = rowToCodeChunk(row);
+      candidates.set(chunk.id, { ...chunk, bm25: candidates.get(chunk.id)?.bm25 ?? chunk.bm25 });
+    }
+  }
+  if (candidates.size === 0) {
+    const rows = db.prepare(
+      `SELECT cc.*, NULL AS bm25
+         FROM code_chunks cc
+         ORDER BY updated_at DESC
+         LIMIT 80`
+    ).all();
+    for (const row of rows) {
+      const chunk = rowToCodeChunk(row);
+      candidates.set(chunk.id, chunk);
+    }
+  }
+  return [...candidates.values()];
+}
+function rankCodeChunks(db, input) {
+  const queryFiles = input.files ?? [];
+  const querySymbols = input.symbols ?? [];
+  const ranked = loadCodeCandidates(db, input).map((chunk) => {
+    const parts = {
+      filePathMatch: filePathMatch2(chunk.filePath, queryFiles),
+      symbolMatch: symbolMatch2(chunk, querySymbols),
+      textMatch: textMatch2(chunk, input),
+      recency: recencyScore2(chunk)
+    };
+    const score = 0.4 * parts.filePathMatch + 0.25 * parts.symbolMatch + 0.25 * parts.textMatch + 0.1 * parts.recency;
+    return {
+      ...chunk,
+      symbols: uniqueStrings(chunk.symbols),
+      score: Number(score.toFixed(4)),
+      scoreParts: parts
+    };
+  }).sort((a, b) => b.score - a.score || b.startLine - a.startLine);
+  const limit = Math.min(5, clampMaxResults(input.maxResults, 5));
+  return ranked.slice(0, limit);
+}
+
 // src/retrieval/formatter.ts
 function evidenceLine(unit) {
   const author = unit.authors[0] ? ` by @${unit.authors[0]}` : "";
@@ -1125,14 +1666,20 @@ function whyItMatters(unit, input) {
 function riskLines(units) {
   const risks = /* @__PURE__ */ new Set();
   for (const unit of units) {
-    if (unit.category === "security_note") risks.add("Avoid logging, exposing, or weakening security-sensitive values.");
-    if (unit.category === "bug_regression") risks.add("Check for regressions similar to the cited PR history.");
-    if (unit.category === "api_contract") risks.add("Preserve documented API and backward-compatibility contracts.");
-    if (unit.category === "constraint") risks.add("Do not remove constraints without verifying the original reason no longer applies.");
+    if (unit.category === "security_note")
+      risks.add("Avoid logging, exposing, or weakening security-sensitive values.");
+    if (unit.category === "bug_regression")
+      risks.add("Check for regressions similar to the cited PR history.");
+    if (unit.category === "api_contract")
+      risks.add("Preserve documented API and backward-compatibility contracts.");
+    if (unit.category === "constraint")
+      risks.add(
+        "Do not remove constraints without verifying the original reason no longer applies."
+      );
   }
   return [...risks].slice(0, 4);
 }
-function formatAnchorContext(units, input) {
+function formatAnchorContext(units, input, codeChunks = []) {
   const lines = ["# Anchor Context", "", "## Must know", ""];
   if (units.length === 0) {
     lines.push("No directly relevant indexed PR history found.", "");
@@ -1146,6 +1693,18 @@ function formatAnchorContext(units, input) {
       lines.push("");
     });
   }
+  lines.push("## Codebase Evidence", "");
+  if (codeChunks.length === 0) {
+    lines.push("No directly relevant indexed codebase context found.", "");
+  } else {
+    codeChunks.forEach((chunk, index) => {
+      const symbols = chunk.symbols.length ? `; symbols: ${chunk.symbols.slice(0, 6).join(", ")}` : "";
+      lines.push(`${index + 1}. ${chunk.filePath}:${chunk.startLine}-${chunk.endLine}${symbols}`);
+      lines.push(`   Why it matters: Current code near this match may affect the requested edit.`);
+      lines.push(`   Snippet: ${clipSentence(chunk.sanitizedText, 260)}`);
+      lines.push("");
+    });
+  }
   lines.push("## Risks", "");
   const risks = riskLines(units);
   if (risks.length === 0) {
@@ -1172,6 +1731,15 @@ function formatAnchorContext(units, input) {
         filePaths: unit.filePaths,
         symbols: unit.symbols,
         duplicateCount: unit.duplicateCount
+      })),
+      codeEvidence: codeChunks.map((chunk) => ({
+        id: chunk.id,
+        score: chunk.score,
+        filePath: chunk.filePath,
+        language: chunk.language,
+        startLine: chunk.startLine,
+        endLine: chunk.endLine,
+        symbols: chunk.symbols
       }))
     }
   };
@@ -1220,7 +1788,10 @@ function formatIndexStatus(status) {
     `- Files: ${status.fileCount}`,
     `- Comments: ${status.commentCount}`,
     `- Wisdom units: ${status.wisdomUnitCount}`,
+    `- Code files: ${status.codeFileCount}`,
+    `- Code chunks: ${status.codeChunkCount}`,
     `- Last sync: ${status.lastSyncTime ?? "never"}`,
+    `- Last code index: ${status.lastCodeIndexTime ?? "never"}`,
     `- GitHub token configured: ${status.githubTokenConfigured ? "yes" : "no"}`,
     `- Health: ${status.health}`
   ];
@@ -1306,16 +1877,67 @@ async function fetchPullRequestDetails(octokit, repoFullName, pullNumber) {
 }
 
 // src/github/fetch-prs.ts
+function resolvePullRequestFetchLimit(options) {
+  return options.all ? void 0 : Math.max(1, Math.min(options.limit ?? 200, 1e3));
+}
+function resolvePullRequestDetailConcurrency(options) {
+  const value = options.detailConcurrency ?? 5;
+  if (!Number.isFinite(value)) return 5;
+  return Math.max(1, Math.min(Math.trunc(value), 10));
+}
+async function fetchPullRequestDetailsConcurrently(options) {
+  const results = new Array(options.pullNumbers.length);
+  let nextIndex = 0;
+  let completed = 0;
+  const workerCount = Math.min(options.detailConcurrency, options.pullNumbers.length);
+  async function worker() {
+    while (nextIndex < options.pullNumbers.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      const pullNumber = options.pullNumbers[index];
+      if (pullNumber === void 0) continue;
+      options.onProgress?.({
+        stage: "fetching_pull_request_details",
+        repo: options.repo,
+        current: index + 1,
+        total: options.pullNumbers.length,
+        prNumber: pullNumber,
+        detailConcurrency: options.detailConcurrency
+      });
+      results[index] = await fetchPullRequestDetails(options.octokit, options.repo, pullNumber);
+      completed += 1;
+      options.onProgress?.({
+        stage: "fetched_pull_request_details",
+        repo: options.repo,
+        current: completed,
+        total: options.pullNumbers.length,
+        prNumber: pullNumber,
+        detailConcurrency: options.detailConcurrency
+      });
+    }
+  }
+  await Promise.all(Array.from({ length: workerCount }, () => worker()));
+  return results.map((result, index) => {
+    if (!result) {
+      throw new Error(`Failed to fetch PR details at index ${index}.`);
+    }
+    return result;
+  });
+}
 async function fetchMergedPullRequests(options) {
   const [owner, repo] = options.repo.split("/");
   if (!owner || !repo) throw new Error(`Invalid repo '${options.repo}'. Expected owner/name.`);
   const octokit = createGitHubClient(options.token);
-  const limit = Math.max(1, Math.min(options.limit ?? 200, 1e3));
+  const limit = resolvePullRequestFetchLimit(options);
+  const detailConcurrency = resolvePullRequestDetailConcurrency(options);
   const sinceTime = options.since ? Date.parse(options.since) : void 0;
   const pullNumbers = [];
+  let scannedPullRequests = 0;
+  let reachedSinceBoundary = false;
   options.onProgress?.({
     stage: "discovering_pull_requests",
     repo: options.repo,
+    all: limit === void 0,
     limit,
     since: options.since
   });
@@ -1325,41 +1947,48 @@ async function fetchMergedPullRequests(options) {
     state: "closed",
     sort: "updated",
     direction: "desc",
-    per_page: 50
+    per_page: 100
   })) {
+    scannedPullRequests += response.data.length;
     for (const pull of response.data) {
-      if (!pull.merged_at) continue;
       if (sinceTime && Date.parse(pull.updated_at) < sinceTime) {
-        continue;
+        reachedSinceBoundary = true;
+        break;
       }
+      if (!pull.merged_at) continue;
       pullNumbers.push(pull.number);
-      if (pullNumbers.length >= limit) break;
+      if (limit !== void 0 && pullNumbers.length >= limit) break;
     }
-    if (pullNumbers.length >= limit) break;
+    options.onProgress?.({
+      stage: "scanned_pull_request_page",
+      repo: options.repo,
+      all: limit === void 0,
+      limit,
+      scannedPullRequests,
+      matchedMergedPullRequests: pullNumbers.length
+    });
+    if (reachedSinceBoundary || limit !== void 0 && pullNumbers.length >= limit) break;
   }
   options.onProgress?.({
     stage: "discovered_pull_requests",
     repo: options.repo,
+    all: limit === void 0,
     total: pullNumbers.length,
-    limit
+    limit,
+    detailConcurrency
+  });
+  return fetchPullRequestDetailsConcurrently({
+    octokit,
+    repo: options.repo,
+    pullNumbers,
+    detailConcurrency,
+    onProgress: options.onProgress
   });
-  const details = [];
-  for (const [index, pullNumber] of pullNumbers.entries()) {
-    options.onProgress?.({
-      stage: "fetching_pull_request_details",
-      repo: options.repo,
-      current: index + 1,
-      total: pullNumbers.length,
-      prNumber: pullNumber
-    });
-    details.push(await fetchPullRequestDetails(octokit, options.repo, pullNumber));
-  }
-  return details;
 }
 
 // src/doctor.ts
-import fs3 from "fs";
-import path6 from "path";
+import fs4 from "fs";
+import path9 from "path";
 function check(name, ok, message, fix) {
   return { name, ok, message, fix: ok ? void 0 : fix };
 }
@@ -1420,12 +2049,12 @@ async function runDoctor(options) {
       )
     );
   }
-  const cursorConfigPath = path6.join(gitRoot ?? cwd, ".cursor", "mcp.json");
+  const cursorConfigPath = path9.join(gitRoot ?? cwd, ".cursor", "mcp.json");
   let cursorConfig;
   let cursorConfigValid = false;
-  if (fs3.existsSync(cursorConfigPath)) {
+  if (fs4.existsSync(cursorConfigPath)) {
     try {
-      cursorConfig = JSON.parse(fs3.readFileSync(cursorConfigPath, "utf8"));
+      cursorConfig = JSON.parse(fs4.readFileSync(cursorConfigPath, "utf8"));
       cursorConfigValid = true;
     } catch {
       cursorConfigValid = false;
@@ -1434,7 +2063,7 @@ async function runDoctor(options) {
   checks.push(
     check(
       ".cursor/mcp.json valid",
-      fs3.existsSync(cursorConfigPath) && cursorConfigValid,
+      fs4.existsSync(cursorConfigPath) && cursorConfigValid,
       cursorConfigValid ? ".cursor/mcp.json exists and is valid JSON." : ".cursor/mcp.json is missing or invalid.",
       "Run anchor init. If the file is malformed, fix the JSON and rerun anchor init."
     )
@@ -1451,7 +2080,7 @@ async function runDoctor(options) {
     )
   );
   const dbPath = defaultDatabasePath(gitRoot ?? cwd);
-  const dbExists = fs3.existsSync(dbPath);
+  const dbExists = fs4.existsSync(dbPath);
   checks.push(
     check(
       ".anchor/index.sqlite exists",
@@ -1495,12 +2124,12 @@ async function runDoctor(options) {
       "Run pnpm build, then try anchor serve from the repository."
     )
   );
-  const rulePath = path6.join(gitRoot ?? cwd, ".cursor", "rules", "anchor.mdc");
+  const rulePath = path9.join(gitRoot ?? cwd, ".cursor", "rules", "anchor.mdc");
   checks.push(
     check(
       "Cursor rule file exists",
-      fs3.existsSync(rulePath),
-      fs3.existsSync(rulePath) ? "Cursor rule file exists." : "Cursor rule file is missing.",
+      fs4.existsSync(rulePath),
+      fs4.existsSync(rulePath) ? "Cursor rule file exists." : "Cursor rule file is missing.",
       "Run anchor init to create .cursor/rules/anchor.mdc."
     )
   );
@@ -1508,12 +2137,14 @@ async function runDoctor(options) {
 }
 export {
   ANCHOR_CURSOR_RULE,
+  DEFAULT_MAX_CODE_FILE_BYTES,
   SCHEMA_SQL,
   anchorMcpEntry,
   buildFtsQuery,
   canonicalizeText,
   categorizeWisdom,
   checkSchema,
+  chunkCodeFile,
   chunkHistoricalText,
   clampMaxResults,
   clipSentence,
@@ -1521,10 +2152,13 @@ export {
   defaultDatabasePath,
   detectGitHubRepo,
   detectGitRoot,
+  discoverCodeFiles,
+  emptyCodeIndexSummary,
   ensureAnchorGitExclude,
   ensureCursorConfig,
   ensureCursorRule,
   ensureRepository,
+  extractCodeSymbols,
   extractSymbols,
   extractWisdomUnits,
   fetchMergedPullRequests,
@@ -1536,16 +2170,22 @@ export {
   getLastSyncTime,
   githubAuthFixMessage,
   hasHighSignalLanguage,
+  indexCodebase,
   indexPullRequests,
   initializeSchema,
+  isHardExcludedCodePath,
   mergeAnchorMcpConfig,
   normalizePullRequest,
   openAnchorDatabase,
   parseGitHubRemote,
+  rankCodeChunks,
   rankWisdomUnits,
   redactSecrets,
   redactedHistoricalText,
+  replaceCodeIndex,
   resolveGitHubToken,
+  resolvePullRequestDetailConcurrency,
+  resolvePullRequestFetchLimit,
   runDoctor,
   sanitizeHistoricalText,
   shouldSyncSince,