@snevins/repo-mapper 1.0.3

package/dist/languages.js

@@ -0,0 +1,609 @@
+/**
+ * Language configuration for tree-sitter parsing.
+ * Registry maps language id to config with extensions, grammar, definition types, builtins.
+ */
+import { resolve } from "node:path";
+/**
+ * Common builtins shared across languages.
+ */
+const COMMON_BUILTINS = new Set([
+    "if",
+    "else",
+    "for",
+    "while",
+    "return",
+    "true",
+    "false",
+    "null",
+]);
+/**
+ * TypeScript/JavaScript shared builtins.
+ */
+const TS_JS_BUILTINS = new Set([
+    ...COMMON_BUILTINS,
+    // Control flow
+    "do",
+    "switch",
+    "case",
+    "break",
+    "continue",
+    "throw",
+    "try",
+    "catch",
+    "finally",
+    // Declarations
+    "function",
+    "class",
+    "const",
+    "let",
+    "var",
+    "import",
+    "export",
+    "default",
+    "from",
+    "as",
+    "type",
+    "interface",
+    "enum",
+    "namespace",
+    "module",
+    "declare",
+    "extends",
+    "implements",
+    // Literals and primitives
+    "undefined",
+    "NaN",
+    "Infinity",
+    // Type keywords
+    "string",
+    "number",
+    "boolean",
+    "object",
+    "symbol",
+    "bigint",
+    "void",
+    "any",
+    "unknown",
+    "never",
+    // Special
+    "this",
+    "super",
+    "new",
+    "typeof",
+    "instanceof",
+    "in",
+    "of",
+    "async",
+    "await",
+    "yield",
+    "static",
+    "get",
+    "set",
+    "public",
+    "private",
+    "protected",
+    "readonly",
+    "abstract",
+    // Common globals
+    "console",
+    "print",
+    "window",
+    "document",
+    "global",
+    "globalThis",
+    "process",
+    "require",
+    "exports",
+    "__dirname",
+    "__filename",
+    "Buffer",
+    "Symbol",
+    "Promise",
+    "Array",
+    "Object",
+    "String",
+    "Number",
+    "Boolean",
+    "Error",
+    "Map",
+    "Set",
+    "WeakMap",
+    "WeakSet",
+    "Date",
+    "RegExp",
+    "JSON",
+    "Math",
+]);
+/**
+ * TypeScript/JavaScript definition types.
+ */
+const TS_JS_DEFINITION_TYPES = new Set([
+    "function_declaration",
+    "generator_function_declaration",
+    "class_declaration",
+    "abstract_class_declaration",
+    "interface_declaration",
+    "type_alias_declaration",
+    "enum_declaration",
+    "method_definition",
+]);
+/**
+ * Python builtins.
+ */
+const PYTHON_BUILTINS = new Set([
+    ...COMMON_BUILTINS,
+    // Keywords
+    "and",
+    "as",
+    "assert",
+    "async",
+    "await",
+    "break",
+    "class",
+    "continue",
+    "def",
+    "del",
+    "elif",
+    "except",
+    "finally",
+    "from",
+    "global",
+    "import",
+    "in",
+    "is",
+    "lambda",
+    "nonlocal",
+    "not",
+    "or",
+    "pass",
+    "raise",
+    "try",
+    "with",
+    "yield",
+    // Constants
+    "None",
+    "True",
+    "False",
+    // Builtins
+    "print",
+    "len",
+    "range",
+    "str",
+    "int",
+    "float",
+    "list",
+    "dict",
+    "set",
+    "tuple",
+    "bool",
+    "type",
+    "object",
+    "self",
+    "cls",
+    "__init__",
+    "__name__",
+    "__main__",
+]);
+/**
+ * Python definition types.
+ */
+const PYTHON_DEFINITION_TYPES = new Set([
+    "function_definition",
+    "class_definition",
+]);
+/**
+ * Go builtins.
+ */
+const GO_BUILTINS = new Set([
+    ...COMMON_BUILTINS,
+    // Keywords
+    "break",
+    "case",
+    "chan",
+    "const",
+    "continue",
+    "default",
+    "defer",
+    "fallthrough",
+    "func",
+    "go",
+    "goto",
+    "import",
+    "interface",
+    "map",
+    "package",
+    "range",
+    "select",
+    "struct",
+    "switch",
+    "type",
+    "var",
+    // Builtins
+    "append",
+    "cap",
+    "close",
+    "copy",
+    "delete",
+    "len",
+    "make",
+    "new",
+    "panic",
+    "print",
+    "println",
+    "recover",
+    // Types
+    "bool",
+    "byte",
+    "complex64",
+    "complex128",
+    "error",
+    "float32",
+    "float64",
+    "int",
+    "int8",
+    "int16",
+    "int32",
+    "int64",
+    "rune",
+    "string",
+    "uint",
+    "uint8",
+    "uint16",
+    "uint32",
+    "uint64",
+    "uintptr",
+    "nil",
+]);
+/**
+ * Go definition types.
+ */
+const GO_DEFINITION_TYPES = new Set([
+    "function_declaration",
+    "method_declaration",
+    "type_declaration",
+    "type_spec",
+]);
+/**
+ * Rust builtins.
+ */
+const RUST_BUILTINS = new Set([
+    ...COMMON_BUILTINS,
+    // Keywords
+    "as",
+    "async",
+    "await",
+    "break",
+    "const",
+    "continue",
+    "crate",
+    "dyn",
+    "enum",
+    "extern",
+    "fn",
+    "impl",
+    "in",
+    "let",
+    "loop",
+    "match",
+    "mod",
+    "move",
+    "mut",
+    "pub",
+    "ref",
+    "Self",
+    "self",
+    "static",
+    "struct",
+    "super",
+    "trait",
+    "type",
+    "unsafe",
+    "use",
+    "where",
+    // Types
+    "bool",
+    "char",
+    "str",
+    "i8",
+    "i16",
+    "i32",
+    "i64",
+    "i128",
+    "isize",
+    "u8",
+    "u16",
+    "u32",
+    "u64",
+    "u128",
+    "usize",
+    "f32",
+    "f64",
+    // Common
+    "Some",
+    "None",
+    "Ok",
+    "Err",
+    "Option",
+    "Result",
+    "Vec",
+    "String",
+    "Box",
+    "Rc",
+    "Arc",
+    "println",
+    "print",
+    "format",
+    "panic",
+]);
+/**
+ * Rust definition types.
+ */
+const RUST_DEFINITION_TYPES = new Set([
+    "function_item",
+    "struct_item",
+    "enum_item",
+    "trait_item",
+    "impl_item",
+    "type_item",
+    "mod_item",
+]);
+/**
+ * Solidity builtins.
+ */
+const SOLIDITY_BUILTINS = new Set([
+    ...COMMON_BUILTINS,
+    // Keywords
+    "abstract",
+    "after",
+    "alias",
+    "apply",
+    "auto",
+    "case",
+    "catch",
+    "constant",
+    "copyof",
+    "default",
+    "define",
+    "emit",
+    "error",
+    "event",
+    "external",
+    "fallback",
+    "final",
+    "function",
+    "immutable",
+    "implements",
+    "import",
+    "in",
+    "indexed",
+    "inline",
+    "internal",
+    "is",
+    "let",
+    "macro",
+    "match",
+    "memory",
+    "modifier",
+    "mutable",
+    "new",
+    "of",
+    "override",
+    "partial",
+    "payable",
+    "pragma",
+    "private",
+    "promise",
+    "public",
+    "pure",
+    "receive",
+    "reference",
+    "relocatable",
+    "revert",
+    "sealed",
+    "sizeof",
+    "static",
+    "storage",
+    "struct",
+    "super",
+    "supports",
+    "switch",
+    "this",
+    "throw",
+    "try",
+    "typedef",
+    "typeof",
+    "unchecked",
+    "using",
+    "var",
+    "view",
+    "virtual",
+    // Types
+    "address",
+    "bool",
+    "bytes",
+    "bytes1",
+    "bytes32",
+    "int",
+    "int8",
+    "int256",
+    "mapping",
+    "string",
+    "uint",
+    "uint8",
+    "uint256",
+    // Globals
+    "msg",
+    "block",
+    "tx",
+    "abi",
+    "require",
+    "assert",
+    "keccak256",
+    "sha256",
+    "ecrecover",
+]);
+/**
+ * Solidity definition types.
+ */
+const SOLIDITY_DEFINITION_TYPES = new Set([
+    "function_definition",
+    "contract_declaration",
+    "library_declaration",
+    "interface_declaration",
+    "struct_declaration",
+    "enum_declaration",
+    "event_definition",
+    "error_declaration",
+    "modifier_definition",
+]);
+/**
+ * Language registry - keyed by language id.
+ */
+export const LANGUAGE_REGISTRY = {
+    typescript: {
+        extensions: [".ts", ".mts", ".cts"],
+        grammarName: "typescript",
+        wasmPath: (nm) => resolve(nm, "tree-sitter-typescript", "tree-sitter-typescript.wasm"),
+        definitionTypes: TS_JS_DEFINITION_TYPES,
+        builtins: TS_JS_BUILTINS,
+        fallbackPatterns: [
+            /^export\s+(?:async\s+)?function\s+(\w+)/m,
+            /^export\s+class\s+(\w+)/m,
+            /^export\s+interface\s+(\w+)/m,
+            /^export\s+type\s+(\w+)/m,
+            /^export\s+enum\s+(\w+)/m,
+            /^export\s+const\s+(\w+)/m,
+        ],
+    },
+    tsx: {
+        extensions: [".tsx"],
+        grammarName: "tsx",
+        wasmPath: (nm) => resolve(nm, "tree-sitter-typescript", "tree-sitter-tsx.wasm"),
+        definitionTypes: TS_JS_DEFINITION_TYPES,
+        builtins: TS_JS_BUILTINS,
+        fallbackPatterns: [
+            /^export\s+(?:async\s+)?function\s+(\w+)/m,
+            /^export\s+class\s+(\w+)/m,
+            /^export\s+const\s+(\w+)/m,
+        ],
+    },
+    javascript: {
+        extensions: [".js", ".mjs", ".cjs"],
+        grammarName: "javascript",
+        wasmPath: (nm) => resolve(nm, "tree-sitter-javascript", "tree-sitter-javascript.wasm"),
+        definitionTypes: TS_JS_DEFINITION_TYPES,
+        builtins: TS_JS_BUILTINS,
+        fallbackPatterns: [
+            /^export\s+(?:async\s+)?function\s+(\w+)/m,
+            /^export\s+class\s+(\w+)/m,
+            /^export\s+const\s+(\w+)/m,
+        ],
+    },
+    jsx: {
+        extensions: [".jsx"],
+        grammarName: "javascript", // Reuse cached JavaScript grammar (same WASM file)
+        wasmPath: (nm) => resolve(nm, "tree-sitter-javascript", "tree-sitter-javascript.wasm"),
+        definitionTypes: TS_JS_DEFINITION_TYPES,
+        builtins: TS_JS_BUILTINS,
+        fallbackPatterns: [
+            /^export\s+(?:async\s+)?function\s+(\w+)/m,
+            /^export\s+class\s+(\w+)/m,
+            /^export\s+const\s+(\w+)/m,
+        ],
+    },
+    python: {
+        extensions: [".py", ".pyw"],
+        grammarName: "python",
+        wasmPath: (nm) => resolve(nm, "tree-sitter-python", "tree-sitter-python.wasm"),
+        definitionTypes: PYTHON_DEFINITION_TYPES,
+        builtins: PYTHON_BUILTINS,
+        fallbackPatterns: [
+            /^(?:async\s+)?def\s+(\w+)/m,
+            /^class\s+(\w+)/m,
+        ],
+    },
+    go: {
+        extensions: [".go"],
+        grammarName: "go",
+        wasmPath: (nm) => resolve(nm, "tree-sitter-go", "tree-sitter-go.wasm"),
+        definitionTypes: GO_DEFINITION_TYPES,
+        builtins: GO_BUILTINS,
+        fallbackPatterns: [
+            /^func\s+(\w+)/m,
+            /^func\s+\([^)]+\)\s+(\w+)/m, // Method receiver
+            /^type\s+(\w+)\s+struct/m,
+            /^type\s+(\w+)\s+interface/m,
+        ],
+    },
+    rust: {
+        extensions: [".rs"],
+        grammarName: "rust",
+        wasmPath: (nm) => resolve(nm, "tree-sitter-rust", "tree-sitter-rust.wasm"),
+        definitionTypes: RUST_DEFINITION_TYPES,
+        builtins: RUST_BUILTINS,
+        fallbackPatterns: [
+            /^(?:pub\s+)?fn\s+(\w+)/m,
+            /^(?:pub\s+)?struct\s+(\w+)/m,
+            /^(?:pub\s+)?enum\s+(\w+)/m,
+            /^(?:pub\s+)?trait\s+(\w+)/m,
+            /^impl(?:<[^>]+>)?\s+(\w+)/m,
+        ],
+    },
+    solidity: {
+        extensions: [".sol"],
+        grammarName: "solidity",
+        wasmPath: (nm) => resolve(nm, "tree-sitter-solidity", "tree-sitter-solidity.wasm"),
+        definitionTypes: SOLIDITY_DEFINITION_TYPES,
+        builtins: SOLIDITY_BUILTINS,
+        fallbackPatterns: [
+            /^(?:abstract\s+)?contract\s+(\w+)/m,
+            /^library\s+(\w+)/m,
+            /^interface\s+(\w+)/m,
+            /^\s*function\s+(\w+)/m,
+            /^struct\s+(\w+)/m,
+            /^event\s+(\w+)/m,
+            /^error\s+(\w+)/m,
+            /^modifier\s+(\w+)/m,
+        ],
+    },
+};
+/**
+ * Build extension -> language lookup map.
+ */
+function buildExtensionMap() {
+    const map = new Map();
+    for (const [langId, config] of Object.entries(LANGUAGE_REGISTRY)) {
+        for (const ext of config.extensions) {
+            map.set(ext, langId);
+        }
+    }
+    return map;
+}
+const EXTENSION_MAP = buildExtensionMap();
+/**
+ * Get language config for a file extension.
+ * Returns undefined for unsupported extensions.
+ */
+export function getLanguageForExtension(ext) {
+    const langId = EXTENSION_MAP.get(ext);
+    if (!langId)
+        return undefined;
+    return LANGUAGE_REGISTRY[langId];
+}
+/**
+ * Check if extension is supported for tree-sitter parsing.
+ */
+export function isTreeSitterSupported(ext) {
+    return EXTENSION_MAP.has(ext);
+}
+/**
+ * Filter out builtin/keyword identifiers for a language.
+ * Also filters single-character identifiers as they're typically loop vars.
+ * If no config provided, uses TS/JS builtins as default.
+ */
+export function isBuiltin(name, config) {
+    if (name.length <= 1)
+        return true;
+    const builtins = config?.builtins ?? TS_JS_BUILTINS;
+    return builtins.has(name);
+}

package/dist/output.d.ts

@@ -0,0 +1,19 @@
+import type { RankedDefinition, FileGraph } from "./types.js";
+/**
+ * Format output per spec §3.5.
+ * Files sorted by PageRank descending.
+ * Definitions within file sorted by line ascending.
+ * Line numbers right-aligned to max width.
+ */
+export declare function formatOutput(defs: readonly RankedDefinition[], graph: FileGraph, fileRanks: ReadonlyMap<string, number>, focusFiles?: readonly string[]): string;
+/**
+ * Fit ranked definitions to token budget using binary search.
+ * Returns the largest output that fits within the budget.
+ *
+ * Algorithm from spec §8.2:
+ * 1. Binary search over number of definitions
+ * 2. Format first `mid` definitions
+ * 3. If tokens ≤ budget, try more; else try fewer
+ * 4. Return best fit
+ */
+export declare function fitToTokenBudget(defs: readonly RankedDefinition[], graph: FileGraph, fileRanks: ReadonlyMap<string, number>, tokenBudget: number, focusFiles?: readonly string[]): string;