@opencodehub/ingestion 0.1.0

package/dist/parse/grammar-registry.js

@@ -0,0 +1,278 @@
+/**
+ * Lazy grammar loader.
+ *
+ * Imports the native tree-sitter grammar modules on demand — the first call
+ * to `loadGrammar('python')` pulls in `tree-sitter-python`, subsequent calls
+ * hit the in-process cache. This keeps the cold-start cost of the parse
+ * subsystem low: importing `grammar-registry` alone does not load any grammar
+ * `.node` file.
+ *
+ * Each grammar package exposes its tree-sitter `Language` object differently:
+ *   - typescript: module has `.typescript` and `.tsx` properties
+ *   - javascript/python/go/go/java/rust: module IS the Language
+ *   - c-sharp: ESM default export IS the Language
+ *   - c, cpp, ruby, kotlin, swift: module IS the Language (CJS require)
+ *   - php: module has `.php` and `.php_only` — we load `.php_only` (pure PHP,
+ *     no HTML template injection; better for static analysis)
+ *   - dart: git-pinned CJS module that IS the Language
+ *
+ * This module abstracts those differences behind {@link loadGrammar}.
+ *
+ * ## Regex-provider escape hatch
+ *
+ * Some languages — COBOL is the first — have no maintained tree-sitter
+ * grammar and ship via a pure-regex extractor instead. The registry encodes
+ * that split with a {@link LanguageProviderSpec} discriminated union:
+ *
+ *   - `{ kind: "tree-sitter", package: string }` — the classic path; the
+ *     grammar package is resolved lazily from npm and hashed into the
+ *     parse-cache key via {@link getGrammarSha}.
+ *   - `{ kind: "regex" }` — the escape hatch; {@link loadGrammar} refuses
+ *     to build a `GrammarHandle`, {@link getGrammarSha} returns `null`
+ *     (disables parse-cache keying), and upstream parse-phase code is
+ *     expected to route the file through the language-specific regex
+ *     extractor instead of the worker pool.
+ *
+ * This keeps every tree-sitter consumer of the registry working unchanged
+ * while giving downstream code a typed way to detect regex-only languages.
+ */
+import { createRequire } from "node:module";
+import { sha256Hex } from "@opencodehub/core-types";
+import { getUnifiedQuery } from "./unified-queries.js";
+const requireFn = createRequire(import.meta.url);
+/**
+ * Per-language provider spec. `satisfies Record<LanguageId, …>` keeps this
+ * 1:1 with the `LanguageId` union at compile time — adding a new language
+ * without an entry here fails the type check.
+ *
+ * Tree-sitter entries carry the npm grammar package name. The content-
+ * addressed parse cache hashes `{ name, version }` from that package's
+ * `package.json`, so a grammar version bump in the workspace lockfile
+ * invalidates the cache cleanly.
+ *
+ * Regex entries (currently only `cobol`) carry no package reference —
+ * {@link loadGrammar} and {@link getGrammarSha} treat them as a marker
+ * that the caller must dispatch through the language's regex extractor.
+ */
+const LANGUAGE_PROVIDERS = {
+    typescript: { kind: "tree-sitter", package: "tree-sitter-typescript" },
+    tsx: { kind: "tree-sitter", package: "tree-sitter-typescript" },
+    javascript: { kind: "tree-sitter", package: "tree-sitter-javascript" },
+    python: { kind: "tree-sitter", package: "tree-sitter-python" },
+    go: { kind: "tree-sitter", package: "tree-sitter-go" },
+    rust: { kind: "tree-sitter", package: "tree-sitter-rust" },
+    java: { kind: "tree-sitter", package: "tree-sitter-java" },
+    csharp: { kind: "tree-sitter", package: "tree-sitter-c-sharp" },
+    c: { kind: "tree-sitter", package: "tree-sitter-c" },
+    cpp: { kind: "tree-sitter", package: "tree-sitter-cpp" },
+    ruby: { kind: "tree-sitter", package: "tree-sitter-ruby" },
+    kotlin: { kind: "tree-sitter", package: "tree-sitter-kotlin" },
+    swift: { kind: "tree-sitter", package: "tree-sitter-swift" },
+    php: { kind: "tree-sitter", package: "tree-sitter-php" },
+    dart: { kind: "tree-sitter", package: "tree-sitter-dart" },
+    // COBOL ships via the regex hot path (see `parse/cobol-regex.ts`).
+    cobol: { kind: "regex" },
+};
+/**
+ * Narrow a language's provider spec to its discriminated union. Exported so
+ * upstream parse-phase code can branch on the provider kind without
+ * re-implementing the registry lookup. Typical use:
+ * `getLanguageProvider(lang).kind === "regex"` to guard the regex-dispatch
+ * path.
+ */
+export function getLanguageProvider(lang) {
+    return LANGUAGE_PROVIDERS[lang];
+}
+/** `true` iff `lang` ships via the regex hot path rather than tree-sitter. */
+export function isRegexProviderLanguage(lang) {
+    return LANGUAGE_PROVIDERS[lang].kind === "regex";
+}
+const cache = new Map();
+// De-dupe concurrent calls for the same language so we only require() once.
+const inflight = new Map();
+// Per-process memoization of grammar SHAs — the value is stable for the
+// lifetime of the process (resolving + hashing a package.json is cheap but
+// not free, and scan() calls this per-file).
+const grammarShaCache = new Map();
+/**
+ * Load and cache the tree-sitter grammar for a language.
+ *
+ * Thread/context note: the cache is per-module-instance, so in the
+ * piscina worker model each worker has its own cache — which matches
+ * tree-sitter's thread-safety rules (one Parser per worker_thread).
+ *
+ * Regex-provider languages (see {@link isRegexProviderLanguage}) throw
+ * on entry: they have no tree-sitter grammar to load, and reaching this
+ * function means the caller skipped the `kind === "regex"` dispatch
+ * guard. That is a bug on the call site, not a runtime condition to
+ * recover from.
+ */
+export async function loadGrammar(lang) {
+    const spec = LANGUAGE_PROVIDERS[lang];
+    if (spec.kind === "regex") {
+        throw new Error(`loadGrammar: ${lang} is a regex-provider language and has no tree-sitter grammar; ` +
+            `route the file through the language's regex extractor instead.`);
+    }
+    const cached = cache.get(lang);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const existing = inflight.get(lang);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const p = doLoad(lang).then((handle) => {
+        cache.set(lang, handle);
+        inflight.delete(lang);
+        return handle;
+    });
+    inflight.set(lang, p);
+    return p;
+}
+/**
+ * Preload a list of grammars in parallel. Useful as a warm-up hint during
+ * indexing start-up, but not required — {@link loadGrammar} is safe to call
+ * lazily during parsing.
+ */
+export async function preloadGrammars(langs) {
+    await Promise.all(langs.map((l) => loadGrammar(l)));
+}
+async function doLoad(lang) {
+    const tsLanguage = await loadLanguageObject(lang);
+    return {
+        language: lang,
+        tsLanguage,
+        queryText: getUnifiedQuery(lang),
+    };
+}
+/**
+ * Resolve the Language object for each grammar, handling per-package quirks.
+ * Returned value is passed straight into `parser.setLanguage()`.
+ */
+async function loadLanguageObject(lang) {
+    switch (lang) {
+        case "typescript": {
+            const mod = requireFn("tree-sitter-typescript");
+            return mod.typescript;
+        }
+        case "tsx": {
+            const mod = requireFn("tree-sitter-typescript");
+            return mod.tsx;
+        }
+        case "javascript":
+            return requireFn("tree-sitter-javascript");
+        case "python":
+            return requireFn("tree-sitter-python");
+        case "go":
+            return requireFn("tree-sitter-go");
+        case "rust":
+            return requireFn("tree-sitter-rust");
+        case "java":
+            return requireFn("tree-sitter-java");
+        case "csharp": {
+            // tree-sitter-c-sharp is ESM-only; use dynamic import. The default
+            // export is the Language binding.
+            const mod = (await import("tree-sitter-c-sharp"));
+            return mod.default;
+        }
+        case "c":
+            // tree-sitter-c 0.24.1 — canonical tree-sitter-org CJS grammar, ships
+            // prebuilds for 6 platforms. Module IS the Language.
+            return requireFn("tree-sitter-c");
+        case "cpp":
+            // tree-sitter-cpp 0.23.4 — extends tree-sitter-c; prebuilds shipped.
+            return requireFn("tree-sitter-cpp");
+        case "ruby":
+            // tree-sitter-ruby 0.23.1 — prebuilds shipped. Module IS the Language.
+            return requireFn("tree-sitter-ruby");
+        case "kotlin":
+            // tree-sitter-kotlin 0.3.8 (fwcd) — NO prebuilds on npm; install-time
+            // node-gyp build is expected. If the native binary is missing on an
+            // exotic platform, require() throws and callers surface the error.
+            return requireFn("tree-sitter-kotlin");
+        case "swift":
+            // tree-sitter-swift 0.7.1 (alex-pinkus) — ships prebuilds but also has
+            // a postinstall rebuild (~30s one-time). Runtime-transparent.
+            return requireFn("tree-sitter-swift");
+        case "php": {
+            // tree-sitter-php 0.24.2 ships TWO grammars in one package:
+            //   - `.php`: pure PHP with HTML injection (for .blade.php, .phtml etc.)
+            //   - `.php_only`: pure PHP without HTML injection
+            // We load `.php_only` — static analysis cares about PHP code, not HTML.
+            const mod = requireFn("tree-sitter-php");
+            return mod.php_only;
+        }
+        case "dart":
+            // tree-sitter-dart git-pinned to UserNobody14/tree-sitter-dart SHA
+            // 0fc19c3a (2026-03-14). npm registry 1.0.0 is 3 years stale; we pin
+            // via the `git+https://…#sha` URL in package.json. Module IS the
+            // Language (CJS, uses legacy `nan` addon API).
+            return requireFn("tree-sitter-dart");
+        case "cobol":
+            // Guarded at the `loadGrammar` entry point via the provider-kind
+            // discriminator; a direct call to `loadLanguageObject("cobol")`
+            // indicates a caller bypassed that guard. Keep the branch so
+            // TypeScript's exhaustiveness check passes.
+            throw new Error("loadLanguageObject: cobol is a regex-provider language (no tree-sitter grammar)");
+    }
+}
+/**
+ * Compute a stable SHA for the grammar backing `lang`. The SHA is derived
+ * from `sha256(JSON.stringify({ name, version }))` of the grammar's
+ * `package.json` — bumping the grammar version in the workspace therefore
+ * produces a new SHA, which is what the content-addressed parse cache
+ * needs in its composite key.
+ *
+ * Returns `null` when:
+ *   - the grammar package is not installed (e.g. languages whose provider
+ *     track has not landed yet), OR
+ *   - the package.json could not be read/parsed.
+ *
+ * Result is memoized per-process. Idempotent across concurrent callers.
+ */
+export async function getGrammarSha(lang) {
+    if (grammarShaCache.has(lang)) {
+        return grammarShaCache.get(lang) ?? null;
+    }
+    const spec = LANGUAGE_PROVIDERS[lang];
+    // Regex-provider languages have no npm grammar to fingerprint, so
+    // parse-cache keying is disabled for those files (cache writes / reads
+    // treat `null` as "uncacheable").
+    const sha = spec.kind === "regex" ? null : await computeGrammarSha(spec.package);
+    grammarShaCache.set(lang, sha);
+    return sha;
+}
+async function computeGrammarSha(pkgName) {
+    // `require.resolve('<pkg>/package.json')` returns the absolute path of the
+    // package's manifest without executing any of its bindings — safe to call
+    // even for grammars that fail to build natively at install time.
+    let manifestPath;
+    try {
+        manifestPath = requireFn.resolve(`${pkgName}/package.json`);
+    }
+    catch {
+        return null;
+    }
+    let manifest;
+    try {
+        const { readFile } = await import("node:fs/promises");
+        const text = await readFile(manifestPath, "utf8");
+        manifest = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    const name = typeof manifest.name === "string" ? manifest.name : pkgName;
+    const version = typeof manifest.version === "string" ? manifest.version : "";
+    if (version === "")
+        return null;
+    // Canonical JSON-like form so the SHA does not depend on object key order.
+    return sha256Hex(JSON.stringify({ name, version }));
+}
+/** For tests: drop the cache so the next load() re-imports fresh. */
+export function _resetGrammarCacheForTests() {
+    cache.clear();
+    inflight.clear();
+    grammarShaCache.clear();
+}
+//# sourceMappingURL=grammar-registry.js.map

package/dist/parse/grammar-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar-registry.js","sourceRoot":"","sources":["../../src/parse/grammar-registry.ts"],"names":[],"mappings":"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"}

package/dist/parse/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Barrel exports for the parse subsystem.
+ */
+export type { CobolElement, CobolElementKind, CobolRegexResult } from "./cobol-regex.js";
+export { parseCobolFile } from "./cobol-regex.js";
+export type { GrammarHandle } from "./grammar-registry.js";
+export { _resetGrammarCacheForTests, loadGrammar, preloadGrammars } from "./grammar-registry.js";
+export { detectLanguage } from "./language-detector.js";
+export type { LanguageId, ParseBatch, ParseCapture, ParseResult, ParseTask, } from "./types.js";
+export { getUnifiedQuery } from "./unified-queries.js";
+export { isNativeAvailable, resetNativeAvailabilityCache } from "./wasm-fallback.js";
+export type { DispatchOptions, ParsePoolOptions } from "./worker-pool.js";
+export { chunkTasks, ParsePool } from "./worker-pool.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/parse/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/parse/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzF,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,0BAA0B,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACjG,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,YAAY,EACV,UAAU,EACV,UAAU,EACV,YAAY,EACZ,WAAW,EACX,SAAS,GACV,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAC;AACrF,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/parse/index.js

@@ -0,0 +1,10 @@
+/**
+ * Barrel exports for the parse subsystem.
+ */
+export { parseCobolFile } from "./cobol-regex.js";
+export { _resetGrammarCacheForTests, loadGrammar, preloadGrammars } from "./grammar-registry.js";
+export { detectLanguage } from "./language-detector.js";
+export { getUnifiedQuery } from "./unified-queries.js";
+export { isNativeAvailable, resetNativeAvailabilityCache } from "./wasm-fallback.js";
+export { chunkTasks, ParsePool } from "./worker-pool.js";
+//# sourceMappingURL=index.js.map

package/dist/parse/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/parse/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,EAAE,0BAA0B,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACjG,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAQxD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAC;AAErF,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/parse/language-detector.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Language detection from file path + optional first line (shebang).
+ *
+ * Extension-first, with shebang as a secondary hint for scripts that lack an
+ * informative extension. Returns `undefined` when the file is not one of the
+ * seven MVP languages — callers skip those files rather than throwing.
+ */
+import type { LanguageId } from "./types.js";
+/**
+ * Return the language ID for a given file path, or `undefined` if unknown.
+ *
+ * @param filePath - Path to the file, either absolute or relative.
+ * @param firstLineOrNull - Optional first line of the file (without trailing
+ *   newline); used as a shebang fallback when the extension is missing.
+ */
+export declare function detectLanguage(filePath: string, firstLineOrNull?: string): LanguageId | undefined;
+//# sourceMappingURL=language-detector.d.ts.map

package/dist/parse/language-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-detector.d.ts","sourceRoot":"","sources":["../../src/parse/language-detector.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAmF7C;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAUjG"}

package/dist/parse/language-detector.js

@@ -0,0 +1,104 @@
+/**
+ * Language detection from file path + optional first line (shebang).
+ *
+ * Extension-first, with shebang as a secondary hint for scripts that lack an
+ * informative extension. Returns `undefined` when the file is not one of the
+ * seven MVP languages — callers skip those files rather than throwing.
+ */
+const EXTENSION_MAP = new Map([
+    [".ts", "typescript"],
+    [".mts", "typescript"],
+    [".cts", "typescript"],
+    [".tsx", "tsx"],
+    [".js", "javascript"],
+    [".mjs", "javascript"],
+    [".cjs", "javascript"],
+    [".jsx", "javascript"],
+    [".py", "python"],
+    [".pyi", "python"],
+    [".go", "go"],
+    [".rs", "rust"],
+    [".java", "java"],
+    [".cs", "csharp"],
+    // --- Extended-language additions (C, C++, Ruby, Kotlin, Swift, PHP, Dart) ---
+    [".c", "c"],
+    // .h is ambiguous between C and C++ headers. We default to C here; a
+    // dedicated C++ header detector (scanning the file for `class`, `template`,
+    // `namespace`, etc.) can upgrade the classification in a later pass.
+    [".h", "c"],
+    [".cpp", "cpp"],
+    [".cc", "cpp"],
+    [".cxx", "cpp"],
+    [".hpp", "cpp"],
+    [".hh", "cpp"],
+    [".hxx", "cpp"],
+    [".rb", "ruby"],
+    [".kt", "kotlin"],
+    [".kts", "kotlin"],
+    [".swift", "swift"],
+    [".php", "php"],
+    [".php3", "php"],
+    [".php4", "php"],
+    [".php5", "php"],
+    [".php7", "php"],
+    [".phtml", "php"],
+    [".dart", "dart"],
+    // --- COBOL (regex hot path; see parse/cobol-regex.ts). Fixed-format .cbl /
+    //     .cob programs and .cpy copybooks. Free-format COBOL is NOT handled
+    //     in v1 — the ProLeap deep-parse path will own that AST when wired in. ---
+    [".cbl", "cobol"],
+    [".cob", "cobol"],
+    [".cpy", "cobol"],
+]);
+/**
+ * Best-effort shebang parsing for the rare case where extension is missing.
+ * Only covers interpreters we care about at MVP.
+ */
+function detectFromShebang(firstLine) {
+    if (!firstLine.startsWith("#!")) {
+        return undefined;
+    }
+    const lowered = firstLine.toLowerCase();
+    if (lowered.includes("python")) {
+        return "python";
+    }
+    if (lowered.includes("node")) {
+        return "javascript";
+    }
+    // Rust's `cargo script` style shebang
+    if (lowered.includes("rust-script") || lowered.includes("cargo")) {
+        return "rust";
+    }
+    return undefined;
+}
+function lastExtension(filePath) {
+    // We intentionally take the LAST dot, not the first, so `.d.ts` resolves to
+    // `.ts` (a TypeScript declaration file) rather than the middle `d` part.
+    const slashIdx = Math.max(filePath.lastIndexOf("/"), filePath.lastIndexOf("\\"));
+    const baseName = slashIdx >= 0 ? filePath.slice(slashIdx + 1) : filePath;
+    const dotIdx = baseName.lastIndexOf(".");
+    if (dotIdx <= 0) {
+        // Dotfile without extension (e.g. ".gitignore") or no extension at all.
+        return "";
+    }
+    return baseName.slice(dotIdx).toLowerCase();
+}
+/**
+ * Return the language ID for a given file path, or `undefined` if unknown.
+ *
+ * @param filePath - Path to the file, either absolute or relative.
+ * @param firstLineOrNull - Optional first line of the file (without trailing
+ *   newline); used as a shebang fallback when the extension is missing.
+ */
+export function detectLanguage(filePath, firstLineOrNull) {
+    const ext = lastExtension(filePath);
+    const byExt = EXTENSION_MAP.get(ext);
+    if (byExt !== undefined) {
+        return byExt;
+    }
+    if (firstLineOrNull !== undefined && firstLineOrNull.length > 0) {
+        return detectFromShebang(firstLineOrNull);
+    }
+    return undefined;
+}
+//# sourceMappingURL=language-detector.js.map

package/dist/parse/language-detector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-detector.js","sourceRoot":"","sources":["../../src/parse/language-detector.ts"],"names":[],"mappings":"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"}

package/dist/parse/parse-worker.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Piscina worker entry point.
+ *
+ * Each worker thread imports this file once, then receives {@link ParseBatch}
+ * inputs on every `pool.run()` call. The worker:
+ *   1. Loads the grammar for each task's language (cached in the worker).
+ *   2. Builds a `Parser` with that language (cached).
+ *   3. Compiles the unified S-expression query (cached).
+ *   4. Parses each task's buffer and maps captures to {@link ParseCapture}.
+ *   5. Returns a {@link ParseResult} per task.
+ *
+ * Per-task wall-clock timeout: 30 seconds. On timeout the task returns a
+ * result with empty captures and a warning rather than crashing the worker.
+ *
+ * Safety: tree-sitter parsers are NOT thread-safe; one Parser per worker per
+ * language is a hard constraint. This file enforces that via per-worker maps
+ * keyed by LanguageId.
+ */
+import type { ParseBatch, ParseResult } from "./types.js";
+/**
+ * Piscina task entry. Default export is the function piscina invokes.
+ */
+export default function parseBatch(batch: ParseBatch): Promise<ParseResult[]>;
+//# sourceMappingURL=parse-worker.d.ts.map

package/dist/parse/parse-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-worker.d.ts","sourceRoot":"","sources":["../../src/parse/parse-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAMH,OAAO,KAAK,EAAc,UAAU,EAAgB,WAAW,EAAa,MAAM,YAAY,CAAC;AAgC/F;;GAEG;AACH,wBAA8B,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CA0BlF"}