@sean.holung/minicode 0.3.9 → 0.3.10

package/README.md

@@ -77,6 +77,14 @@ minicode --oneshot --json "Summarize recent changes"
 minicode --oneshot --out result.txt "Generate release notes"
 ```
 
+Run the benchmark-friendly non-interactive entrypoint for external eval harnesses:
+
+```bash
+minicode benchmark run --prompt-file prompt.txt --out result.json
+```
+
+See [docs/BENCHMARKING.md](docs/BENCHMARKING.md) for the reproducible benchmark config/env flow.
+
 **Requirements:** Node.js 22+, LM Studio (or any OpenAI-compatible local server), `rg` in PATH (recommended). Set `MODEL` to match the model name in LM Studio.
 
 ### Install from source
@@ -211,6 +219,7 @@ Nothing is written inside your workspace; config and cache live under `~/.minico
 | `ENABLE_FILE_READ_DEDUP` | No             | `true`                     | Reuses earlier `read_file` results within a turn when the same file slice is still in context                                        |
 | `ENABLE_ADAPTIVE_KEEP_RECENT` | No        | `true`                     | Scales `keepRecentMessages` down as context fills so trimming gets more aggressive when needed                                       |
 | `ENABLE_TOOL_OUTPUT_TRUNCATION` | No      | `true`                     | Enables content-aware truncation strategies for tool output instead of simple head-only clipping                                     |
+| `ENABLE_DYNAMIC_PROMPT` | No             | `false`                    | Rebuilds the system prompt and focused code map every agent step. Leave disabled for a more stable prompt prefix and better KV-cache reuse. |
 | `COMPACTION_THRESHOLD`  | No              | `0.8`                      | Context fullness ratio (0–1) at which auto-compaction triggers                                                                        |
 | `COMPACTION_MODEL`      | No              | none                       | Model for LLM-based compaction summaries. When set, `/compact` and auto-compaction use this model instead of mechanical truncation. Use a small, fast model (e.g. your local model). |
 | `REASONING_EFFORT`      | No              | unset                      | Reasoning level for providers that support it. Valid values: `xhigh`, `high`, `medium`, `low`, `minimal`, `none`                   |

package/dist/scripts/run-ts-bench-smoke.js

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+import { chmod, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { parse as parseDotenv } from "dotenv";
+import { applyTsBenchMinicodeAdapter } from "./ts-bench-adapter.js";
+function readFlagValue(args, index, flagName) {
+    const next = args[index + 1];
+    if (!next || next.startsWith("-")) {
+        throw new Error(`${flagName} requires a value.`);
+    }
+    return { value: next, nextIndex: index + 1 };
+}
+export function parseTsBenchSmokeArgs(argv) {
+    let tsBenchPath;
+    let exercise = "acronym";
+    let provider = "openrouter";
+    let model;
+    let envFile;
+    let skipBuild = false;
+    let installDeps = false;
+    let dryRun = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined) {
+            continue;
+        }
+        if (arg === "--skip-build") {
+            skipBuild = true;
+            continue;
+        }
+        if (arg === "--install-deps") {
+            installDeps = true;
+            continue;
+        }
+        if (arg === "--dry-run") {
+            dryRun = true;
+            continue;
+        }
+        if (arg === "--ts-bench-path") {
+            const parsed = readFlagValue(argv, i, "--ts-bench-path");
+            tsBenchPath = parsed.value;
+            i = parsed.nextIndex;
+            continue;
+        }
+        if (arg.startsWith("--ts-bench-path=")) {
+            tsBenchPath = arg.slice("--ts-bench-path=".length).trim();
+            continue;
+        }
+        if (arg === "--exercise") {
+            const parsed = readFlagValue(argv, i, "--exercise");
+            exercise = parsed.value;
+            i = parsed.nextIndex;
+            continue;
+        }
+        if (arg.startsWith("--exercise=")) {
+            exercise = arg.slice("--exercise=".length).trim();
+            continue;
+        }
+        if (arg === "--provider") {
+            const parsed = readFlagValue(argv, i, "--provider");
+            const value = parsed.value;
+            if (value !== "openrouter" && value !== "openai" && value !== "anthropic") {
+                throw new Error(`Unsupported --provider ${parsed.value}. Use openrouter, openai, or anthropic.`);
+            }
+            provider = value;
+            i = parsed.nextIndex;
+            continue;
+        }
+        if (arg.startsWith("--provider=")) {
+            const value = arg.slice("--provider=".length).trim();
+            if (value !== "openrouter" && value !== "openai" && value !== "anthropic") {
+                throw new Error(`Unsupported --provider ${value}. Use openrouter, openai, or anthropic.`);
+            }
+            provider = value;
+            continue;
+        }
+        if (arg === "--model") {
+            const parsed = readFlagValue(argv, i, "--model");
+            model = parsed.value;
+            i = parsed.nextIndex;
+            continue;
+        }
+        if (arg.startsWith("--model=")) {
+            model = arg.slice("--model=".length).trim();
+            continue;
+        }
+        if (arg === "--env-file") {
+            const parsed = readFlagValue(argv, i, "--env-file");
+            envFile = parsed.value;
+            i = parsed.nextIndex;
+            continue;
+        }
+        if (arg.startsWith("--env-file=")) {
+            envFile = arg.slice("--env-file=".length).trim();
+            continue;
+        }
+    }
+    if (!tsBenchPath) {
+        throw new Error("--ts-bench-path is required.");
+    }
+    if (!model) {
+        throw new Error("--model is required.");
+    }
+    return {
+        tsBenchPath,
+        exercise,
+        provider,
+        model,
+        ...(envFile ? { envFile } : {}),
+        skipBuild,
+        installDeps,
+        dryRun,
+    };
+}
+async function runCommand(command, args, options) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd: options.cwd,
+            env: options.env,
+            stdio: "inherit",
+        });
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`${command} ${args.join(" ")} exited with code ${code ?? "unknown"}.`));
+            }
+        });
+    });
+}
+function buildStablePath(extraDirs = []) {
+    const segments = (process.env.PATH ?? "")
+        .split(path.delimiter)
+        .filter((segment) => segment.length > 0 && !segment.startsWith("/mnt/"));
+    const ordered = [
+        ...extraDirs,
+        path.join(homedir(), ".bun", "bin"),
+        path.dirname(process.execPath),
+        ...segments,
+        "/usr/local/sbin",
+        "/usr/local/bin",
+        "/usr/sbin",
+        "/usr/bin",
+        "/sbin",
+        "/bin",
+    ];
+    const seen = new Set();
+    const deduped = [];
+    for (const segment of ordered) {
+        if (segment.length === 0 || seen.has(segment)) {
+            continue;
+        }
+        seen.add(segment);
+        deduped.push(segment);
+    }
+    return deduped.join(path.delimiter);
+}
+async function ensureFileExists(filePath, label) {
+    try {
+        const details = await stat(filePath);
+        if (!details.isFile()) {
+            throw new Error(`${label} is not a file: ${filePath}`);
+        }
+    }
+    catch {
+        throw new Error(`${label} was not found at ${filePath}`);
+    }
+}
+export async function createLocalMinicodeShim(tsBenchRoot, repoRoot) {
+    const shimDir = path.join(tsBenchRoot, ".minicode-local-bin");
+    const shimPath = path.join(shimDir, "minicode");
+    const entryPath = path.join(repoRoot, "dist", "src", "index.js");
+    await ensureFileExists(entryPath, "Built minicode entrypoint");
+    await mkdir(shimDir, { recursive: true });
+    const script = [
+        "#!/usr/bin/env bash",
+        "set -euo pipefail",
+        `exec "${process.execPath}" "${entryPath}" "$@"`,
+        "",
+    ].join("\n");
+    await writeFile(shimPath, script, "utf8");
+    await chmod(shimPath, 0o755);
+    return shimDir;
+}
+function buildSmokeCommand(args) {
+    return [
+        "src/index.ts",
+        "--agent",
+        "minicode",
+        "--version",
+        "local-dev",
+        "--dataset",
+        "v1",
+        "--exercise",
+        args.exercise,
+        "--provider",
+        args.provider,
+        "--model",
+        args.model,
+        "--output-format",
+        "json",
+    ];
+}
+async function main() {
+    const args = parseTsBenchSmokeArgs(process.argv.slice(2));
+    const repoRoot = process.cwd();
+    const tsBenchRoot = path.resolve(repoRoot, args.tsBenchPath);
+    const benchmarkConfig = path.join(repoRoot, "benchmarks", "benchmark.config.json");
+    const home = homedir();
+    const baseEnv = {
+        ...process.env,
+        HOME: process.env.HOME ?? home,
+        USERPROFILE: home,
+        XDG_CACHE_HOME: process.env.XDG_CACHE_HOME ?? path.join(home, ".cache"),
+        COREPACK_HOME: process.env.COREPACK_HOME ?? path.join(home, ".cache", "node", "corepack"),
+        LOCALAPPDATA: path.join(home, ".local", "share"),
+        APPDATA: path.join(home, ".config"),
+        PATH: buildStablePath(),
+    };
+    if (!args.skipBuild) {
+        await runCommand("npm", ["run", "build"], { cwd: repoRoot, env: baseEnv });
+    }
+    await applyTsBenchMinicodeAdapter(tsBenchRoot);
+    const shimDir = await createLocalMinicodeShim(tsBenchRoot, repoRoot);
+    const env = {
+        ...baseEnv,
+        PATH: buildStablePath([shimDir]),
+        MINICODE_BENCHMARK_CONFIG: benchmarkConfig,
+    };
+    if (args.envFile) {
+        const envFilePath = path.resolve(repoRoot, args.envFile);
+        const parsed = parseDotenv(await readFile(envFilePath, "utf8"));
+        for (const [key, value] of Object.entries(parsed)) {
+            if (env[key] === undefined) {
+                env[key] = value;
+            }
+        }
+        env.MINICODE_BENCHMARK_ENV_FILE = envFilePath;
+    }
+    if (args.dryRun) {
+        console.log(`ts-bench path: ${tsBenchRoot}`);
+        console.log(`repo root: ${repoRoot}`);
+        console.log(`shim dir: ${shimDir}`);
+        console.log(`command: bun ${buildSmokeCommand(args).join(" ")}`);
+        return;
+    }
+    if (args.installDeps) {
+        await runCommand("bun", ["install"], { cwd: tsBenchRoot, env });
+        await runCommand("git", ["submodule", "update", "--init", "repos/exercism-typescript"], {
+            cwd: tsBenchRoot,
+            env,
+        });
+    }
+    await runCommand("bun", buildSmokeCommand(args), { cwd: tsBenchRoot, env });
+}
+const invokedPath = process.argv[1];
+if (invokedPath && path.resolve(invokedPath) === path.resolve(fileURLToPath(import.meta.url))) {
+    main().catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    });
+}

package/dist/scripts/ts-bench-adapter.js

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+const MINICODE_REGISTRY_ENTRY = `
+
+    minicode: {
+        defaultProvider: 'openrouter' as ProviderType,
+        install: { method: 'npm', bin: 'minicode', package: '@sean.holung/minicode' },
+        getEnv(config: AgentConfig): Record<string, string> {
+            const provider = config.provider ?? 'openrouter';
+            const env: Record<string, string> = {
+                CONFIRM_DESTRUCTIVE: 'false'
+            };
+
+            const optionalBenchmarkEnv = [
+                ['MINICODE_BENCHMARK_MAX_STEPS', 'MAX_STEPS'],
+                ['MINICODE_BENCHMARK_MAX_CONTEXT_TOKENS', 'MAX_CONTEXT_TOKENS'],
+                ['MINICODE_BENCHMARK_COMMAND_TIMEOUT_MS', 'COMMAND_TIMEOUT_MS'],
+                ['MINICODE_BENCHMARK_MODEL_TIMEOUT_SECONDS', 'MODEL_TIMEOUT_SECONDS'],
+                ['MINICODE_BENCHMARK_MAX_TOOL_OUTPUT_CHARS', 'MAX_TOOL_OUTPUT_CHARS'],
+                ['MINICODE_BENCHMARK_REASONING_EFFORT', 'REASONING_EFFORT'],
+                ['MINICODE_BENCHMARK_ENABLE_DYNAMIC_PROMPT', 'ENABLE_DYNAMIC_PROMPT'],
+                ['MINICODE_BENCHMARK_KEEP_RECENT_MESSAGES', 'KEEP_RECENT_MESSAGES']
+            ] as const;
+
+            for (const [sourceKey, targetKey] of optionalBenchmarkEnv) {
+                const value = process.env[sourceKey];
+                if (value) {
+                    env[targetKey] = value;
+                }
+            }
+
+            switch (provider) {
+                case 'openrouter':
+                    env.OPENROUTER_API_KEY = requireEnv('OPENROUTER_API_KEY', 'Missing OPENROUTER_API_KEY for minicode (OpenRouter) provider');
+                    break;
+                case 'openai':
+                    env.OPENAI_API_KEY = requireEnv('OPENAI_API_KEY', 'Missing OPENAI_API_KEY for minicode (OpenAI) provider');
+                    break;
+                case 'anthropic':
+                    env.ANTHROPIC_API_KEY = requireEnv('ANTHROPIC_API_KEY', 'Missing ANTHROPIC_API_KEY for minicode (Anthropic) provider');
+                    break;
+                default:
+                    throw new Error(\`Unsupported provider for minicode: \${provider}. Use openrouter, openai, or anthropic.\`);
+            }
+
+            return env;
+        },
+        buildArgs(config: AgentConfig, instructions: string): string[] {
+            const provider = config.provider ?? 'openrouter';
+            const exerciseId = (config.exercise ?? 'benchmark').replace(/[^A-Za-z0-9._-]+/g, '-');
+            const args = [
+                'bash',
+                config.agentScriptPath,
+                'minicode',
+                'benchmark',
+                'run',
+                '--workspace-root',
+                '.',
+                '--out',
+                \`minicode-\${exerciseId}.json\`,
+                '--diff-out',
+                \`minicode-\${exerciseId}.patch\`
+            ];
+
+            const benchmarkConfig = process.env.MINICODE_BENCHMARK_CONFIG;
+            if (benchmarkConfig) {
+                args.push('--config', benchmarkConfig);
+            }
+
+            const benchmarkEnvFile = process.env.MINICODE_BENCHMARK_ENV_FILE;
+            if (benchmarkEnvFile) {
+                args.push('--env-file', benchmarkEnvFile);
+            }
+
+            switch (provider) {
+                case 'anthropic':
+                    args.push('--provider', 'anthropic');
+                    break;
+                case 'openai':
+                    args.push(
+                        '--provider',
+                        'openai-compatible',
+                        '--base-url',
+                        process.env.MINICODE_OPENAI_BASE_URL || 'https://api.openai.com/v1'
+                    );
+                    break;
+                case 'openrouter':
+                    args.push(
+                        '--provider',
+                        'openai-compatible',
+                        '--base-url',
+                        process.env.MINICODE_OPENROUTER_BASE_URL || 'https://openrouter.ai/api/v1'
+                    );
+                    break;
+                default:
+                    throw new Error(\`Unsupported provider for minicode: \${provider}. Use openrouter, openai, or anthropic.\`);
+            }
+
+            if (config.model) {
+                args.push('--model', config.model);
+            }
+
+            args.push(instructions);
+            return args;
+        }
+    }`;
+const MINICODE_AGENTS_JSON_ENTRY = '  "minicode":  { "bin": "minicode",     "method": "npm",      "package": "@sean.holung/minicode" },';
+function insertBeforeMarker(source, marker, insertion, description) {
+    const index = source.indexOf(marker);
+    if (index === -1) {
+        throw new Error(`Could not find ${description} marker.`);
+    }
+    return `${source.slice(0, index)}${insertion}${source.slice(index)}`;
+}
+function insertBeforeNthOccurrence(source, marker, occurrence, insertion, description) {
+    let searchIndex = 0;
+    let matchIndex = -1;
+    for (let count = 0; count < occurrence; count += 1) {
+        matchIndex = source.indexOf(marker, searchIndex);
+        if (matchIndex === -1) {
+            throw new Error(`Could not find ${description} occurrence ${occurrence}.`);
+        }
+        searchIndex = matchIndex + marker.length;
+    }
+    return `${source.slice(0, matchIndex)}${insertion}${source.slice(matchIndex)}`;
+}
+export function injectMinicodeRegistry(source) {
+    if (source.includes("minicode: {")) {
+        return source;
+    }
+    return insertBeforeMarker(source, "\n} satisfies Record<string, AgentDefinition>;", `,${MINICODE_REGISTRY_ENTRY}\n`, "registry closing");
+}
+export function injectMinicodeAgentsJson(source) {
+    if (source.includes('"minicode"')) {
+        return source;
+    }
+    if (source.includes('\n  "kimi":')) {
+        return source.replace('\n  "kimi":', `\n${MINICODE_AGENTS_JSON_ENTRY}\n\n  "kimi":`);
+    }
+    return insertBeforeMarker(source, "\n}", `\n${MINICODE_AGENTS_JSON_ENTRY}\n`, "agents.json closing");
+}
+export function injectMinicodeSiteDisplayName(source) {
+    if (source.includes("case 'minicode':")) {
+        return source;
+    }
+    if (source.includes("case 'opencode':")) {
+        return source.replace("        case 'opencode': return 'OpenCode';", "        case 'minicode': return 'minicode';\n        case 'opencode': return 'OpenCode';");
+    }
+    const next = source.replace("        default: return slug.charAt(0).toUpperCase() + slug.slice(1).toLowerCase();", "        case 'minicode': return 'minicode';\n        default: return slug.charAt(0).toUpperCase() + slug.slice(1).toLowerCase();");
+    if (next === source) {
+        throw new Error("Could not find agent display-name switch marker.");
+    }
+    return next;
+}
+export function injectMinicodeVersionDetector(source) {
+    if (source.includes("return ['minicode', '--version'];")
+        && source.includes("case 'minicode':\n                return this.extractGenericVersion(cleanOutput);")) {
+        return source;
+    }
+    let next = source;
+    next = insertBeforeNthOccurrence(next, "            case 'opencode':", 1, "            case 'minicode':\n                return ['minicode', '--version'];\n", "version detector command switch");
+    next = insertBeforeNthOccurrence(next, "            case 'opencode':", 2, "            case 'minicode':\n                return this.extractGenericVersion(cleanOutput);\n", "version detector parse switch");
+    return next;
+}
+export function injectMinicodeLeaderboardName(source) {
+    if (source.includes("case 'minicode': return 'minicode';")) {
+        return source;
+    }
+    const next = source.replace(/(\s*case 'kimi': return 'Kimi Code CLI';)/, "            case 'minicode': return 'minicode';\n$1");
+    if (next !== source) {
+        return next;
+    }
+    const fallback = source.replace(/(\s*default: return agent\.charAt\(0\)\.toUpperCase\(\) \+ agent\.slice\(1\)\.toLowerCase\(\);)/, "            case 'minicode': return 'minicode';\n$1");
+    if (fallback === source) {
+        throw new Error("Could not find leaderboard agent-name switch marker.");
+    }
+    return fallback;
+}
+export async function applyTsBenchMinicodeAdapter(tsBenchRoot) {
+    const files = [
+        {
+            path: path.join(tsBenchRoot, "src", "agents", "registry.ts"),
+            transform: injectMinicodeRegistry,
+        },
+        {
+            path: path.join(tsBenchRoot, "scripts", "agents.json"),
+            transform: injectMinicodeAgentsJson,
+        },
+        {
+            path: path.join(tsBenchRoot, "src", "site", "shared", "format.ts"),
+            transform: injectMinicodeSiteDisplayName,
+        },
+        {
+            path: path.join(tsBenchRoot, "src", "utils", "version-detector.ts"),
+            transform: injectMinicodeVersionDetector,
+        },
+        {
+            path: path.join(tsBenchRoot, "src", "utils", "leaderboard-generator.ts"),
+            transform: injectMinicodeLeaderboardName,
+        },
+    ];
+    for (const file of files) {
+        const current = await readFile(file.path, "utf8");
+        const updated = file.transform(current);
+        if (updated !== current) {
+            await writeFile(file.path, updated, "utf8");
+        }
+    }
+}
+function parseAdapterCliArgs(argv) {
+    let tsBenchPath;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined) {
+            continue;
+        }
+        if (arg === "--ts-bench-path") {
+            const next = argv[i + 1];
+            if (!next || next.startsWith("-")) {
+                throw new Error("--ts-bench-path requires a value.");
+            }
+            tsBenchPath = next;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--ts-bench-path=")) {
+            tsBenchPath = arg.slice("--ts-bench-path=".length).trim();
+            continue;
+        }
+    }
+    if (!tsBenchPath) {
+        throw new Error("Usage: node --import tsx scripts/ts-bench-adapter.ts --ts-bench-path /path/to/ts-bench");
+    }
+    return { tsBenchPath };
+}
+async function main() {
+    const args = parseAdapterCliArgs(process.argv.slice(2));
+    const tsBenchRoot = path.resolve(process.cwd(), args.tsBenchPath);
+    await applyTsBenchMinicodeAdapter(tsBenchRoot);
+    console.log(`Applied minicode adapter to ${tsBenchRoot}`);
+}
+const invokedPath = process.argv[1];
+if (invokedPath && path.resolve(invokedPath) === path.resolve(fileURLToPath(import.meta.url))) {
+    main().catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    });
+}

package/dist/src/agent/config.js

@@ -33,7 +33,7 @@ export function formatConfigForDisplay(config) {
         "compactionThreshold: " + (config.compactionThreshold ?? "(disabled)"),
         "compactionModel: " + (config.compactionModel ?? "(disabled — using mechanical compaction)"),
         "reasoningEffort: " + (config.reasoningEffort ?? "(unset — no reasoning parameters sent)"),
-        "enableDynamicPrompt: " + (config.enableDynamicPrompt ?? true),
+        "enableDynamicPrompt: " + (config.enableDynamicPrompt ?? false),
     ];
     return lines.join("\n");
 }
@@ -275,7 +275,7 @@ export async function loadAgentConfig(cwd = process.cwd(), options = {}) {
         ...(env.COMPACTION_MODEL
             ? { compactionModel: env.COMPACTION_MODEL }
             : {}),
-        enableDynamicPrompt: parseBoolean(env.ENABLE_DYNAMIC_PROMPT, true),
+        enableDynamicPrompt: parseBoolean(env.ENABLE_DYNAMIC_PROMPT, false),
         ...(() => {
             const effort = parseReasoningEffort(env.REASONING_EFFORT);
             return effort ? { reasoningEffort: effort } : {};

package/dist/src/auto-allow.js

@@ -0,0 +1,28 @@
+export const AUTO_ALLOW_MODES = [
+    "none",
+    "writes",
+    "commands",
+    "all",
+];
+const WRITE_TOOLS = new Set(["write_file", "edit_file"]);
+const COMMAND_TOOLS = new Set(["run_command"]);
+/** Tools whose execution is gated by the permission prompt. */
+export function isGatedTool(toolName) {
+    return WRITE_TOOLS.has(toolName) || COMMAND_TOOLS.has(toolName);
+}
+/** True when `mode` would auto-allow `toolName` without prompting. */
+export function shouldAutoAllow(mode, toolName) {
+    if (mode === "all")
+        return isGatedTool(toolName);
+    if (mode === "writes")
+        return WRITE_TOOLS.has(toolName);
+    if (mode === "commands")
+        return COMMAND_TOOLS.has(toolName);
+    return false;
+}
+export function isAutoAllowMode(value) {
+    return (value === "none" ||
+        value === "writes" ||
+        value === "commands" ||
+        value === "all");
+}