@snevins/repo-mapper 1.0.3

package/dist/index.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+import { writeFile, stat } from "node:fs/promises";
+import { resolve, relative } from "node:path";
+import { parseCliArgs } from "./cli.js";
+import { loadCache, getCachedTags, setCacheEntry, saveCache } from "./cache.js";
+import { discoverFiles, DEFAULT_IGNORED_PATTERNS } from "./files.js";
+import { initParser, parseFile, shutdownParser } from "./parser.js";
+import { buildFileGraph } from "./graph.js";
+import { computePageRank } from "./pagerank.js";
+import { buildPersonalization, rankDefinitions } from "./ranking.js";
+import { fitToTokenBudget } from "./output.js";
+async function main() {
+    const args = parseCliArgs(process.argv.slice(2));
+    const { options } = args;
+    // Determine root directory (first path or cwd)
+    const firstPath = args.paths[0];
+    const rootDir = firstPath !== undefined ? resolve(firstPath) : process.cwd();
+    // Resolve focus files to relative paths
+    const focusFiles = options.focus.map((f) => relative(rootDir, resolve(f)));
+    const focusSet = new Set(focusFiles);
+    if (options.verbose) {
+        console.error(`Root: ${rootDir}`);
+        console.error(`Focus files: ${String(focusFiles.length)}`);
+    }
+    // 1. Discover files (apply ignore patterns unless --no-ignore)
+    const ignoredPatterns = options.noIgnore
+        ? [...options.ignore] // custom patterns only
+        : [...DEFAULT_IGNORED_PATTERNS, ...options.ignore]; // defaults + custom
+    const discoveryResult = await discoverFiles({
+        rootDir,
+        ignoredPatterns: ignoredPatterns.length > 0 ? ignoredPatterns : undefined,
+        maxFiles: options.maxFiles,
+    });
+    const files = discoveryResult.files;
+    if (discoveryResult.wasLimited) {
+        console.error(`Warning: Found ${String(discoveryResult.totalDiscovered)} files, limited to ${String(options.maxFiles)}. ` +
+            `Use --max-files to increase limit or --max-files 0 for unlimited.`);
+    }
+    if (options.verbose) {
+        console.error(`Discovered ${String(files.length)} files`);
+        if (options.noIgnore) {
+            console.error("Default ignore patterns disabled (--no-ignore)");
+        }
+    }
+    // 2. Parse files (with cache)
+    const cache = await loadCache(rootDir, options.refresh);
+    await initParser();
+    const allTags = [];
+    let cacheHits = 0;
+    let cacheMisses = 0;
+    for (const absPath of files) {
+        const relPath = relative(rootDir, absPath);
+        let fileStat;
+        try {
+            fileStat = await stat(absPath);
+        }
+        catch {
+            if (options.verbose) {
+                console.error(`Skipping ${relPath}: file not accessible`);
+            }
+            continue;
+        }
+        const cachedTags = getCachedTags(cache, absPath, fileStat.mtimeMs);
+        if (cachedTags !== undefined) {
+            allTags.push(...cachedTags);
+            cacheHits++;
+        }
+        else {
+            const tags = await parseFile(absPath, relPath);
+            setCacheEntry(cache, absPath, fileStat.mtimeMs, tags);
+            allTags.push(...tags);
+            cacheMisses++;
+        }
+    }
+    shutdownParser();
+    try {
+        await saveCache(cache, rootDir);
+    }
+    catch (err) {
+        if (options.verbose) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`Warning: failed to save cache: ${msg}`);
+        }
+    }
+    if (options.verbose) {
+        const defs = allTags.filter((t) => t.kind === "def");
+        const refs = allTags.filter((t) => t.kind === "ref");
+        console.error(`Cache: ${String(cacheHits)} hits, ${String(cacheMisses)} misses`);
+        console.error(`Parsed ${String(defs.length)} definitions, ${String(refs.length)} references`);
+    }
+    // 3. Build graph
+    const graph = buildFileGraph(allTags);
+    // 4. Compute PageRank
+    const personalization = focusFiles.length > 0
+        ? buildPersonalization(focusFiles)
+        : undefined;
+    const fileRanks = computePageRank(graph, { personalization });
+    // 5. Rank definitions (exclude focus files)
+    const rankedDefs = rankDefinitions(graph, fileRanks, focusSet);
+    if (options.verbose) {
+        console.error(`Ranked ${String(rankedDefs.length)} definitions`);
+    }
+    // 6. Fit to token budget and format output
+    const output = fitToTokenBudget(rankedDefs, graph, fileRanks, options.tokens, focusFiles.length > 0 ? focusFiles : undefined);
+    // 7. Write output
+    if (options.output) {
+        await writeFile(options.output, output);
+        if (options.verbose) {
+            console.error(`Output written to ${options.output}`);
+        }
+    }
+    else {
+        console.log(output);
+    }
+}
+main().catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Error: ${message}`);
+    console.error("\nUsage: repo-mapper [paths...] [options]");
+    console.error("Options:");
+    console.error("  -t, --tokens <n>      Max tokens (default: 1024)");
+    console.error("  -f, --focus <file>    Focus file (repeatable)");
+    console.error("  -o, --output <file>   Output file");
+    console.error("  -r, --refresh         Ignore cache");
+    console.error("  -v, --verbose         Verbose output");
+    console.error("  --ignore <pattern>    Add ignore pattern (repeatable)");
+    console.error("  --no-ignore           Disable default ignore patterns");
+    console.error("  --max-files <n>       Max files to process (default: 10000, 0=unlimited)");
+    process.exit(1);
+});

package/dist/languages.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Language configuration for tree-sitter parsing.
+ * Registry maps language id to config with extensions, grammar, definition types, builtins.
+ */
+/**
+ * Configuration for a supported language.
+ */
+export interface LanguageConfig {
+    /** File extensions that map to this language (e.g., [".py", ".pyw"]) */
+    readonly extensions: readonly string[];
+    /** Grammar name for tree-sitter */
+    readonly grammarName: string;
+    /** Resolve WASM path given node_modules directory */
+    readonly wasmPath: (nodeModules: string) => string;
+    /** AST node types that represent definitions */
+    readonly definitionTypes: ReadonlySet<string>;
+    /** Language-specific builtins/keywords to filter from references */
+    readonly builtins: ReadonlySet<string>;
+    /** Fallback regex patterns for when tree-sitter fails. Captures name in group 1. */
+    readonly fallbackPatterns: readonly RegExp[];
+}
+/**
+ * Language registry - keyed by language id.
+ */
+export declare const LANGUAGE_REGISTRY: Readonly<Record<string, LanguageConfig>>;
+/**
+ * Get language config for a file extension.
+ * Returns undefined for unsupported extensions.
+ */
+export declare function getLanguageForExtension(ext: string): LanguageConfig | undefined;
+/**
+ * Check if extension is supported for tree-sitter parsing.
+ */
+export declare function isTreeSitterSupported(ext: string): boolean;
+/**
+ * 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 declare function isBuiltin(name: string, config?: LanguageConfig): boolean;