@maxgfr/codeindex 2.7.0

package/src/lang/go.ts

@@ -0,0 +1,22 @@
+import type { CodeSymbol } from "../types.js";
+import { scan, type Rule } from "./common.js";
+
+// Go. Exported identifiers start with an uppercase letter — that drives the
+// `exported` flag. Methods carry a receiver: `func (r T) Name(...)`.
+const upper = (name: string) => /^[A-Z]/.test(name);
+
+const RULES: Rule[] = [
+  { re: /^func\s+\([^)]*\)\s+(?<name>[\w]+)\s*\(/, kind: "method", exported: (m) => upper(m.groups!.name!) },
+  { re: /^func\s+(?<name>[\w]+)\s*\(/, kind: "function", exported: (m) => upper(m.groups!.name!) },
+  { re: /^type\s+(?<name>[\w]+)\s+struct\b/, kind: "struct", exported: (m) => upper(m.groups!.name!) },
+  { re: /^type\s+(?<name>[\w]+)\s+interface\b/, kind: "interface", exported: (m) => upper(m.groups!.name!) },
+  { re: /^type\s+(?<name>[\w]+)\s+/, kind: "type", exported: (m) => upper(m.groups!.name!) },
+];
+
+export const go = {
+  lang: "go",
+  exts: [".go"],
+  extract(rel: string, content: string): CodeSymbol[] {
+    return scan(rel, content, "go", RULES);
+  },
+};

package/src/lang/java.ts

@@ -0,0 +1,19 @@
+import type { CodeSymbol } from "../types.js";
+import { scan, type Rule } from "./common.js";
+
+// Java. Types and methods, with `public` driving the exported flag. The method
+// rule is conservative: a visibility modifier, a return type, then `name(`.
+const RULES: Rule[] = [
+  { re: /^\s*(?:public|protected|private)?\s*(?:abstract\s+|final\s+)?class\s+(?<name>[\w]+)/, kind: "class", exported: (_m, l) => /\bpublic\b/.test(l) },
+  { re: /^\s*(?:public|protected|private)?\s*interface\s+(?<name>[\w]+)/, kind: "interface", exported: (_m, l) => /\bpublic\b/.test(l) },
+  { re: /^\s*(?:public|protected|private)?\s*enum\s+(?<name>[\w]+)/, kind: "enum", exported: (_m, l) => /\bpublic\b/.test(l) },
+  { re: /^\s*(?:public|protected|private)\s+(?:static\s+|final\s+|abstract\s+|synchronized\s+)*[\w<>\[\],.?\s]+\s+(?<name>[\w]+)\s*\(/, kind: "method", exported: (_m, l) => /\bpublic\b/.test(l) },
+];
+
+export const java = {
+  lang: "java",
+  exts: [".java"],
+  extract(rel: string, content: string): CodeSymbol[] {
+    return scan(rel, content, "java", RULES);
+  },
+};

package/src/lang/js-ts.ts

@@ -0,0 +1,112 @@
+import type { CodeSymbol } from "../types.js";
+import { scan, type Rule } from "./common.js";
+
+// JavaScript / TypeScript. Heuristic, line-based: catches top-level
+// declarations and their `export` status, which is what drives ranking and
+// "where is X defined" navigation.
+const RULES: Rule[] = [
+  { re: /^\s*export\s+(?:async\s+)?function\s+(?<name>[\w$]+)/, kind: "function", exported: true },
+  { re: /^\s*export\s+default\s+(?:async\s+)?function\s+(?<name>[\w$]+)/, kind: "function", exported: true },
+  { re: /^\s*export\s+default\s+(?:abstract\s+)?class\s+(?<name>[\w$]+)/, kind: "class", exported: true },
+  { re: /^\s*(?:async\s+)?function\s+(?<name>[\w$]+)/, kind: "function", exported: false },
+  { re: /^\s*export\s+(?:abstract\s+)?class\s+(?<name>[\w$]+)/, kind: "class", exported: true },
+  { re: /^\s*(?:abstract\s+)?class\s+(?<name>[\w$]+)/, kind: "class", exported: false },
+  { re: /^\s*export\s+interface\s+(?<name>[\w$]+)/, kind: "interface", exported: true },
+  { re: /^\s*interface\s+(?<name>[\w$]+)/, kind: "interface", exported: false },
+  { re: /^\s*export\s+type\s+(?<name>[\w$]+)/, kind: "type", exported: true },
+  { re: /^\s*type\s+(?<name>[\w$]+)\s*[=<]/, kind: "type", exported: false },
+  { re: /^\s*export\s+enum\s+(?<name>[\w$]+)/, kind: "enum", exported: true },
+  { re: /^\s*export\s+const\s+enum\s+(?<name>[\w$]+)/, kind: "enum", exported: true },
+  // exported const/let bound to an arrow fn or value
+  { re: /^\s*export\s+(?:const|let|var)\s+(?<name>[\w$]+)\s*[:=]/, kind: "const", exported: true },
+  // CommonJS named exports: `exports.foo = …`, `module.exports.foo = …`
+  { re: /^\s*exports\.(?<name>[\w$]+)\s*=/, kind: "const", exported: true },
+  { re: /^\s*module\.exports\.(?<name>[\w$]+)\s*=/, kind: "const", exported: true },
+  // top-level const arrow function (not exported)
+  { re: /^\s*(?:const|let)\s+(?<name>[\w$]+)\s*=\s*(?:async\s*)?\([^)]*\)\s*(?::[^=]+)?=>/, kind: "const", exported: false },
+  // `export default Foo;` — a class/const declared above and exported by reference.
+  { re: /^\s*export\s+default\s+(?<name>[A-Za-z_$][\w$]*)\s*;?\s*$/, kind: "default", exported: true },
+];
+
+// An anonymous default export (`export default function () {}`, `export default
+// class extends Base {}`, `export default () => …`, `export default {…}`) has no
+// name to capture — it gets named after the file stem (ultradoc parity), so the
+// module's default export is still a real, referencable symbol.
+const ANON_DEFAULT_RE = /^\s*export\s+default\s+(?:async\s+)?(?:function|class)?\s*(?:\(|\{|extends\b)/;
+const NAMED_DEFAULT_RE = /^\s*export\s+default\s+(?:async\s+)?(?:function|class)\s+(?!extends\b)[\w$]+/;
+
+function stemOf(rel: string): string {
+  return (rel.split("/").pop() ?? "").replace(/\.[^.]+$/, "");
+}
+
+// Post-pass flipping local declarations to exported when an export LIST names
+// them — forms the one-symbol-per-line rules above cannot see (mirrors
+// ultradoc's applyExportLists):
+// - `export { a, b as c }` marks locals `a`/`b` (the alias `c` itself is emitted
+//   as a `reexport` symbol by extract/code.ts's extractReexports, both tiers);
+//   `export { … } from "x"` is a pure re-export and names no locals.
+// - `module.exports = { foo, bar: baz }` marks the shorthand names, keys and
+//   identifier values (key = the exported surface, value = the local decl).
+// - `export default Foo;` marks the ORIGINAL `Foo` declaration (the line rule
+//   above keeps emitting the `default` reference symbol for byte-compat).
+const EXPORT_LIST_RE = /export\s*\{([^}]*)\}\s*(from\b)?/g;
+const CJS_OBJECT_RE = /module\.exports\s*=\s*\{([^}]*)\}/g;
+const DEFAULT_ID_RE = /(^|\n)\s*export\s+default\s+([A-Za-z_$][\w$]*)\s*;?\s*(?=\n|$)/g;
+
+function applyExportLists(content: string, symbols: CodeSymbol[]): void {
+  const markExported = (name: string | undefined): void => {
+    if (!name || name === "default") return;
+    for (const s of symbols) if (s.name === name) s.exported = true;
+  };
+  const handleList = (inner: string, cjs: boolean): void => {
+    for (const raw of inner.split(",")) {
+      const part = raw.trim().replace(/^type\s+/, "");
+      if (!part) continue;
+      const asMatch = /^([\w$]+)\s+as\s+([\w$]+)$/.exec(part);
+      if (asMatch) {
+        if (asMatch[2] !== "default") markExported(asMatch[1]);
+        continue;
+      }
+      if (cjs) {
+        const kv = /^([\w$]+)\s*:\s*([\w$]+)$/.exec(part);
+        if (kv) {
+          markExported(kv[1]);
+          markExported(kv[2]);
+          continue;
+        }
+      }
+      markExported(/^([\w$]+)/.exec(part)?.[1]);
+    }
+  };
+  let m: RegExpExecArray | null;
+  EXPORT_LIST_RE.lastIndex = 0;
+  while ((m = EXPORT_LIST_RE.exec(content))) {
+    if (!m[2]) handleList(m[1] ?? "", false);
+  }
+  CJS_OBJECT_RE.lastIndex = 0;
+  while ((m = CJS_OBJECT_RE.exec(content))) handleList(m[1] ?? "", true);
+  DEFAULT_ID_RE.lastIndex = 0;
+  while ((m = DEFAULT_ID_RE.exec(content))) markExported(m[2]);
+}
+
+export const jsTs = {
+  lang: "javascript/typescript",
+  exts: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"],
+  extract(rel: string, content: string): CodeSymbol[] {
+    const lang = rel.match(/\.(ts|tsx|mts|cts)$/) ? "typescript" : "javascript";
+    const symbols = scan(rel, content, lang, RULES);
+    const lines = content.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i]!;
+      if (ANON_DEFAULT_RE.test(line) && !NAMED_DEFAULT_RE.test(line)) {
+        symbols.push({
+          name: stemOf(rel), kind: "default", file: rel, line: i + 1,
+          signature: line.trim().slice(0, 200), exported: true, lang,
+        });
+        break;
+      }
+    }
+    applyExportLists(content, symbols);
+    return symbols;
+  },
+};

package/src/lang/kotlin.ts

@@ -0,0 +1,20 @@
+import type { CodeSymbol } from "../types.js";
+import { scan, type Rule } from "./common.js";
+
+// Kotlin. `private`/`internal` are not exported; the default (public) is.
+const vis = (_m: RegExpExecArray, l: string) => !/\b(private|internal)\b/.test(l);
+
+const RULES: Rule[] = [
+  { re: /^\s*(?:public\s+|internal\s+|private\s+|abstract\s+|sealed\s+|open\s+|final\s+|data\s+)*class\s+(?<name>\w+)/, kind: "class", exported: vis },
+  { re: /^\s*(?:public\s+|internal\s+|private\s+|fun\s+)?interface\s+(?<name>\w+)/, kind: "interface", exported: vis },
+  { re: /^\s*(?:public\s+|internal\s+|private\s+|companion\s+)?object\s+(?<name>\w+)/, kind: "object", exported: vis },
+  { re: /^\s*(?:public\s+|internal\s+|private\s+|protected\s+|override\s+|open\s+|abstract\s+|suspend\s+|inline\s+|operator\s+)*fun\s+(?:<[^>]*>\s+)?(?<name>\w+)\s*\(/, kind: "function", exported: vis },
+];
+
+export const kotlin = {
+  lang: "kotlin",
+  exts: [".kt", ".kts"],
+  extract(rel: string, content: string): CodeSymbol[] {
+    return scan(rel, content, "kotlin", RULES);
+  },
+};

package/src/lang/lua.ts

@@ -0,0 +1,18 @@
+import type { CodeSymbol } from "../types.js";
+import { scan, type Rule } from "./common.js";
+
+// Lua. `function name(…)`, `local function name(…)`, `Table.method(…)` /
+// `Table:method(…)`, and `name = function(…)`.
+const RULES: Rule[] = [
+  { re: /^\s*local\s+function\s+(?<name>[\w.:]+)\s*\(/, kind: "function", exported: false },
+  { re: /^\s*function\s+(?<name>[\w.:]+)\s*\(/, kind: "function", exported: true },
+  { re: /^\s*(?:local\s+)?(?<name>[\w.]+)\s*=\s*function\s*\(/, kind: "function", exported: true },
+];
+
+export const lua = {
+  lang: "lua",
+  exts: [".lua"],
+  extract(rel: string, content: string): CodeSymbol[] {
+    return scan(rel, content, "lua", RULES);
+  },
+};

package/src/lang/php.ts

@@ -0,0 +1,24 @@
+import type { CodeSymbol } from "../types.js";
+import { scan, type Rule } from "./common.js";
+
+// PHP. Classes/interfaces/traits/enums and functions/methods. Methods marked
+// `private`/`protected` are treated as non-exported.
+const RULES: Rule[] = [
+  { re: /^\s*(?:abstract\s+|final\s+)*class\s+(?<name>\w+)/, kind: "class", exported: true },
+  { re: /^\s*interface\s+(?<name>\w+)/, kind: "interface", exported: true },
+  { re: /^\s*trait\s+(?<name>\w+)/, kind: "trait", exported: true },
+  { re: /^\s*enum\s+(?<name>\w+)/, kind: "enum", exported: true },
+  {
+    re: /^\s*(?:public\s+|protected\s+|private\s+|static\s+|abstract\s+|final\s+)*function\s+(?<name>\w+)\s*\(/,
+    kind: "function",
+    exported: (_m, l) => !/\b(private|protected)\b/.test(l),
+  },
+];
+
+export const php = {
+  lang: "php",
+  exts: [".php"],
+  extract(rel: string, content: string): CodeSymbol[] {
+    return scan(rel, content, "php", RULES);
+  },
+};

package/src/lang/python.ts

@@ -0,0 +1,22 @@
+import type { CodeSymbol } from "../types.js";
+import { scan, type Rule } from "./common.js";
+
+// Python. A name not prefixed with "_" is treated as part of the public
+// surface (the usual convention). Indented `def` → method; column-0 `def` →
+// module function.
+const pub = (name: string) => !name.startsWith("_") || name.startsWith("__");
+
+const RULES: Rule[] = [
+  { re: /^(?:async\s+)?def\s+(?<name>[\w]+)\s*\(/, kind: "function", exported: (m) => pub(m.groups!.name!) },
+  { re: /^\s+(?:async\s+)?def\s+(?<name>[\w]+)\s*\(/, kind: "method", exported: (m) => pub(m.groups!.name!) },
+  { re: /^class\s+(?<name>[\w]+)/, kind: "class", exported: (m) => pub(m.groups!.name!) },
+  { re: /^\s+class\s+(?<name>[\w]+)/, kind: "class", exported: (m) => pub(m.groups!.name!) },
+];
+
+export const python = {
+  lang: "python",
+  exts: [".py", ".pyi"],
+  extract(rel: string, content: string): CodeSymbol[] {
+    return scan(rel, content, "python", RULES);
+  },
+};

package/src/lang/registry.ts

@@ -0,0 +1,54 @@
+import type { CodeSymbol } from "../types.js";
+import { extToLang } from "./common.js";
+import { jsTs } from "./js-ts.js";
+import { python } from "./python.js";
+import { go } from "./go.js";
+import { ruby } from "./ruby.js";
+import { java } from "./java.js";
+import { rust } from "./rust.js";
+import { csharp } from "./csharp.js";
+import { php } from "./php.js";
+import { swift } from "./swift.js";
+import { kotlin } from "./kotlin.js";
+import { c } from "./c.js";
+import { lua } from "./lua.js";
+import { shell } from "./shell.js";
+import { elixir } from "./elixir.js";
+import { scala } from "./scala.js";
+
+export interface Extractor {
+  lang: string;
+  exts: string[];
+  extract(rel: string, content: string): CodeSymbol[];
+}
+
+// Registry of symbol extractors keyed by file extension. Adding a language is a
+// matter of writing one `lang/<x>.ts` and registering it here — the same
+// registry pattern reconstruct uses for its framework adapters.
+const EXTRACTORS: Extractor[] = [
+  jsTs, python, go, ruby, java, rust,
+  csharp, php, swift, kotlin, c, lua, shell, elixir, scala,
+];
+
+const BY_EXT = new Map<string, Extractor>();
+for (const e of EXTRACTORS) for (const ext of e.exts) BY_EXT.set(ext, e);
+
+// Extract declared symbols from one file. Returns [] for languages without a
+// dedicated extractor (their content is still fully searchable via ripgrep).
+export function extractSymbols(rel: string, ext: string, content: string): CodeSymbol[] {
+  const extractor = BY_EXT.get(ext);
+  if (!extractor) return [];
+  try {
+    return extractor.extract(rel, content);
+  } catch {
+    return [];
+  }
+}
+
+// Human-readable language label for an extension (used for the language
+// histogram), falling back to the broad table for non-extracted languages.
+export function languageOf(ext: string): string {
+  return BY_EXT.get(ext)?.lang ?? extToLang(ext);
+}
+
+export { extToLang };

package/src/lang/ruby.ts

@@ -0,0 +1,17 @@
+import type { CodeSymbol } from "../types.js";
+import { scan, type Rule } from "./common.js";
+
+// Ruby. `def` (instance/class methods), `class`, and `module` declarations.
+const RULES: Rule[] = [
+  { re: /^\s*def\s+(?:self\.)?(?<name>[\w?!=]+)/, kind: "method", exported: true },
+  { re: /^\s*class\s+(?<name>[\w:]+)/, kind: "class", exported: true },
+  { re: /^\s*module\s+(?<name>[\w:]+)/, kind: "module", exported: true },
+];
+
+export const ruby = {
+  lang: "ruby",
+  exts: [".rb", ".rake"],
+  extract(rel: string, content: string): CodeSymbol[] {
+    return scan(rel, content, "ruby", RULES);
+  },
+};

package/src/lang/rust.ts

@@ -0,0 +1,22 @@
+import type { CodeSymbol } from "../types.js";
+import { scan, type Rule } from "./common.js";
+
+// Rust. `pub` marks the public surface. Covers fn / struct / enum / trait /
+// type declarations.
+const isPub = (_m: RegExpExecArray, l: string) => /^\s*pub\b/.test(l);
+
+const RULES: Rule[] = [
+  { re: /^\s*(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?(?:unsafe\s+)?fn\s+(?<name>[\w]+)/, kind: "function", exported: isPub },
+  { re: /^\s*(?:pub(?:\([^)]*\))?\s+)?struct\s+(?<name>[\w]+)/, kind: "struct", exported: isPub },
+  { re: /^\s*(?:pub(?:\([^)]*\))?\s+)?enum\s+(?<name>[\w]+)/, kind: "enum", exported: isPub },
+  { re: /^\s*(?:pub(?:\([^)]*\))?\s+)?trait\s+(?<name>[\w]+)/, kind: "trait", exported: isPub },
+  { re: /^\s*(?:pub(?:\([^)]*\))?\s+)?type\s+(?<name>[\w]+)/, kind: "type", exported: isPub },
+];
+
+export const rust = {
+  lang: "rust",
+  exts: [".rs"],
+  extract(rel: string, content: string): CodeSymbol[] {
+    return scan(rel, content, "rust", RULES);
+  },
+};

package/src/lang/scala.ts

@@ -0,0 +1,19 @@
+import type { CodeSymbol } from "../types.js";
+import { scan, type Rule } from "./common.js";
+
+// Scala. class/trait/object (incl. `case class`) and `def`. `private`/
+// `protected` defs are not exported.
+const RULES: Rule[] = [
+  { re: /^\s*(?:final\s+|sealed\s+|abstract\s+|implicit\s+)*(?:case\s+)?class\s+(?<name>\w+)/, kind: "class", exported: true },
+  { re: /^\s*(?:sealed\s+)?trait\s+(?<name>\w+)/, kind: "trait", exported: true },
+  { re: /^\s*(?:case\s+)?object\s+(?<name>\w+)/, kind: "object", exported: true },
+  { re: /^\s*(?:override\s+|final\s+|private\s+|protected\s+|implicit\s+)*def\s+(?<name>\w+)/, kind: "def", exported: (_m, l) => !/\b(private|protected)\b/.test(l) },
+];
+
+export const scala = {
+  lang: "scala",
+  exts: [".scala", ".sc"],
+  extract(rel: string, content: string): CodeSymbol[] {
+    return scan(rel, content, "scala", RULES);
+  },
+};

package/src/lang/shell.ts

@@ -0,0 +1,17 @@
+import type { CodeSymbol } from "../types.js";
+import { scan, type Rule } from "./common.js";
+
+// Shell (bash/zsh/sh). Both function syntaxes: `function name { … }` and
+// `name() { … }`.
+const RULES: Rule[] = [
+  { re: /^\s*function\s+(?<name>[\w:-]+)\s*(?:\(\))?\s*\{?/, kind: "function", exported: true },
+  { re: /^\s*(?<name>[A-Za-z_][\w:-]*)\s*\(\)\s*\{?/, kind: "function", exported: true },
+];
+
+export const shell = {
+  lang: "shell",
+  exts: [".sh", ".bash", ".zsh", ".ksh"],
+  extract(rel: string, content: string): CodeSymbol[] {
+    return scan(rel, content, "shell", RULES);
+  },
+};

package/src/lang/swift.ts

@@ -0,0 +1,23 @@
+import type { CodeSymbol } from "../types.js";
+import { scan, type Rule } from "./common.js";
+
+// Swift. Types and funcs. `private`/`fileprivate` are not exported; everything
+// else (internal/public/open, the default) is treated as public surface.
+const vis = (_m: RegExpExecArray, l: string) => !/\b(private|fileprivate)\b/.test(l);
+const MODS = "(?:public\\s+|open\\s+|internal\\s+|private\\s+|fileprivate\\s+)?(?:final\\s+)?";
+
+const RULES: Rule[] = [
+  { re: new RegExp(`^\\s*${MODS}class\\s+(?<name>\\w+)`), kind: "class", exported: vis },
+  { re: new RegExp(`^\\s*${MODS}struct\\s+(?<name>\\w+)`), kind: "struct", exported: vis },
+  { re: new RegExp(`^\\s*${MODS}enum\\s+(?<name>\\w+)`), kind: "enum", exported: vis },
+  { re: new RegExp(`^\\s*${MODS}protocol\\s+(?<name>\\w+)`), kind: "protocol", exported: vis },
+  { re: /^\s*(?:public\s+|open\s+|internal\s+|private\s+|fileprivate\s+)?(?:static\s+|class\s+|final\s+|override\s+|mutating\s+|@\w+\s+)*func\s+(?<name>\w+)/, kind: "function", exported: vis },
+];
+
+export const swift = {
+  lang: "swift",
+  exts: [".swift"],
+  extract(rel: string, content: string): CodeSymbol[] {
+    return scan(rel, content, "swift", RULES);
+  },
+};