@sean.holung/minicode 0.1.0

package/dist/src/indexer/plugins/typescript.js

@@ -0,0 +1,327 @@
+import path from "node:path";
+import ts from "typescript";
+const EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+function getLine(sourceFile, position) {
+    const { line } = sourceFile.getLineAndCharacterOfPosition(position);
+    return line + 1;
+}
+function extractSignature(node, sourceFile) {
+    const fullText = node.getText(sourceFile);
+    const sourceText = sourceFile.getText();
+    const getSigEnd = () => {
+        if (ts.isFunctionDeclaration(node) ||
+            ts.isMethodDeclaration(node) ||
+            ts.isConstructorDeclaration(node)) {
+            return node.body?.getStart(sourceFile) ?? null;
+        }
+        if (ts.isArrowFunction(node) && ts.isBlock(node.body)) {
+            return node.body.getStart(sourceFile);
+        }
+        if (ts.isClassDeclaration(node)) {
+            const text = sourceText.slice(node.getStart(), node.getEnd());
+            const braceIdx = text.indexOf("{");
+            return braceIdx >= 0 ? node.getStart() + braceIdx : null;
+        }
+        return null;
+    };
+    const sigEnd = getSigEnd();
+    if (sigEnd !== null) {
+        const sig = sourceText.slice(node.getStart(), sigEnd).trim();
+        return sig.endsWith(")") ? sig : sig;
+    }
+    return fullText;
+}
+function isExported(node) {
+    if (ts.canHaveModifiers(node)) {
+        const mods = ts.getModifiers(node);
+        if (mods?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+            return true;
+        }
+    }
+    return false;
+}
+function extractJSDoc(node, sourceFile) {
+    const nodeWithJSDoc = node;
+    const jsDoc = nodeWithJSDoc.jsDoc?.[0];
+    if (!jsDoc)
+        return undefined;
+    const fullText = jsDoc.getText(sourceFile);
+    const cleaned = fullText
+        .replace(/^\s*\/\*\*/, "")
+        .replace(/\*\/\s*$/, "")
+        .replace(/^\s*\*\s?/gm, "")
+        .trim();
+    return cleaned.length > 0 ? cleaned : undefined;
+}
+function createPlugin() {
+    return {
+        name: "typescript",
+        extensions: EXTENSIONS,
+        canIndex(filePath) {
+            const lower = filePath.toLowerCase();
+            return EXTENSIONS.some((ext) => lower.endsWith(ext));
+        },
+        indexFile(filePath, content) {
+            const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+            const symbols = [];
+            let currentClass = null;
+            function visit(node) {
+                if (ts.isFunctionDeclaration(node) && node.name) {
+                    const name = node.name.getText(sourceFile);
+                    const qualifiedName = currentClass ? `${currentClass}.${name}` : name;
+                    const doc = extractJSDoc(node, sourceFile);
+                    symbols.push({
+                        name,
+                        qualifiedName,
+                        kind: "function",
+                        filePath,
+                        startLine: getLine(sourceFile, node.getStart(sourceFile)),
+                        endLine: getLine(sourceFile, node.getEnd()),
+                        signature: extractSignature(node, sourceFile),
+                        exported: isExported(node),
+                        dependencies: [],
+                        ...(doc && { docComment: doc }),
+                    });
+                    return;
+                }
+                if (ts.isClassDeclaration(node) && node.name) {
+                    const name = node.name.getText(sourceFile);
+                    const prevClass = currentClass;
+                    currentClass = name;
+                    const doc = extractJSDoc(node, sourceFile);
+                    symbols.push({
+                        name,
+                        qualifiedName: name,
+                        kind: "class",
+                        filePath,
+                        startLine: getLine(sourceFile, node.getStart(sourceFile)),
+                        endLine: getLine(sourceFile, node.getEnd()),
+                        signature: extractSignature(node, sourceFile),
+                        exported: isExported(node),
+                        dependencies: [],
+                        ...(doc && { docComment: doc }),
+                    });
+                    ts.forEachChild(node, visit);
+                    currentClass = prevClass;
+                    return;
+                }
+                if (ts.isConstructorDeclaration(node)) {
+                    const qualifiedName = currentClass
+                        ? `${currentClass}.constructor`
+                        : "constructor";
+                    const doc = extractJSDoc(node, sourceFile);
+                    symbols.push({
+                        name: "constructor",
+                        qualifiedName,
+                        kind: "method",
+                        filePath,
+                        startLine: getLine(sourceFile, node.getStart(sourceFile)),
+                        endLine: getLine(sourceFile, node.getEnd()),
+                        signature: extractSignature(node, sourceFile),
+                        exported: false,
+                        dependencies: [],
+                        ...(doc && { docComment: doc }),
+                    });
+                    return;
+                }
+                if (ts.isMethodDeclaration(node) && node.name) {
+                    const name = ts.isComputedPropertyName(node.name)
+                        ? "[computed]"
+                        : node.name.getText(sourceFile);
+                    const qualifiedName = currentClass ? `${currentClass}.${name}` : name;
+                    const doc = extractJSDoc(node, sourceFile);
+                    symbols.push({
+                        name,
+                        qualifiedName,
+                        kind: "method",
+                        filePath,
+                        startLine: getLine(sourceFile, node.getStart(sourceFile)),
+                        endLine: getLine(sourceFile, node.getEnd()),
+                        signature: extractSignature(node, sourceFile),
+                        exported: false,
+                        dependencies: [],
+                        ...(doc && { docComment: doc }),
+                    });
+                    return;
+                }
+                if (ts.isInterfaceDeclaration(node) && node.name) {
+                    const name = node.name.getText(sourceFile);
+                    const doc = extractJSDoc(node, sourceFile);
+                    symbols.push({
+                        name,
+                        qualifiedName: name,
+                        kind: "interface",
+                        filePath,
+                        startLine: getLine(sourceFile, node.getStart(sourceFile)),
+                        endLine: getLine(sourceFile, node.getEnd()),
+                        signature: node.getText(sourceFile).split("\n")[0] ?? `interface ${name}`,
+                        exported: isExported(node),
+                        dependencies: [],
+                        ...(doc && { docComment: doc }),
+                    });
+                    return;
+                }
+                if (ts.isTypeAliasDeclaration(node) && node.name) {
+                    const name = node.name.getText(sourceFile);
+                    const doc = extractJSDoc(node, sourceFile);
+                    symbols.push({
+                        name,
+                        qualifiedName: name,
+                        kind: "type",
+                        filePath,
+                        startLine: getLine(sourceFile, node.getStart(sourceFile)),
+                        endLine: getLine(sourceFile, node.getEnd()),
+                        signature: node.getText(sourceFile).split("\n")[0] ?? `type ${name}`,
+                        exported: isExported(node),
+                        dependencies: [],
+                        ...(doc && { docComment: doc }),
+                    });
+                    return;
+                }
+                if (ts.isVariableStatement(node)) {
+                    const exported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                    const doc = extractJSDoc(node, sourceFile);
+                    for (const decl of node.declarationList.declarations) {
+                        const init = decl.initializer;
+                        if (ts.isIdentifier(decl.name) &&
+                            init &&
+                            (ts.isArrowFunction(init) || ts.isFunctionExpression(init))) {
+                            const name = decl.name.getText(sourceFile);
+                            symbols.push({
+                                name,
+                                qualifiedName: name,
+                                kind: "function",
+                                filePath,
+                                startLine: getLine(sourceFile, decl.getStart(sourceFile)),
+                                endLine: getLine(sourceFile, decl.getEnd()),
+                                signature: extractSignature(decl, sourceFile),
+                                exported,
+                                dependencies: [],
+                                ...(doc && { docComment: doc }),
+                            });
+                        }
+                    }
+                    return;
+                }
+                ts.forEachChild(node, visit);
+            }
+            visit(sourceFile);
+            return symbols;
+        },
+        resolveDependencies(symbols, projectFiles) {
+            const symbolSet = new Set(symbols.map((s) => s.qualifiedName));
+            const edges = [];
+            const rootDir = "/project";
+            function addEdge(from, to, kind) {
+                if (symbolSet.has(to)) {
+                    edges.push({ from, to, kind });
+                }
+            }
+            function collectTypeRefs(node, from) {
+                if (ts.isTypeReferenceNode(node)) {
+                    const name = node.typeName.getText();
+                    addEdge(from, name, "references");
+                    if (ts.isQualifiedName(node.typeName)) {
+                        const left = node.typeName.left;
+                        if (ts.isIdentifier(left)) {
+                            addEdge(from, left.getText(), "references");
+                        }
+                    }
+                }
+                ts.forEachChild(node, (n) => collectTypeRefs(n, from));
+            }
+            function collectCalls(node, from) {
+                if (ts.isCallExpression(node)) {
+                    const expr = node.expression;
+                    if (ts.isIdentifier(expr)) {
+                        addEdge(from, expr.getText(), "calls");
+                    }
+                    else if (ts.isNewExpression(expr) && expr.expression) {
+                        if (ts.isIdentifier(expr.expression)) {
+                            addEdge(from, expr.expression.getText(), "calls");
+                        }
+                    }
+                }
+                ts.forEachChild(node, (n) => collectCalls(n, from));
+            }
+            for (const [filePath, content] of projectFiles) {
+                const fullPath = path.join(rootDir, filePath);
+                const sourceFile = ts.createSourceFile(fullPath, content, ts.ScriptTarget.Latest, true);
+                let currentClass = null;
+                function visit(node) {
+                    if (ts.isClassDeclaration(node) && node.name) {
+                        const name = node.name.getText(sourceFile);
+                        const prevClass = currentClass;
+                        currentClass = name;
+                        if (symbolSet.has(name)) {
+                            for (const clause of node.heritageClauses ?? []) {
+                                for (const type of clause.types) {
+                                    const expr = type.expression;
+                                    const target = ts.isIdentifier(expr)
+                                        ? expr.getText()
+                                        : ts.isPropertyAccessExpression(expr)
+                                            ? expr.expression.getText()
+                                            : expr.getText();
+                                    const kind = clause.token === ts.SyntaxKind.ExtendsKeyword
+                                        ? "extends"
+                                        : "implements";
+                                    addEdge(name, target, kind);
+                                }
+                            }
+                        }
+                        ts.forEachChild(node, visit);
+                        currentClass = prevClass;
+                        return;
+                    }
+                    if (ts.isConstructorDeclaration(node)) {
+                        const from = currentClass ? `${currentClass}.constructor` : "constructor";
+                        if (symbolSet.has(from)) {
+                            collectTypeRefs(node, from);
+                            collectCalls(node, from);
+                        }
+                        return;
+                    }
+                    if (ts.isMethodDeclaration(node) && node.name) {
+                        const name = ts.isComputedPropertyName(node.name)
+                            ? "[computed]"
+                            : node.name.getText(sourceFile);
+                        const from = currentClass ? `${currentClass}.${name}` : name;
+                        if (symbolSet.has(from)) {
+                            collectTypeRefs(node, from);
+                            collectCalls(node, from);
+                        }
+                        return;
+                    }
+                    if (ts.isFunctionDeclaration(node) && node.name) {
+                        const name = node.name.getText(sourceFile);
+                        const from = currentClass ? `${currentClass}.${name}` : name;
+                        if (symbolSet.has(from)) {
+                            collectTypeRefs(node, from);
+                            collectCalls(node, from);
+                        }
+                        return;
+                    }
+                    if (ts.isVariableStatement(node)) {
+                        for (const decl of node.declarationList.declarations) {
+                            const init = decl.initializer;
+                            if (ts.isIdentifier(decl.name) &&
+                                init &&
+                                (ts.isArrowFunction(init) || ts.isFunctionExpression(init))) {
+                                const name = decl.name.getText(sourceFile);
+                                if (symbolSet.has(name)) {
+                                    collectTypeRefs(decl, name);
+                                    collectCalls(decl, name);
+                                }
+                            }
+                        }
+                        return;
+                    }
+                    ts.forEachChild(node, visit);
+                }
+                visit(sourceFile);
+            }
+            return edges;
+        },
+    };
+}
+export const typescriptPlugin = createPlugin();

package/dist/src/indexer/project-index.js

@@ -0,0 +1,145 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { generateCodeMap } from "./code-map.js";
+import { getPluginForFile, loadPlugins } from "./plugin-loader.js";
+const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", "coverage"]);
+async function collectSourceFiles(dir, root, files) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (!SKIP_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
+                await collectSourceFiles(fullPath, root, files);
+            }
+            continue;
+        }
+        if (entry.isFile()) {
+            const ext = path.extname(entry.name).toLowerCase();
+            if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
+                files.push(path.relative(root, fullPath));
+            }
+        }
+    }
+}
+export function createProjectIndex(symbols, files, dependencyEdges, plugins, projectFiles, workspaceRoot) {
+    return {
+        symbols,
+        files,
+        dependencyEdges,
+        plugins,
+        projectFiles,
+        workspaceRoot,
+        getSymbol(name) {
+            const direct = symbols.get(name);
+            if (direct)
+                return direct;
+            for (const sym of symbols.values()) {
+                if (sym.name === name || sym.qualifiedName === name)
+                    return sym;
+            }
+            return undefined;
+        },
+        getSymbolsInFile(filePath) {
+            return files.get(filePath) ?? [];
+        },
+        getDependencyCone(symbolName, depth = 2) {
+            const target = symbols.get(symbolName) ?? [...symbols.values()].find((s) => s.name === symbolName || s.qualifiedName === symbolName);
+            if (!target)
+                return [];
+            const result = new Map();
+            result.set(target.qualifiedName, target);
+            let frontier = new Set([target.qualifiedName]);
+            for (let d = 0; d < depth; d += 1) {
+                const next = new Set();
+                for (const from of frontier) {
+                    for (const edge of dependencyEdges) {
+                        if (edge.from === from) {
+                            const dep = symbols.get(edge.to) ?? [...symbols.values()].find((s) => s.qualifiedName === edge.to || s.name === edge.to);
+                            if (dep && !result.has(dep.qualifiedName)) {
+                                result.set(dep.qualifiedName, dep);
+                                next.add(dep.qualifiedName);
+                            }
+                        }
+                    }
+                }
+                frontier = next;
+            }
+            return [...result.values()];
+        },
+        getCodeMap(tokenBudget) {
+            return generateCodeMap(files, tokenBudget, dependencyEdges);
+        },
+        reindexFile(filePath, content) {
+            const relPath = path.isAbsolute(filePath)
+                ? path.relative(workspaceRoot, filePath)
+                : path.normalize(filePath);
+            const plugin = getPluginForFile(relPath, plugins);
+            if (!plugin)
+                return;
+            const oldSymbols = files.get(relPath) ?? [];
+            for (const sym of oldSymbols) {
+                symbols.delete(sym.qualifiedName);
+            }
+            files.delete(relPath);
+            projectFiles.set(relPath, content);
+            const extracted = plugin.indexFile(relPath, content);
+            for (const sym of extracted) {
+                symbols.set(sym.qualifiedName, sym);
+                const existing = files.get(relPath) ?? [];
+                existing.push(sym);
+                files.set(relPath, existing);
+            }
+            for (const p of plugins) {
+                if (p.resolveDependencies) {
+                    const allSymbols = [...symbols.values()];
+                    const edges = p.resolveDependencies(allSymbols, projectFiles);
+                    dependencyEdges.splice(0, dependencyEdges.length, ...edges);
+                    break;
+                }
+            }
+        },
+    };
+}
+/**
+ * Build a project index by scanning the workspace and running all matching plugins.
+ */
+export async function buildProjectIndex(workspaceRoot) {
+    const plugins = await loadPlugins(workspaceRoot);
+    const root = path.resolve(workspaceRoot);
+    const sourceFiles = [];
+    await collectSourceFiles(root, root, sourceFiles);
+    const symbols = new Map();
+    const files = new Map();
+    const projectFiles = new Map();
+    for (const relPath of sourceFiles) {
+        const plugin = getPluginForFile(relPath, plugins);
+        if (!plugin)
+            continue;
+        const absPath = path.join(root, relPath);
+        let content;
+        try {
+            content = await readFile(absPath, "utf8");
+        }
+        catch {
+            continue;
+        }
+        projectFiles.set(relPath, content);
+        const extracted = plugin.indexFile(relPath, content);
+        for (const sym of extracted) {
+            symbols.set(sym.qualifiedName, sym);
+            const existing = files.get(relPath) ?? [];
+            existing.push(sym);
+            files.set(relPath, existing);
+        }
+    }
+    let dependencyEdges = [];
+    for (const plugin of plugins) {
+        if (plugin.resolveDependencies) {
+            const allSymbols = [...symbols.values()];
+            const edges = plugin.resolveDependencies(allSymbols, projectFiles);
+            dependencyEdges = edges;
+            break;
+        }
+    }
+    return createProjectIndex(symbols, files, dependencyEdges, plugins, projectFiles, root);
+}

package/dist/src/indexer/types.js

@@ -0,0 +1 @@
+export {};