@sean.holung/minicode 0.3.1 → 0.3.3

package/dist/src/index.js

@@ -3,12 +3,14 @@ import process from "node:process";
 import { writeFile } from "node:fs/promises";
 import { createInterface } from "node:readline/promises";
 import { CodingAgent, createModelClient } from "@minicode/agent-sdk";
-import { formatConfigForDisplay, loadAgentConfig } from "./agent/config.js";
+import { loadAgentConfig, getConfigSetupMessage } from "./agent/config.js";
 import { listSessions, loadSession, loadSessionByLabel, saveSession, } from "./session/session-store.js";
 import { computeFileHashes, getWorkspaceCacheDir, loadIndex, saveIndex, } from "./indexer/cache.js";
 import { buildProjectIndex } from "./indexer/project-index.js";
+import { sortModelsAlphabetically } from "./model-utils.js";
 import { createToolRegistry } from "./tools/registry.js";
 import { CliUsageError, parseCliArgs, validateCliArgs, } from "./cli/args.js";
+import { handleConfigSlashCommand } from "./cli/config-slash-command.js";
 const EXIT_CODE_SUCCESS = 0;
 const EXIT_CODE_RUNTIME_ERROR = 1;
 const EXIT_CODE_USAGE_ERROR = 2;
@@ -18,6 +20,11 @@ function printBanner() {
 }
 async function createAgentRuntime(verbose, onProgress) {
     const config = await loadAgentConfig();
+    const setupMessage = getConfigSetupMessage(config);
+    if (setupMessage) {
+        console.error(setupMessage);
+        process.exit(EXIT_CODE_USAGE_ERROR);
+    }
     const modelClient = createModelClient(config);
     let projectIndex;
     try {
@@ -49,12 +56,12 @@ async function createAgentRuntime(verbose, onProgress) {
             ...(onProgress ? { onProgress } : {}),
         });
     }
-    return { agent: buildAgent(), config, toolRegistry, projectIndex, buildAgent };
+    return { agent: buildAgent(), config, modelClient, toolRegistry, projectIndex, buildAgent };
 }
 async function runInteractive(verbose, initialTask) {
     const runtime = await createAgentRuntime(verbose, (msg) => console.error(`  ${msg}`));
     let { agent } = runtime;
-    const { config, buildAgent } = runtime;
+    const { config, modelClient, buildAgent } = runtime;
     printBanner();
     console.log(`Workspace: ${config.workspaceRoot}`);
     console.log(`Provider: ${config.modelProvider}`);
@@ -98,12 +105,13 @@ async function runInteractive(verbose, initialTask) {
             break;
         }
         if (trimmed === "/help") {
-            console.log('Commands: "/help", "/config", "/compact", "/save [label]", "/load [label]", "/sessions", "/exit"');
+            console.log('Commands: "/help", "/config [keys|get|set|unset]", "/compact", "/reasoning [level]", "/models", "/model [name]", "/save [label]", "/load [label]", "/sessions", "/exit"');
             console.log("Start with --verbose or -v to log prompts, responses, and tool calls.");
             continue;
         }
-        if (trimmed === "/config") {
-            console.log("\n" + formatConfigForDisplay(config) + "\n");
+        const configCommand = await handleConfigSlashCommand(trimmed, { config });
+        if (configCommand.handled) {
+            console.log("\n" + (configCommand.message ?? "") + "\n");
             continue;
         }
         if (trimmed === "/compact") {
@@ -120,6 +128,63 @@ async function runInteractive(verbose, initialTask) {
             }
             continue;
         }
+        if (trimmed === "/reasoning" || trimmed.startsWith("/reasoning ")) {
+            const VALID_LEVELS = ["xhigh", "high", "medium", "low", "minimal", "none"];
+            const arg = trimmed.slice("/reasoning".length).trim().toLowerCase();
+            if (arg.length === 0) {
+                const current = agent.getReasoningEffort() ?? "(unset)";
+                console.log(`Current reasoning effort: ${current}`);
+                console.log(`Valid levels: ${VALID_LEVELS.join(", ")}, off`);
+                continue;
+            }
+            if (arg === "off") {
+                agent.setReasoningEffort(undefined);
+                console.log("Reasoning effort disabled.");
+                continue;
+            }
+            if (VALID_LEVELS.includes(arg)) {
+                agent.setReasoningEffort(arg);
+                console.log(`Reasoning effort set to: ${arg}`);
+            }
+            else {
+                console.log(`Invalid reasoning level "${arg}". Valid levels: ${VALID_LEVELS.join(", ")}, off`);
+            }
+            continue;
+        }
+        if (trimmed === "/models") {
+            if (modelClient.listModels) {
+                console.log("Fetching models...");
+                const models = sortModelsAlphabetically(await modelClient.listModels());
+                if (models.length === 0) {
+                    console.log("No models found (provider may not support listing).");
+                }
+                else {
+                    console.log(`Available models (${models.length}):`);
+                    for (const m of models) {
+                        const marker = m.id === config.model ? " (active)" : "";
+                        console.log(`  ${m.id}${marker}`);
+                    }
+                }
+            }
+            else {
+                console.log("Current provider does not support listing models.");
+            }
+            continue;
+        }
+        if (trimmed.startsWith("/model ")) {
+            const newModel = trimmed.slice("/model ".length).trim();
+            if (newModel.length === 0) {
+                console.log(`Current model: ${config.model}`);
+                continue;
+            }
+            config.model = newModel;
+            console.log(`Model switched to: ${newModel}`);
+            continue;
+        }
+        if (trimmed === "/model") {
+            console.log(`Current model: ${config.model}`);
+            continue;
+        }
         if (trimmed === "/save" || trimmed.startsWith("/save ")) {
             const label = trimmed.slice("/save".length).trim() || undefined;
             try {
@@ -210,6 +275,11 @@ async function runOneshot(params) {
 async function main() {
     const cliArgs = parseCliArgs(process.argv);
     validateCliArgs(cliArgs);
+    if (cliArgs.pluginInstall) {
+        const { installPlugin } = await import("./cli/plugin-install.js");
+        await installPlugin();
+        return;
+    }
     if (cliArgs.serve) {
         const { runServe } = await import("./serve/server.js");
         await runServe(cliArgs.verbose, cliArgs.port);

package/dist/src/indexer/cache.js

@@ -20,19 +20,19 @@ export function getWorkspaceCacheDir(workspaceRoot) {
 function hashContent(content) {
     return createHash("sha256").update(content, "utf8").digest("hex");
 }
-async function collectSourceFiles(dir, root, files) {
+async function collectSourceFiles(dir, root, files, validExtensions) {
     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);
+                await collectSourceFiles(fullPath, root, files, validExtensions);
             }
             continue;
         }
         if (entry.isFile()) {
             const ext = path.extname(entry.name).toLowerCase();
-            if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
+            if (validExtensions.has(ext)) {
                 files.push(path.relative(root, fullPath));
             }
         }
@@ -43,8 +43,10 @@ async function collectSourceFiles(dir, root, files) {
  */
 export async function computeFileHashes(workspaceRoot) {
     const root = path.resolve(workspaceRoot);
+    const plugins = await loadPlugins(root);
+    const validExtensions = new Set(plugins.flatMap((p) => p.extensions));
     const sourceFiles = [];
-    await collectSourceFiles(root, root, sourceFiles);
+    await collectSourceFiles(root, root, sourceFiles, validExtensions);
     const hashes = new Map();
     for (const relPath of sourceFiles) {
         const absPath = path.join(root, relPath);

package/dist/src/indexer/code-map.js

@@ -1,3 +1,4 @@
+import { getSymbolDisplayName } from "./symbol-names.js";
 const DEFAULT_TOKEN_BUDGET = 1500;
 const APPROX_CHARS_PER_TOKEN = 4;
 function estimateTokens(text) {
@@ -7,39 +8,63 @@ function formatSymbol(symbol, indent, isMethod) {
     if (isMethod) {
         return `${indent}  ${symbol.signature}`;
     }
-    return `${indent}${symbol.kind} ${symbol.qualifiedName}\n${indent}  ${symbol.signature}`;
+    return `${indent}${symbol.kind} ${getSymbolDisplayName(symbol)}\n${indent}  ${symbol.signature}`;
 }
 function isEntryPointFile(filePath) {
     const name = filePath.replace(/\\/g, "/");
     return /(?:^|\/)index\.[jt]sx?$/.test(name);
 }
+/**
+ * Build adjacency maps from edges for O(1) lookups per symbol.
+ */
+function buildAdjacencyMaps(edges) {
+    const byFrom = new Map();
+    const byTo = new Map();
+    for (const edge of edges) {
+        const fromList = byFrom.get(edge.from);
+        if (fromList)
+            fromList.push(edge);
+        else
+            byFrom.set(edge.from, [edge]);
+        const toList = byTo.get(edge.to);
+        if (toList)
+            toList.push(edge);
+        else
+            byTo.set(edge.to, [edge]);
+    }
+    return { byFrom, byTo };
+}
 /**
  * Build the set of symbols related to focus symbols via dependency edges.
  * Expands 1 hop outbound (what focus symbols depend on) and 1 hop inbound
  * (what depends on focus symbols).
  */
-function expandFocusSet(focusSymbols, edges) {
+function expandFocusSet(focusSymbols, adjacency) {
     const expanded = new Set(focusSymbols);
-    for (const edge of edges) {
+    for (const sym of focusSymbols) {
         // Outbound: focus symbol depends on something
-        if (focusSymbols.has(edge.from)) {
-            expanded.add(edge.to);
+        const outEdges = adjacency.byFrom.get(sym);
+        if (outEdges) {
+            for (const edge of outEdges)
+                expanded.add(edge.to);
         }
         // Inbound: something depends on focus symbol
-        if (focusSymbols.has(edge.to)) {
-            expanded.add(edge.from);
+        const inEdges = adjacency.byTo.get(sym);
+        if (inEdges) {
+            for (const edge of inEdges)
+                expanded.add(edge.from);
         }
     }
     return expanded;
 }
-function createSymbolRanker(edges, focusSymbols) {
+function createSymbolRanker(adjacency, focusSymbols) {
     const refCount = new Map();
-    for (const e of edges) {
-        refCount.set(e.to, (refCount.get(e.to) ?? 0) + 1);
+    for (const [target, edges] of adjacency.byTo) {
+        refCount.set(target, edges.length);
     }
     // Expand focus set to include 1-hop neighbors in the dependency graph
     const boosted = focusSymbols?.size
-        ? expandFocusSet(focusSymbols, edges)
+        ? expandFocusSet(focusSymbols, adjacency)
         : undefined;
     return (a, b) => {
         // Focus-boosted symbols always sort first
@@ -72,8 +97,11 @@ function createSymbolRanker(edges, focusSymbols) {
 export function generateCodeMap(symbolsByFile, tokenBudget = DEFAULT_TOKEN_BUDGET, dependencyEdges, focusSymbols) {
     const totalCount = [...symbolsByFile.values()].reduce((sum, syms) => sum + syms.length, 0);
     const lines = ["# Project Code Map", ""];
+    const adjacency = dependencyEdges
+        ? buildAdjacencyMaps(dependencyEdges)
+        : { byFrom: new Map(), byTo: new Map() };
     const rank = dependencyEdges
-        ? createSymbolRanker(dependencyEdges, focusSymbols)
+        ? createSymbolRanker(adjacency, focusSymbols)
         : (a, b) => (a.exported === b.exported ? 0 : a.exported ? -1 : 1);
     let totalTokens = estimateTokens(lines.join("\n"));
     let truncatedSymbols = 0;
@@ -82,7 +110,7 @@ export function generateCodeMap(symbolsByFile, tokenBudget = DEFAULT_TOKEN_BUDGE
     // When we have focus symbols, sort files so that files containing
     // focused symbols come first in the code map.
     const boosted = focusSymbols?.size && dependencyEdges
-        ? expandFocusSet(focusSymbols, dependencyEdges)
+        ? expandFocusSet(focusSymbols, adjacency)
         : undefined;
     const sortedFiles = [...symbolsByFile.keys()].sort((a, b) => {
         if (boosted) {

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

@@ -54,6 +54,7 @@ function extractJSDoc(node, sourceFile) {
     return cleaned.length > 0 ? cleaned : undefined;
 }
 function createPlugin() {
+    const astCache = new Map();
     return {
         name: "typescript",
         extensions: EXTENSIONS,
@@ -63,6 +64,7 @@ function createPlugin() {
         },
         indexFile(filePath, content) {
             const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+            astCache.set(filePath, sourceFile);
             const symbols = [];
             let currentClass = null;
             function visit(node) {
@@ -230,44 +232,88 @@ function createPlugin() {
         },
         resolveDependencies(symbols, projectFiles) {
             const symbolSet = new Set(symbols.map((s) => s.qualifiedName));
+            const symbolsByLookup = new Map();
             const edges = [];
+            const edgeKeys = new Set();
             const rootDir = "/project";
+            function addLookup(key, symbol) {
+                if (key.length === 0)
+                    return;
+                const existing = symbolsByLookup.get(key);
+                if (existing) {
+                    existing.push(symbol);
+                }
+                else {
+                    symbolsByLookup.set(key, [symbol]);
+                }
+            }
+            for (const symbol of symbols) {
+                const lookupKeys = new Set([
+                    symbol.qualifiedName,
+                    symbol.name,
+                    symbol.originalQualifiedName ?? "",
+                    symbol.displayName ?? "",
+                    ...(symbol.aliases ?? []),
+                ]);
+                for (const key of lookupKeys) {
+                    addLookup(key, symbol);
+                }
+            }
             function addEdge(from, to, kind) {
-                if (symbolSet.has(to)) {
+                const edgeKey = `${from}->${to}:${kind}`;
+                if (symbolSet.has(from) && symbolSet.has(to) && !edgeKeys.has(edgeKey)) {
+                    edgeKeys.add(edgeKey);
                     edges.push({ from, to, kind });
                 }
             }
-            function collectTypeRefs(node, from) {
+            function resolveCandidates(rawName, filePath, kinds) {
+                const matches = symbolsByLookup.get(rawName) ?? [];
+                return matches.filter((symbol) => (filePath === undefined || symbol.filePath === filePath) &&
+                    (kinds === undefined || kinds.includes(symbol.kind)));
+            }
+            function addResolvedEdges(rawFrom, rawTo, kind, filePath, targetKinds) {
+                const fromMatches = resolveCandidates(rawFrom, filePath);
+                const sameFileTargets = resolveCandidates(rawTo, filePath, targetKinds);
+                const toMatches = sameFileTargets.length > 0
+                    ? sameFileTargets
+                    : resolveCandidates(rawTo, undefined, targetKinds);
+                for (const fromSymbol of fromMatches) {
+                    for (const toSymbol of toMatches) {
+                        addEdge(fromSymbol.qualifiedName, toSymbol.qualifiedName, kind);
+                    }
+                }
+            }
+            function collectTypeRefs(node, from, filePath) {
                 if (ts.isTypeReferenceNode(node)) {
                     const name = node.typeName.getText();
-                    addEdge(from, name, "references");
+                    addResolvedEdges(from, name, "references", filePath, ["type", "interface", "class"]);
                     if (ts.isQualifiedName(node.typeName)) {
                         const left = node.typeName.left;
                         if (ts.isIdentifier(left)) {
-                            addEdge(from, left.getText(), "references");
+                            addResolvedEdges(from, left.getText(), "references", filePath, ["type", "interface", "class"]);
                         }
                     }
                 }
-                ts.forEachChild(node, (n) => collectTypeRefs(n, from));
+                ts.forEachChild(node, (n) => collectTypeRefs(n, from, filePath));
             }
-            function collectCalls(node, from) {
+            function collectCalls(node, from, filePath) {
                 if (ts.isCallExpression(node)) {
                     const expr = node.expression;
                     if (ts.isIdentifier(expr)) {
-                        addEdge(from, expr.getText(), "calls");
+                        addResolvedEdges(from, expr.getText(), "calls", filePath, ["function", "class", "variable"]);
                     }
                 }
                 if (ts.isNewExpression(node)) {
                     const expr = node.expression;
                     if (ts.isIdentifier(expr)) {
-                        addEdge(from, expr.getText(), "calls");
+                        addResolvedEdges(from, expr.getText(), "calls", filePath, ["class", "function"]);
                     }
                 }
-                ts.forEachChild(node, (n) => collectCalls(n, from));
+                ts.forEachChild(node, (n) => collectCalls(n, from, filePath));
             }
             for (const [filePath, content] of projectFiles) {
                 const fullPath = path.join(rootDir, filePath);
-                const sourceFile = ts.createSourceFile(fullPath, content, ts.ScriptTarget.Latest, true);
+                const sourceFile = astCache.get(filePath) ?? ts.createSourceFile(fullPath, content, ts.ScriptTarget.Latest, true);
                 let currentClass = null;
                 function visitClassNode(node, name) {
                     const prevClass = currentClass;
@@ -284,7 +330,7 @@ function createPlugin() {
                                 const kind = clause.token === ts.SyntaxKind.ExtendsKeyword
                                     ? "extends"
                                     : "implements";
-                                addEdge(name, target, kind);
+                                addResolvedEdges(name, target, kind, filePath, ["class", "interface"]);
                             }
                         }
                     }
@@ -300,9 +346,9 @@ function createPlugin() {
                     }
                     if (ts.isConstructorDeclaration(node)) {
                         const from = currentClass ? `${currentClass}.constructor` : "constructor";
-                        if (symbolSet.has(from)) {
-                            collectTypeRefs(node, from);
-                            collectCalls(node, from);
+                        if (resolveCandidates(from, filePath).length > 0) {
+                            collectTypeRefs(node, from, filePath);
+                            collectCalls(node, from, filePath);
                         }
                         return;
                     }
@@ -311,18 +357,18 @@ function createPlugin() {
                             ? "[computed]"
                             : node.name.getText(sourceFile);
                         const from = currentClass ? `${currentClass}.${name}` : name;
-                        if (symbolSet.has(from)) {
-                            collectTypeRefs(node, from);
-                            collectCalls(node, from);
+                        if (resolveCandidates(from, filePath).length > 0) {
+                            collectTypeRefs(node, from, filePath);
+                            collectCalls(node, from, filePath);
                         }
                         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);
+                        if (resolveCandidates(from, filePath).length > 0) {
+                            collectTypeRefs(node, from, filePath);
+                            collectCalls(node, from, filePath);
                         }
                         return;
                     }
@@ -333,9 +379,9 @@ function createPlugin() {
                                 continue;
                             if (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) {
                                 const name = decl.name.getText(sourceFile);
-                                if (symbolSet.has(name)) {
-                                    collectTypeRefs(decl, name);
-                                    collectCalls(decl, name);
+                                if (resolveCandidates(name, filePath).length > 0) {
+                                    collectTypeRefs(decl, name, filePath);
+                                    collectCalls(decl, name, filePath);
                                 }
                             }
                             else if (ts.isClassExpression(init)) {
@@ -349,6 +395,7 @@ function createPlugin() {
                 }
                 visit(sourceFile);
             }
+            astCache.clear();
             return edges;
         },
     };