@maxgfr/codeindex 2.7.0

package/src/git.ts

@@ -0,0 +1,205 @@
+import { sh } from "./util.js";
+
+// The short HEAD commit of a working tree, when it is a git repo. Recorded in
+// the manifest so an index is pinned to an exact revision. Returns undefined
+// when `git` is absent or the directory isn't a repo — the index still works.
+export function headCommit(dir: string): string | undefined {
+  const res = sh("git", ["-C", dir, "rev-parse", "--short", "HEAD"]);
+  return res.ok ? res.stdout.trim() : undefined;
+}
+
+// ---------------------------------------------------------------------------
+// Diff plumbing for `delta`. All calls disable core.quotePath so non-ASCII
+// paths come back verbatim, and use -z (NUL separators) wherever a path could
+// contain anything surprising.
+
+export interface DiffFile {
+  path: string;
+  status: "added" | "modified" | "deleted" | "renamed";
+  oldPath?: string; // renames only
+  binary?: boolean;
+  linesAdded?: number;
+  linesDeleted?: number;
+}
+
+// A changed line range on the NEW side of the diff. A pure deletion has no new
+// lines, so it maps to the touch-point line and is flagged approx.
+export interface Hunk {
+  start: number;
+  end: number;
+  approx?: boolean;
+}
+
+// The diff to take: a merge-base for branch review, or the staged changeset.
+export interface DiffSpec {
+  mergeBase?: string;
+  staged?: boolean;
+}
+
+const gitArgs = (dir: string): string[] => ["-C", dir, "-c", "core.quotePath=false"];
+const rangeArgs = (spec: DiffSpec): string[] => (spec.staged ? ["--cached"] : [spec.mergeBase!]);
+
+export function isGitWorktree(dir: string): boolean {
+  return sh("git", ["-C", dir, "rev-parse", "--is-inside-work-tree"]).ok;
+}
+
+// Resolve the review base. An explicit ref must exist; otherwise the first of
+// origin/HEAD → origin/main → origin/master → main → master that resolves is
+// taken, and the comparison point is its MERGE-BASE with HEAD (PR semantics —
+// commits landed on the base branch never count as yours). With no candidate
+// (fresh repo, detached CI clone) the base falls back to HEAD with a note.
+export function resolveBaseRef(
+  dir: string,
+  base?: string,
+): { ref: string; mergeBase: string; note?: string } | { error: string } {
+  const verify = (ref: string): boolean =>
+    sh("git", [...gitArgs(dir), "rev-parse", "--verify", "--quiet", `${ref}^{commit}`]).ok;
+  const mergeBase = (ref: string): string | undefined => {
+    const mb = sh("git", [...gitArgs(dir), "merge-base", ref, "HEAD"]);
+    return mb.ok ? mb.stdout.trim() : undefined;
+  };
+
+  if (base) {
+    if (!verify(base)) return { error: `base ref "${base}" not found (tried git rev-parse --verify)` };
+    const mb = mergeBase(base);
+    if (!mb) return { error: `no merge-base between "${base}" and HEAD` };
+    return { ref: base, mergeBase: mb };
+  }
+
+  const originHead = sh("git", [...gitArgs(dir), "symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"]);
+  const candidates = [
+    ...(originHead.ok ? [originHead.stdout.trim().replace("refs/remotes/", "")] : []),
+    "origin/main",
+    "origin/master",
+    "main",
+    "master",
+  ];
+  for (const c of candidates) {
+    if (!verify(c)) continue;
+    const mb = mergeBase(c);
+    if (mb) return { ref: c, mergeBase: mb };
+  }
+  const head = sh("git", [...gitArgs(dir), "rev-parse", "HEAD"]);
+  if (!head.ok) return { error: "cannot resolve HEAD — empty repository?" };
+  return {
+    ref: "HEAD",
+    mergeBase: head.stdout.trim(),
+    note: "base: HEAD (no default branch found — reviewing uncommitted work)",
+  };
+}
+
+// Changed files with statuses (rename-aware) plus per-file churn/binary info
+// from --numstat. Default spec compares the merge-base against the WORKTREE —
+// committed + staged + unstaged, "review my branch as it sits".
+export function diffFiles(dir: string, spec: DiffSpec): DiffFile[] {
+  const out: DiffFile[] = [];
+  const ns = sh("git", [...gitArgs(dir), "diff", "-z", "-M", "--name-status", ...rangeArgs(spec)]);
+  if (ns.ok) {
+    const toks = ns.stdout.split("\0");
+    let i = 0;
+    while (i < toks.length) {
+      const st = toks[i++];
+      if (!st) break;
+      const code = st[0]!;
+      if (code === "R" || code === "C") {
+        const oldPath = toks[i++];
+        const path = toks[i++];
+        if (path) out.push({ path, status: "renamed", oldPath });
+      } else {
+        const path = toks[i++];
+        if (!path) break;
+        const status = code === "A" ? "added" : code === "D" ? "deleted" : "modified"; // M/T/U fold into modified
+        out.push({ path, status });
+      }
+    }
+  }
+
+  const byPath = new Map(out.map((f) => [f.path, f]));
+  const num = sh("git", [...gitArgs(dir), "diff", "-z", "-M", "--numstat", ...rangeArgs(spec)]);
+  if (num.ok) {
+    const toks = num.stdout.split("\0");
+    let i = 0;
+    while (i < toks.length) {
+      const head = toks[i++];
+      if (!head) break;
+      const m = head.match(/^(-|\d+)\t(-|\d+)\t([\s\S]*)$/);
+      if (!m) continue;
+      let path = m[3]!;
+      if (path === "") {
+        i++; // rename record: skip the old-path token
+        path = toks[i++] ?? "";
+      }
+      const rec = byPath.get(path);
+      if (!rec) continue;
+      if (m[1] === "-") rec.binary = true;
+      else {
+        rec.linesAdded = Number(m[1]);
+        rec.linesDeleted = Number(m[2]);
+      }
+    }
+  }
+  return out;
+}
+
+// Changed NEW-side line ranges per file, from one --unified=0 diff call. Pure
+// deletions map to their touch-point line, flagged approx. Files with no
+// content hunks (pure renames, binaries) are absent.
+export function diffHunks(dir: string, spec: DiffSpec): Map<string, Hunk[]> {
+  const map = new Map<string, Hunk[]>();
+  const res = sh("git", [...gitArgs(dir), "diff", "-M", "--unified=0", ...rangeArgs(spec)]);
+  if (!res.ok) return map;
+  let current: Hunk[] | undefined;
+  for (const line of res.stdout.split("\n")) {
+    if (line.startsWith("+++ ")) {
+      const p = line.slice(4).trim();
+      if (p === "/dev/null") {
+        current = undefined;
+        continue;
+      }
+      const path = p.startsWith("b/") ? p.slice(2) : p;
+      current = map.get(path) ?? [];
+      map.set(path, current);
+    } else if (current && line.startsWith("@@")) {
+      const m = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+      if (!m) continue;
+      const start = Number(m[1]);
+      const count = m[2] === undefined ? 1 : Number(m[2]);
+      if (count === 0) current.push({ start: Math.max(start, 1), end: Math.max(start, 1), approx: true });
+      else current.push({ start, end: start + count - 1 });
+    }
+  }
+  return map;
+}
+
+// Untracked (but not ignored) files — part of "the branch as it sits".
+export function untrackedFiles(dir: string): string[] {
+  const res = sh("git", [...gitArgs(dir), "ls-files", "--others", "--exclude-standard", "-z"]);
+  if (!res.ok) return [];
+  return res.stdout.split("\0").filter((p) => p.length > 0);
+}
+
+// Per-file commit counts over the whole history (or since a ref) — the churn
+// half of hotspot analysis. `ok: false` means git was unavailable or the dir
+// isn't a repo: degrade loudly (callers can say "no churn data"), never
+// silently return an empty map that reads as "nothing ever changed".
+export function gitChurn(dir: string, opts: { since?: string } = {}): { churn: Map<string, number>; ok: boolean } {
+  const churn = new Map<string, number>();
+  const range = opts.since ? [`${opts.since}..HEAD`] : [];
+  const res = sh("git", [...gitArgs(dir), "log", ...range, "--pretty=format:", "--name-only", "-z"]);
+  if (!res.ok) return { churn, ok: false };
+  for (const tok of res.stdout.split("\0")) {
+    const f = tok.replace(/^\n+/, "").trim();
+    if (f) churn.set(f, (churn.get(f) ?? 0) + 1);
+  }
+  return { churn, ok: true };
+}
+
+// Files changed since a ref (worktree vs ref) plus untracked files — "what did
+// I touch". Returns an empty set outside a git repo.
+export function changedSince(dir: string, ref: string): Set<string> {
+  const out = new Set<string>();
+  const diff = sh("git", [...gitArgs(dir), "diff", "-z", "--name-only", ref, "--"]);
+  if (diff.ok) for (const p of diff.stdout.split("\0")) if (p) out.add(p);
+  for (const p of untrackedFiles(dir)) out.add(p);
+  return out;
+}

package/src/glob.ts

@@ -0,0 +1,56 @@
+import { escapeRegExp } from "./util.js";
+
+// Minimal glob → RegExp for --include/--exclude. Supports `**` (any path,
+// crossing `/`), `*` (any run within a segment), and `?` (one non-`/` char).
+// Patterns match against the posix path relative to the repo root. Anything
+// fancier (brace expansion, extglob) is intentionally out of scope — keep it
+// dependency-free and predictable.
+function globToRegExp(glob: string): RegExp {
+  let re = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i]!;
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        // `**` — match across directory separators.
+        i++;
+        if (glob[i + 1] === "/") {
+          // `a/**/b` should also match `a/b` → the segment is optional.
+          i++;
+          re += "(?:.*/)?";
+        } else {
+          // Trailing `**` (e.g. `src/**`) must match everything beneath, files
+          // included. `(?:.*/)?` only matches dir-like paths ending in `/`, so a
+          // bare trailing `**` would match ZERO files — use `.*` instead.
+          re += ".*";
+        }
+      } else {
+        re += "[^/]*";
+      }
+    } else if (c === "?") {
+      re += "[^/]";
+    } else {
+      re += escapeRegExp(c);
+    }
+  }
+  return new RegExp(`^${re}$`);
+}
+
+// Compile a list of globs into a single predicate (matches if ANY glob matches).
+// An empty/undefined list yields `null` so callers can skip the test entirely.
+export function compileGlobs(globs: string[] | undefined): ((rel: string) => boolean) | null {
+  if (!globs || globs.length === 0) return null;
+  const res = globs.map(globToRegExp);
+  return (rel: string) => res.some((r) => r.test(rel));
+}
+
+// Negation-aware variant: `!`-prefixed globs EXCLUDE. A path passes when it
+// matches at least one positive glob (or none are given — negations alone
+// mean "everything but") AND matches no negated glob. Exclusion wins over
+// inclusion regardless of list order — grep.ts feeds ripgrep the same way
+// (positives first, negations last) so both backends agree.
+export function compileGlobFilter(globs: string[] | undefined): ((rel: string) => boolean) | null {
+  if (!globs || globs.length === 0) return null;
+  const include = compileGlobs(globs.filter((g) => !g.startsWith("!")));
+  const exclude = compileGlobs(globs.filter((g) => g.startsWith("!")).map((g) => g.slice(1)));
+  return (rel: string) => (!include || include(rel)) && !exclude?.(rel);
+}

package/src/grep.ts

@@ -0,0 +1,115 @@
+// Repo text search: ripgrep when it's on PATH (fast), a pure-JS scan over
+// walk() otherwise (always available). Both backends return the SAME shape,
+// sorted by (file, line) with the cap applied after sorting, so a consumer
+// cannot tell which backend ran — asserted by the backend-parity test.
+import { walk, readText, IGNORE_DIRS, LOCKFILES, BINARY_EXT } from "./walk.js";
+import { compileGlobFilter } from "./glob.js";
+import { sh, have } from "./util.js";
+import { byStr } from "./sort.js";
+
+export interface SearchHit {
+  file: string; // repo-relative posix path
+  line: number; // 1-based
+  text: string; // the matching line, trimmed of the trailing newline
+}
+
+export interface GrepOptions {
+  // Restrict to matching paths (repo-relative, rooted dialect). A `!` prefix
+  // NEGATES the glob: `!sub/**` excludes that tree; exclusion beats inclusion
+  // regardless of list order, identically on both backends.
+  globs?: string[];
+  maxHits?: number; // cap AFTER sorting (default 200)
+  ignoreCase?: boolean;
+  // Force the JS backend even when ripgrep is available (tests, determinism).
+  noRipgrep?: boolean;
+}
+
+const DEFAULT_MAX_HITS = 200;
+
+function sortHits(hits: SearchHit[]): SearchHit[] {
+  return hits.sort((a, b) => byStr(a.file, b.file) || a.line - b.line);
+}
+
+function rgBackend(root: string, pattern: string, opts: GrepOptions): SearchHit[] | undefined {
+  // Align ripgrep's universe with walk()'s exactly: search hidden files (the
+  // walker does), honor .gitignore even outside a git worktree, but NOT the
+  // user/global/exclude/parent/.ignore layers the walker never reads; skip the
+  // same junk dirs, lockfiles and binary extensions; same 1 MiB size cap.
+  const args = [
+    "--no-heading",
+    "--line-number",
+    "--null", // path\0line:text — a `:12:` inside a filename can't corrupt parsing
+    "--color=never",
+    "--no-messages",
+    "--hidden",
+    "--no-require-git",
+    "--no-ignore-global",
+    "--no-ignore-exclude",
+    "--no-ignore-parent",
+    "--no-ignore-dot",
+    "--max-filesize",
+    "1M",
+  ];
+  for (const d of IGNORE_DIRS) args.push("--glob", `!**/${d}/**`);
+  // Lockfiles match at any depth, case-insensitively (the walker lowercases).
+  for (const l of LOCKFILES) args.push("--iglob", `!**/${l}`);
+  for (const ext of BINARY_EXT) args.push("--iglob", `!**/*${ext}`);
+  args.push("--glob", "!*.min.js", "--glob", "!*.min.css");
+  if (opts.ignoreCase) args.push("--ignore-case");
+  // User globs use the engine's rooted dialect (compileGlobFilter anchors at
+  // the repo root); a leading `/` makes rg anchor the same way instead of
+  // basename-matching slash-less patterns. Positives go first and `!`-negated
+  // globs LAST: rg resolves overlapping globs by last-match-wins, so this
+  // ordering makes exclusion beat inclusion — the JS backend's semantics —
+  // regardless of how the caller ordered the list.
+  const user = opts.globs ?? [];
+  const anchor = (g: string): string => (g.startsWith("/") ? g : `/${g}`);
+  for (const g of user.filter((g) => !g.startsWith("!"))) args.push("--glob", anchor(g));
+  for (const g of user.filter((g) => g.startsWith("!"))) args.push("--glob", `!${anchor(g.slice(1))}`);
+  args.push("--regexp", pattern, "./");
+  const res = sh("rg", args, { cwd: root });
+  // status 1 = no matches (fine); anything else (crash, unsupported flag on an
+  // old rg) → let the JS backend give the authoritative answer instead.
+  if (res.missing || (!res.ok && res.status !== 1)) return undefined;
+  const hits: SearchHit[] = [];
+  for (const line of res.stdout.split("\n")) {
+    if (!line) continue;
+    const nul = line.indexOf("\0");
+    if (nul === -1) continue;
+    const file = line.slice(0, nul).replace(/^\.\//, "");
+    const rest = line.slice(nul + 1);
+    const colon = rest.indexOf(":");
+    if (colon === -1) continue;
+    hits.push({ file, line: Number(rest.slice(0, colon)), text: rest.slice(colon + 1) });
+  }
+  return hits;
+}
+
+function jsBackend(root: string, re: RegExp, opts: GrepOptions): SearchHit[] {
+  // Accept the same optionally-`/`-anchored spelling the rg path takes (the
+  // anchor may follow the `!` of a negated glob: `!/sub/**` ≡ `!sub/**`).
+  const filter = compileGlobFilter(opts.globs?.map((g) => g.replace(/^(!?)\//, "$1")));
+  const hits: SearchHit[] = [];
+  for (const f of walk(root).files) {
+    if (filter && !filter(f.rel)) continue;
+    const content = readText(f.abs);
+    if (!content) continue;
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (re.test(lines[i]!)) hits.push({ file: f.rel, line: i + 1, text: lines[i]! });
+    }
+  }
+  return hits;
+}
+
+export function grepRepo(root: string, pattern: string, opts: GrepOptions = {}): SearchHit[] {
+  // The pattern dialect is JS RegExp on BOTH backends: validate up front and
+  // throw the same error regardless of which backend runs, instead of one
+  // backend silently returning [] on syntax the other accepts.
+  const re = new RegExp(pattern, opts.ignoreCase ? "i" : "");
+  const max = opts.maxHits ?? DEFAULT_MAX_HITS;
+  let hits: SearchHit[] | undefined;
+  if (!opts.noRipgrep && have("rg")) hits = rgBackend(root, pattern, opts);
+  hits ??= jsBackend(root, re, opts);
+  return sortHits(hits).slice(0, max);
+}

package/src/hash.ts

@@ -0,0 +1,13 @@
+import { createHash } from "node:crypto";
+
+// Stable content hash used for the manifest's staleness oracle and for the
+// `ui:gen` region fingerprints. sha1 is plenty for change detection (not
+// security) and keeps the manifest compact.
+export function sha1(s: string): string {
+  return createHash("sha1").update(s).digest("hex");
+}
+
+// A short fingerprint for embedding in region fences without bloating the file.
+export function shortHash(s: string, n = 8): string {
+  return sha1(s).slice(0, n);
+}

package/src/ignore.ts

@@ -0,0 +1,134 @@
+// .gitignore support for the walker. Semantics follow git's core rules: per-
+// directory files apply to their subtree, later rules win, `!` negates, a
+// trailing `/` restricts to directories, a `/` anywhere else anchors the
+// pattern to the .gitignore's own directory, `*`/`**`/`?` glob (never crossing
+// `/` except `**`), `[...]` character classes, and `\x` fnmatch escapes.
+// Verified by differential testing against `git check-ignore`. Two deliberate
+// deviations: (1) once a directory is ignored the walk never descends into it,
+// so a negation cannot re-include a file inside it — git behaves the same;
+// (2) matching is ALWAYS case-sensitive (gitignore(5) semantics) even where
+// git's platform default is core.ignorecase=true — a platform-dependent match
+// would break cross-machine byte-identical builds.
+import { escapeRegExp } from "./util.js";
+
+export interface IgnoreRule {
+  re: RegExp; // tested against the path RELATIVE TO THE REPO ROOT (posix)
+  negated: boolean;
+  dirOnly: boolean;
+}
+
+// Compile one gitignore pattern segment-wise. Differs from glob.ts: `**` here
+// follows gitignore's spec (`**/` leading, `/**` trailing, `/**/` mid-pattern),
+// `\x` escapes the next character (fnmatch), and `[...]` character classes are
+// supported (`*.py[cod]`, `[Tt]humbs.db`).
+function patternToRegExpSource(pattern: string): string {
+  let re = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const c = pattern[i]!;
+    if (c === "\\" && i + 1 < pattern.length) {
+      // fnmatch escaping: the next character is literal (`\*`, `\?`, `\ `, `\\`).
+      re += escapeRegExp(pattern[++i]!);
+    } else if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        // `**` is special only at segment boundaries (`**/`, `/**`, `/**/`,
+        // or the whole pattern); anywhere else — `a**b` — git treats each
+        // star as a regular single-segment `*`.
+        const atStart = i === 0 || pattern[i - 1] === "/";
+        let j = i;
+        while (pattern[j + 1] === "*") j++;
+        const next = pattern[j + 1];
+        if (atStart && next === "/") {
+          i = j + 1;
+          re += "(?:[^/]+/)*"; // `**/` — zero or more whole segments
+        } else if (atStart && next === undefined) {
+          i = j;
+          re += ".*"; // trailing `/**` or bare `**` — anything, crossing `/`
+        } else {
+          i = j;
+          re += "[^/]*"; // mid-segment run of stars — one segment, like `*`
+        }
+      } else {
+        re += "[^/]*";
+      }
+    } else if (c === "?") {
+      re += "[^/]";
+    } else if (c === "[") {
+      // Character class: consume up to the closing `]` (a leading `]` is
+      // literal, `!` negates). Falls back to a literal `[` when unclosed.
+      let j = i + 1;
+      let body = "";
+      if (pattern[j] === "!") {
+        body += "^";
+        j++;
+      }
+      if (pattern[j] === "]") {
+        body += "\\]";
+        j++;
+      }
+      while (j < pattern.length && pattern[j] !== "]") {
+        const ch = pattern[j]!;
+        body += ch === "\\" || ch === "^" ? "\\" + ch : ch;
+        j++;
+      }
+      if (j < pattern.length && body !== "" && body !== "^") {
+        re += `[${body}]`;
+        i = j;
+      } else {
+        re += "\\[";
+      }
+    } else {
+      re += escapeRegExp(c);
+    }
+  }
+  return re;
+}
+
+// Parse one .gitignore file. `baseRel` is the directory holding the file,
+// relative to the repo root ("" for the root .gitignore), posix-style.
+export function parseGitignore(content: string, baseRel: string): IgnoreRule[] {
+  const rules: IgnoreRule[] = [];
+  const prefix = baseRel ? escapeRegExp(baseRel) + "/" : "";
+  for (const rawLine of content.split(/\r?\n/)) {
+    // Trailing SPACES are ignored unless backslash-escaped (git trims only
+    // 0x20 — a trailing tab is significant). Blank lines and comments carry no
+    // rule. Escapes (`\ `, `\*`, `\#`…) are consumed by the pattern compiler.
+    let line = rawLine.replace(/(?<!\\) +$/, "");
+    if (!line || line.startsWith("#")) continue;
+    let negated = false;
+    if (line.startsWith("!")) {
+      negated = true;
+      line = line.slice(1);
+    }
+    let dirOnly = false;
+    if (line.endsWith("/")) {
+      dirOnly = true;
+      line = line.slice(0, -1);
+    }
+    if (!line) continue;
+    // A slash anywhere (leading or interior) anchors the pattern to the base
+    // directory; otherwise it floats to any depth beneath it.
+    const anchored = line.includes("/");
+    if (line.startsWith("/")) line = line.slice(1);
+    const body = patternToRegExpSource(line);
+    const source = anchored ? `^${prefix}${body}$` : `^${prefix}(?:[^/]+/)*${body}$`;
+    try {
+      rules.push({ re: new RegExp(source), negated, dirOnly });
+    } catch {
+      // An unparsable pattern is dropped rather than crashing the walk.
+    }
+  }
+  return rules;
+}
+
+// Decide whether `rel` (posix, repo-root-relative) is ignored under an ordered
+// rule chain (root rules first, deeper .gitignore rules appended after — which
+// realizes "later rules win" across nesting levels too). Returns the verdict of
+// the LAST matching rule, or false when none match.
+export function isIgnored(rules: readonly IgnoreRule[], rel: string, isDir: boolean): boolean {
+  let ignored = false;
+  for (const rule of rules) {
+    if (rule.dirOnly && !isDir) continue;
+    if (rule.re.test(rel)) ignored = !rule.negated;
+  }
+  return ignored;
+}

package/src/lang/c.ts

@@ -0,0 +1,26 @@
+import type { CodeSymbol } from "../types.js";
+import { scan, type Rule } from "./common.js";
+
+// C / C++. Regex heuristics: function definitions (a return type then `name(…)`
+// with the line ending in an opening brace or nothing — not a `;` prototype or a
+// control statement), plus type declarations. Conservative to avoid matching
+// calls and macros.
+const NOT_KEYWORD = "(?!\\s*(?:if|for|while|switch|return|else|do|sizeof|typedef)\\b)";
+
+const RULES: Rule[] = [
+  // C++ types
+  { re: /^\s*(?:class|struct)\s+(?<name>[A-Za-z_]\w+)\s*(?:[:{]|$)/, kind: "class", exported: true },
+  { re: /^\s*namespace\s+(?<name>[A-Za-z_]\w+)/, kind: "namespace", exported: true },
+  // typedef struct/enum/union NAME {
+  { re: /^\s*(?:typedef\s+)?(?:struct|enum|union)\s+(?<name>[A-Za-z_]\w+)\s*\{/, kind: "struct", exported: true },
+  // function definition: <type ...> name(<args>) [const] {?  at column 0-ish
+  { re: new RegExp(`^${NOT_KEYWORD}[A-Za-z_][\\w\\s\\*&<>:,]*?\\b(?<name>[A-Za-z_]\\w+)\\s*\\([^;{]*\\)\\s*(?:const)?\\s*\\{?\\s*$`), kind: "function", exported: true },
+];
+
+export const c = {
+  lang: "c/cpp",
+  exts: [".c", ".h", ".cc", ".cpp", ".cxx", ".hpp", ".hh"],
+  extract(rel: string, content: string): CodeSymbol[] {
+    return scan(rel, content, rel.match(/\.(c|h)$/) ? "c" : "cpp", RULES);
+  },
+};

package/src/lang/common.ts

@@ -0,0 +1,68 @@
+import type { CodeSymbol } from "../types.js";
+
+// A line-level extraction rule. `re` must capture the symbol name in a named
+// group `name` (or capture group 1). One symbol is emitted per matching line
+// (first rule wins), which keeps the heuristics cheap and predictable.
+export interface Rule {
+  re: RegExp;
+  kind: string;
+  exported?: boolean | ((m: RegExpExecArray, line: string) => boolean);
+}
+
+// Run a list of rules line-by-line over file content. Deterministic and
+// zero-dep — no parser, no AST, no LLM. Good enough to locate declarations and
+// rank them; ripgrep covers everything inside bodies.
+export function scan(rel: string, content: string, lang: string, rules: Rule[]): CodeSymbol[] {
+  const out: CodeSymbol[] = [];
+  const lines = content.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!;
+    if (!line.trim()) continue;
+    for (const rule of rules) {
+      const m = rule.re.exec(line);
+      if (!m) continue;
+      const name = m.groups?.name ?? m[1];
+      if (!name) continue;
+      const exported =
+        typeof rule.exported === "function" ? rule.exported(m, line) : rule.exported ?? false;
+      out.push({
+        name,
+        kind: rule.kind,
+        file: rel,
+        line: i + 1,
+        signature: line.trim().slice(0, 200),
+        exported,
+        lang,
+      });
+      break;
+    }
+  }
+  return out;
+}
+
+// Broad extension → language label table, used for the index's language
+// histogram even when no symbol extractor exists for that language.
+const EXT_LANG: Record<string, string> = {
+  ".ts": "typescript", ".tsx": "typescript", ".mts": "typescript", ".cts": "typescript",
+  ".js": "javascript", ".jsx": "javascript", ".mjs": "javascript", ".cjs": "javascript",
+  ".py": "python", ".pyi": "python",
+  ".go": "go",
+  ".rb": "ruby", ".rake": "ruby",
+  ".java": "java",
+  ".rs": "rust",
+  ".c": "c", ".h": "c", ".cc": "cpp", ".cpp": "cpp", ".cxx": "cpp", ".hpp": "cpp",
+  ".cs": "csharp", ".php": "php", ".swift": "swift", ".kt": "kotlin", ".kts": "kotlin",
+  ".scala": "scala", ".sc": "scala", ".clj": "clojure", ".ex": "elixir", ".exs": "elixir", ".erl": "erlang",
+  ".hs": "haskell", ".dart": "dart", ".lua": "lua",
+  ".sh": "shell", ".bash": "shell", ".zsh": "shell", ".ksh": "shell", ".fish": "shell",
+  ".hh": "cpp", ".m": "objective-c", ".mm": "objective-c",
+  ".sql": "sql", ".graphql": "graphql", ".gql": "graphql", ".proto": "protobuf",
+  ".md": "markdown", ".mdx": "markdown", ".rst": "restructuredtext", ".txt": "text",
+  ".json": "json", ".yaml": "yaml", ".yml": "yaml", ".toml": "toml", ".ini": "ini",
+  ".html": "html", ".css": "css", ".scss": "scss", ".vue": "vue", ".svelte": "svelte",
+  ".astro": "astro",
+};
+
+export function extToLang(ext: string): string {
+  return EXT_LANG[ext] ?? "other";
+}

package/src/lang/csharp.ts

@@ -0,0 +1,22 @@
+import type { CodeSymbol } from "../types.js";
+import { scan, type Rule } from "./common.js";
+
+// C#. `public`/`internal` mark the public surface. Covers types and methods.
+const pub = (_m: RegExpExecArray, l: string) => /\b(public|internal)\b/.test(l);
+
+const RULES: Rule[] = [
+  { re: /^\s*(?:public|internal|protected|private)?\s*(?:static\s+|sealed\s+|abstract\s+|partial\s+)*(?:class|record)\s+(?<name>\w+)/, kind: "class", exported: pub },
+  { re: /^\s*(?:public|internal|protected|private)?\s*(?:partial\s+)?interface\s+(?<name>\w+)/, kind: "interface", exported: pub },
+  { re: /^\s*(?:public|internal|protected|private)?\s*(?:readonly\s+)?(?:ref\s+)?struct\s+(?<name>\w+)/, kind: "struct", exported: pub },
+  { re: /^\s*(?:public|internal|protected|private)?\s*enum\s+(?<name>\w+)/, kind: "enum", exported: pub },
+  // method: a visibility modifier, a return type, then `name(`
+  { re: /^\s*(?:public|internal|protected|private)\s+(?:static\s+|virtual\s+|override\s+|async\s+|sealed\s+|abstract\s+|new\s+)*[\w<>\[\],.?]+\s+(?<name>\w+)\s*(?:<[^>]*>)?\s*\(/, kind: "method", exported: pub },
+];
+
+export const csharp = {
+  lang: "csharp",
+  exts: [".cs"],
+  extract(rel: string, content: string): CodeSymbol[] {
+    return scan(rel, content, "csharp", RULES);
+  },
+};

package/src/lang/elixir.ts

@@ -0,0 +1,18 @@
+import type { CodeSymbol } from "../types.js";
+import { scan, type Rule } from "./common.js";
+
+// Elixir. Modules and def/defp/defmacro. `defp` is private (not exported).
+const RULES: Rule[] = [
+  { re: /^\s*defmodule\s+(?<name>[\w.]+)/, kind: "module", exported: true },
+  { re: /^\s*defp\s+(?<name>[\w?!]+)/, kind: "function", exported: false },
+  { re: /^\s*def\s+(?<name>[\w?!]+)/, kind: "function", exported: true },
+  { re: /^\s*defmacrop?\s+(?<name>[\w?!]+)/, kind: "macro", exported: true },
+];
+
+export const elixir = {
+  lang: "elixir",
+  exts: [".ex", ".exs"],
+  extract(rel: string, content: string): CodeSymbol[] {
+    return scan(rel, content, "elixir", RULES);
+  },
+};