@sean.holung/minicode 0.1.0

package/dist/src/agent/config.js

@@ -0,0 +1,151 @@
+import { access, readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import dotenv from "dotenv";
+/** User-level config directory: ~/.minicode */
+export const MINICODE_HOME = path.join(os.homedir(), ".minicode");
+/**
+ * Format the current agent configuration for display (e.g. /config slash command).
+ */
+export function formatConfigForDisplay(config) {
+    const lines = [
+        "configHome: " + MINICODE_HOME + " (.env, agent.config.json)",
+        "workspaceRoot: " + config.workspaceRoot,
+        "modelProvider: " + config.modelProvider,
+        "model: " + config.model,
+        "maxSteps: " + config.maxSteps,
+        "maxTokens: " + config.maxTokens,
+        "maxContextTokens: " + config.maxContextTokens,
+        "commandTimeoutMs: " + config.commandTimeoutMs,
+        "maxFileSizeBytes: " + config.maxFileSizeBytes,
+        "maxToolOutputChars: " + config.maxToolOutputChars,
+        "keepRecentMessages: " + config.keepRecentMessages,
+        "loopDetectionWindow: " + config.loopDetectionWindow,
+        "confirmDestructive: " + config.confirmDestructive,
+        "commandDenylist: " + config.commandDenylist.length + " patterns",
+        "openAiBaseUrl: " + config.openAiBaseUrl,
+        "openAiApiKey: " + (config.openAiApiKey ? "***" : "(unset)"),
+    ];
+    return lines.join("\n");
+}
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const envPath = __dirname.includes(`${path.sep}dist${path.sep}`)
+    ? path.resolve(__dirname, "../../../.env")
+    : path.resolve(__dirname, "../../.env");
+// Load order: user home (~/.minicode/.env) < project .env < cwd .env
+dotenv.config({ path: path.join(MINICODE_HOME, ".env") });
+dotenv.config({ path: envPath, override: true });
+dotenv.config({ path: path.resolve(process.cwd(), ".env"), override: true });
+const DEFAULT_COMMAND_DENYLIST = [
+    /\brm\s+-rf\s+\//i,
+    /\bmkfs\b/i,
+    /\bdd\s+if=/i,
+    /:\(\)\s*\{\s*:\|:&\s*\};:/,
+    /\bshutdown\b/i,
+    /\breboot\b/i,
+    /\bpoweroff\b/i,
+    /\binit\s+0\b/i,
+    /\bchmod\s+-R\s+777\s+\//i,
+];
+function parseNumber(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+function parseBoolean(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(normalized)) {
+        return false;
+    }
+    return fallback;
+}
+async function loadConfigFile(configPath) {
+    try {
+        await access(configPath);
+    }
+    catch {
+        return {};
+    }
+    const file = await readFile(configPath, "utf8");
+    const parsed = JSON.parse(file);
+    if (!parsed || typeof parsed !== "object") {
+        return {};
+    }
+    return parsed;
+}
+function parseUserDenylist(patterns) {
+    if (!patterns?.length) {
+        return [];
+    }
+    const denylist = [];
+    for (const pattern of patterns) {
+        try {
+            denylist.push(new RegExp(pattern, "i"));
+        }
+        catch {
+            // Ignore malformed denylist patterns from user config.
+        }
+    }
+    return denylist;
+}
+function parseModelProvider(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "openai-compatible" ||
+        normalized === "openai" ||
+        normalized === "lmstudio" ||
+        normalized === "lm-studio") {
+        return "openai-compatible";
+    }
+    return "anthropic";
+}
+export async function loadAgentConfig(cwd = process.cwd()) {
+    const homeConfigPath = path.join(MINICODE_HOME, "agent.config.json");
+    const workspaceConfigPath = path.resolve(cwd, "agent.config.json");
+    const homeConfig = await loadConfigFile(homeConfigPath);
+    const workspaceConfig = await loadConfigFile(workspaceConfigPath);
+    const fileConfig = { ...homeConfig, ...workspaceConfig };
+    const rawWorkspaceRoot = process.env.WORKSPACE_ROOT ?? fileConfig.workspaceRoot ?? cwd;
+    const workspaceRoot = path.resolve(cwd, rawWorkspaceRoot);
+    const commandDenylist = [
+        ...DEFAULT_COMMAND_DENYLIST,
+        ...parseUserDenylist(fileConfig.commandDenylist),
+    ];
+    const rawBaseUrl = process.env.OPENAI_BASE_URL ??
+        fileConfig.openAiBaseUrl ??
+        "http://localhost:1234/v1";
+    const isOpenRouter = rawBaseUrl.includes("openrouter");
+    const openAiApiKey = isOpenRouter
+        ? (process.env.OPENROUTER_API_KEY ??
+            process.env.OPENAI_API_KEY ??
+            fileConfig.openAiApiKey)
+        : (process.env.OPENAI_API_KEY ?? fileConfig.openAiApiKey);
+    return {
+        modelProvider: parseModelProvider(process.env.MODEL_PROVIDER ?? fileConfig.modelProvider ?? "openai-compatible"),
+        model: process.env.MODEL ??
+            fileConfig.model ??
+            "zai-org/glm-4.7-flash",
+        maxSteps: parseNumber(process.env.MAX_STEPS, fileConfig.maxSteps ?? 50),
+        maxTokens: parseNumber(process.env.MAX_TOKENS, fileConfig.maxTokens ?? 4096),
+        maxContextTokens: parseNumber(process.env.MAX_CONTEXT_TOKENS, fileConfig.maxContextTokens ?? 120_000),
+        workspaceRoot,
+        commandTimeoutMs: parseNumber(process.env.COMMAND_TIMEOUT_MS, fileConfig.commandTimeout ?? 30_000),
+        maxFileSizeBytes: parseNumber(process.env.MAX_FILE_SIZE_BYTES, fileConfig.maxFileSizeBytes ?? 1_000_000),
+        commandDenylist,
+        confirmDestructive: parseBoolean(process.env.CONFIRM_DESTRUCTIVE, fileConfig.confirmDestructive ?? false),
+        keepRecentMessages: parseNumber(process.env.KEEP_RECENT_MESSAGES, fileConfig.keepRecentMessages ?? 12),
+        loopDetectionWindow: parseNumber(process.env.LOOP_DETECTION_WINDOW, fileConfig.loopDetectionWindow ?? 6),
+        maxToolOutputChars: parseNumber(process.env.MAX_TOOL_OUTPUT_CHARS, fileConfig.maxToolOutputChars ?? 15_000),
+        openAiBaseUrl: rawBaseUrl,
+        ...(openAiApiKey !== undefined ? { openAiApiKey } : {}),
+    };
+}

package/dist/src/agent/types.js

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

package/dist/src/index.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { createInterface } from "node:readline/promises";
+import { CodingAgent } from "./agent/agent.js";
+import { formatConfigForDisplay, loadAgentConfig } from "./agent/config.js";
+import { computeFileHashes, getWorkspaceCacheDir, loadIndex, saveIndex, } from "./indexer/cache.js";
+import { buildProjectIndex } from "./indexer/project-index.js";
+import { createModelClient } from "./model/client.js";
+import { ToolRegistry } from "./tools/registry.js";
+function parseArgs(argv) {
+    const args = argv.slice(2);
+    const verbose = args.includes("--verbose") || args.includes("-v");
+    const filtered = args.filter((a) => a !== "--verbose" && a !== "-v");
+    const task = filtered.join(" ").trim();
+    return { verbose, task };
+}
+function printBanner() {
+    console.log("minicode");
+    console.log('Type your request, or "/exit" to quit.');
+}
+async function runInteractive(verbose, initialTask) {
+    const config = await loadAgentConfig();
+    const modelClient = createModelClient(config);
+    let projectIndex;
+    try {
+        const cacheDir = getWorkspaceCacheDir(config.workspaceRoot);
+        const fileHashes = await computeFileHashes(config.workspaceRoot);
+        const cached = await loadIndex(cacheDir, fileHashes);
+        if (cached) {
+            projectIndex = cached;
+        }
+        else {
+            projectIndex = await buildProjectIndex(config.workspaceRoot);
+            await saveIndex(projectIndex, cacheDir, fileHashes);
+        }
+    }
+    catch {
+        projectIndex = undefined;
+    }
+    const toolRegistry = ToolRegistry.createDefault(config, projectIndex);
+    const agent = new CodingAgent({
+        config,
+        modelClient,
+        toolRegistry,
+        verbose,
+        ...(projectIndex !== undefined ? { projectIndex } : {}),
+        onProgress: (msg) => console.error(`  ${msg}`),
+    });
+    printBanner();
+    console.log(`Workspace: ${config.workspaceRoot}`);
+    console.log(`Provider: ${config.modelProvider}`);
+    console.log(`Model: ${config.model}`);
+    if (verbose) {
+        console.log("Verbose: enabled");
+    }
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    let shuttingDown = false;
+    let turnAbortController = null;
+    process.on("SIGINT", () => {
+        if (turnAbortController) {
+            turnAbortController.abort();
+        }
+        else if (shuttingDown) {
+            process.exit(1);
+        }
+        else {
+            shuttingDown = true;
+            console.log("\nReceived interrupt. Exiting gracefully.");
+            rl.close();
+        }
+    });
+    let pendingInput = initialTask ?? null;
+    while (!shuttingDown) {
+        const input = pendingInput !== null
+            ? pendingInput
+            : await rl.question("\nYou> ");
+        if (pendingInput !== null) {
+            console.log(`\nYou> ${input}`);
+        }
+        pendingInput = null;
+        const trimmed = input.trim();
+        if (trimmed.length === 0) {
+            continue;
+        }
+        if (trimmed === "/exit" || trimmed === "exit" || trimmed === "quit") {
+            break;
+        }
+        if (trimmed === "/help") {
+            console.log('Commands: "/help", "/config", "/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");
+            continue;
+        }
+        turnAbortController = new AbortController();
+        try {
+            const { text, usage } = await agent.runTurn(trimmed, {
+                signal: turnAbortController.signal,
+            });
+            console.log(`\nAgent> ${text}`);
+            if (usage) {
+                console.error(`  tokens: ${usage.inputTokens} in, ${usage.outputTokens} out`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error && error.name === "AbortError"
+                ? "Cancelled"
+                : error instanceof Error
+                    ? error.message
+                    : "Unknown runtime failure";
+            console.error(`\nAgent error: ${message}`);
+        }
+        finally {
+            turnAbortController = null;
+        }
+    }
+    rl.close();
+}
+async function main() {
+    const { verbose, task } = parseArgs(process.argv);
+    const uiMode = process.env.CLI_UI_MODE ?? "ink";
+    if (uiMode !== "legacy" && process.stdin.isTTY) {
+        const { runInkCli } = await import("./ui/cli-ink.js");
+        await runInkCli(verbose, task.length > 0 ? task : undefined);
+        return;
+    }
+    await runInteractive(verbose, task.length > 0 ? task : undefined);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Fatal error: ${message}`);
+    process.exit(1);
+});

package/dist/src/indexer/cache.js

@@ -0,0 +1,121 @@
+import { createHash } from "node:crypto";
+import { readdir, readFile, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { MINICODE_HOME } from "../agent/config.js";
+import { createProjectIndex } from "./project-index.js";
+import { loadPlugins } from "./plugin-loader.js";
+const CACHE_FILENAME = "index.json";
+const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", "coverage"]);
+function hashWorkspacePath(workspaceRoot) {
+    const normalized = path.resolve(workspaceRoot);
+    return createHash("sha256").update(normalized, "utf8").digest("hex").slice(0, 32);
+}
+/**
+ * Return the cache directory for a workspace. Index files live under ~/.minicode/cache/<hash>/
+ * so caches are global and keyed by workspace path.
+ */
+export function getWorkspaceCacheDir(workspaceRoot) {
+    return path.join(MINICODE_HOME, "cache", hashWorkspacePath(workspaceRoot));
+}
+function hashContent(content) {
+    return createHash("sha256").update(content, "utf8").digest("hex");
+}
+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));
+            }
+        }
+    }
+}
+/**
+ * Compute content hashes for all source files in the workspace.
+ */
+export async function computeFileHashes(workspaceRoot) {
+    const root = path.resolve(workspaceRoot);
+    const sourceFiles = [];
+    await collectSourceFiles(root, root, sourceFiles);
+    const hashes = new Map();
+    for (const relPath of sourceFiles) {
+        const absPath = path.join(root, relPath);
+        try {
+            const content = await readFile(absPath, "utf8");
+            hashes.set(relPath, hashContent(content));
+        }
+        catch {
+            // skip unreadable files
+        }
+    }
+    return hashes;
+}
+function hashesMatch(cached, current) {
+    if (Object.keys(cached).length !== current.size)
+        return false;
+    for (const [relPath, hash] of current) {
+        if (cached[relPath] !== hash)
+            return false;
+    }
+    return true;
+}
+/**
+ * Save the project index to disk. Call after buildProjectIndex.
+ */
+export async function saveIndex(index, cacheDir, fileHashes) {
+    const payload = {
+        version: 1,
+        fileHashes: Object.fromEntries(fileHashes),
+        symbols: [...index.symbols.entries()],
+        files: [...index.files.entries()],
+        dependencyEdges: [...index.dependencyEdges],
+        projectFiles: [...index.projectFiles.entries()],
+        workspaceRoot: index.workspaceRoot,
+    };
+    await mkdir(cacheDir, { recursive: true });
+    const cachePath = path.join(cacheDir, CACHE_FILENAME);
+    await writeFile(cachePath, JSON.stringify(payload, null, 0), "utf8");
+}
+/**
+ * Load the project index from cache if all file hashes match.
+ * Returns null if cache is missing, invalid, or any file has changed.
+ */
+export async function loadIndex(cacheDir, fileHashes) {
+    const cachePath = path.join(cacheDir, CACHE_FILENAME);
+    let raw;
+    try {
+        raw = await readFile(cachePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    let payload;
+    try {
+        payload = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (payload.version !== 1 || !payload.fileHashes)
+        return null;
+    if (!hashesMatch(payload.fileHashes, fileHashes))
+        return null;
+    const symbols = new Map(payload.symbols);
+    const files = new Map(payload.files);
+    const dependencyEdges = payload.dependencyEdges ?? [];
+    const projectFiles = new Map(payload.projectFiles);
+    const workspaceRoot = payload.workspaceRoot ?? "";
+    const plugins = await loadPlugins(workspaceRoot);
+    return createProjectIndexFromCache(symbols, files, dependencyEdges, plugins, projectFiles, workspaceRoot);
+}
+function createProjectIndexFromCache(symbols, files, dependencyEdges, plugins, projectFiles, workspaceRoot) {
+    return createProjectIndex(symbols, files, dependencyEdges, plugins, projectFiles, workspaceRoot);
+}

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

@@ -0,0 +1,92 @@
+const DEFAULT_TOKEN_BUDGET = 1500;
+const APPROX_CHARS_PER_TOKEN = 4;
+function estimateTokens(text) {
+    return Math.ceil(text.length / APPROX_CHARS_PER_TOKEN);
+}
+function formatSymbol(symbol, indent, isMethod) {
+    if (isMethod) {
+        return `${indent}  ${symbol.signature}`;
+    }
+    return `${indent}${symbol.kind} ${symbol.qualifiedName}\n${indent}  ${symbol.signature}`;
+}
+function isEntryPointFile(filePath) {
+    return filePath === "src/index.ts" || filePath.endsWith("/index.ts");
+}
+function createSymbolRanker(edges) {
+    const refCount = new Map();
+    for (const e of edges) {
+        refCount.set(e.to, (refCount.get(e.to) ?? 0) + 1);
+    }
+    return (a, b) => {
+        if (a.exported !== b.exported)
+            return a.exported ? -1 : 1;
+        const refA = refCount.get(a.qualifiedName) ?? 0;
+        const refB = refCount.get(b.qualifiedName) ?? 0;
+        if (refA !== refB)
+            return refB - refA;
+        const entryA = isEntryPointFile(a.filePath) ? 1 : 0;
+        const entryB = isEntryPointFile(b.filePath) ? 1 : 0;
+        return entryB - entryA;
+    };
+}
+/**
+ * Generate a compact code map from symbols grouped by file.
+ * Ranks symbols by: exported > high reference count > entry points.
+ * When over budget, truncates with a footer.
+ */
+export function generateCodeMap(symbolsByFile, tokenBudget = DEFAULT_TOKEN_BUDGET, dependencyEdges) {
+    const totalCount = [...symbolsByFile.values()].reduce((sum, syms) => sum + syms.length, 0);
+    const lines = ["# Project Code Map", ""];
+    const rank = dependencyEdges
+        ? createSymbolRanker(dependencyEdges)
+        : (a, b) => (a.exported === b.exported ? 0 : a.exported ? -1 : 1);
+    let totalTokens = estimateTokens(lines.join("\n"));
+    let truncatedSymbols = 0;
+    let shownCount = 0;
+    const filesWithTruncation = new Set();
+    const sortedFiles = [...symbolsByFile.keys()].sort();
+    for (const filePath of sortedFiles) {
+        const symbols = symbolsByFile.get(filePath);
+        if (!symbols?.length)
+            continue;
+        const sorted = [...symbols].sort(rank);
+        let currentClass = null;
+        const fileLines = [`  ${filePath}`];
+        for (const symbol of sorted) {
+            const isMethod = symbol.kind === "method";
+            const indent = isMethod && currentClass ? "    " : "  "; // methods nest under class
+            if (symbol.kind === "class") {
+                currentClass = symbol.name;
+            }
+            else if (!isMethod) {
+                currentClass = null;
+            }
+            const block = formatSymbol(symbol, indent, isMethod);
+            const blockTokens = estimateTokens(block);
+            if (totalTokens + blockTokens > tokenBudget) {
+                truncatedSymbols += 1;
+                filesWithTruncation.add(filePath);
+                continue;
+            }
+            fileLines.push(block);
+            totalTokens += blockTokens;
+            shownCount += 1;
+        }
+        if (fileLines.length > 1) {
+            lines.push(...fileLines, "");
+        }
+        else {
+            truncatedSymbols += symbols.length;
+            filesWithTruncation.add(filePath);
+        }
+    }
+    if (truncatedSymbols > 0) {
+        const fileCount = filesWithTruncation.size;
+        lines.push(`... and ${truncatedSymbols} more symbols in ${fileCount} file${fileCount === 1 ? "" : "s"}`);
+    }
+    return {
+        text: lines.join("\n").trim(),
+        shownCount,
+        totalCount,
+    };
+}

package/dist/src/indexer/plugin-loader.js

@@ -0,0 +1,78 @@
+import { typescriptPlugin } from "./plugins/typescript.js";
+/**
+ * Load all available language plugins.
+ * Built-in: TypeScript.
+ * Also loads: npm packages (minicode-plugin-*), local plugins (.minicode/plugins/).
+ */
+export async function loadPlugins(workspaceRoot) {
+    const plugins = [];
+    plugins.push(typescriptPlugin);
+    await loadNpmPlugins(workspaceRoot, plugins);
+    await loadLocalPlugins(workspaceRoot, plugins);
+    return plugins;
+}
+async function loadNpmPlugins(workspaceRoot, plugins) {
+    const path = await import("node:path");
+    const { readFile } = await import("node:fs/promises");
+    const pkgPath = path.join(workspaceRoot, "package.json");
+    let pkg;
+    try {
+        const raw = await readFile(pkgPath, "utf8");
+        pkg = JSON.parse(raw);
+    }
+    catch {
+        return;
+    }
+    const deps = {
+        ...(pkg.dependencies ?? {}),
+        ...(pkg.devDependencies ?? {}),
+    };
+    const pluginPkgs = Object.keys(deps).filter((k) => k.startsWith("minicode-plugin-"));
+    for (const pkgName of pluginPkgs) {
+        try {
+            const mod = await import(pkgName);
+            const plugin = mod.default ?? mod.plugin ?? mod;
+            if (plugin && typeof plugin.canIndex === "function") {
+                plugins.push(plugin);
+            }
+        }
+        catch {
+            // skip failed plugins
+        }
+    }
+}
+async function loadLocalPlugins(workspaceRoot, plugins) {
+    const path = await import("node:path");
+    const { pathToFileURL } = await import("node:url");
+    const { readdir } = await import("node:fs/promises");
+    const pluginDir = path.join(workspaceRoot, ".minicode", "plugins");
+    let entries;
+    try {
+        entries = await readdir(pluginDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".js"))
+            continue;
+        const pluginPath = path.join(pluginDir, entry.name);
+        const pluginUrl = pathToFileURL(pluginPath).href;
+        try {
+            const mod = await import(pluginUrl);
+            const plugin = mod.default ?? mod.plugin ?? mod;
+            if (plugin && typeof plugin.canIndex === "function") {
+                plugins.push(plugin);
+            }
+        }
+        catch {
+            // skip failed plugins
+        }
+    }
+}
+/**
+ * Return the first plugin that can index the given file path.
+ */
+export function getPluginForFile(filePath, plugins) {
+    return plugins.find((p) => p.canIndex(filePath));
+}