@sean.holung/minicode 0.3.1 → 0.3.3

package/dist/src/benchmark/evaluator.js

@@ -0,0 +1,79 @@
+/**
+ * Evaluates a benchmark trace against a task's rubric.
+ */
+/**
+ * Evaluate a benchmark trace against the task rubric.
+ */
+export function evaluate(taskId, rubric, trace) {
+    const checks = [];
+    // 1. Check expected output patterns
+    if (rubric.expectedOutputPatterns) {
+        for (const pattern of rubric.expectedOutputPatterns) {
+            const regex = new RegExp(pattern, "i");
+            checks.push({
+                name: `output matches /${pattern}/i`,
+                passed: regex.test(trace.response),
+                detail: regex.test(trace.response)
+                    ? undefined
+                    : `Pattern not found in response`,
+            });
+        }
+    }
+    // 2. Check expected files read
+    if (rubric.expectedFilesRead) {
+        for (const expectedFile of rubric.expectedFilesRead) {
+            const found = trace.filesRead.some((f) => f === expectedFile || f.endsWith(expectedFile));
+            checks.push({
+                name: `read file ${expectedFile}`,
+                passed: found,
+                detail: found ? undefined : `File was not read during the run`,
+            });
+        }
+    }
+    // 3. Check expected symbols queried
+    if (rubric.expectedSymbols) {
+        for (const sym of rubric.expectedSymbols) {
+            const found = trace.symbolsQueried.some((s) => s === sym || s.includes(sym));
+            checks.push({
+                name: `queried symbol ${sym}`,
+                passed: found,
+                detail: found ? undefined : `Symbol was not queried`,
+            });
+        }
+    }
+    // 4. Check forbidden patterns
+    if (rubric.forbiddenPatterns) {
+        for (const pattern of rubric.forbiddenPatterns) {
+            const regex = new RegExp(pattern, "i");
+            const absent = !regex.test(trace.response);
+            checks.push({
+                name: `output does NOT match /${pattern}/i`,
+                passed: absent,
+                detail: absent ? undefined : `Forbidden pattern found in response`,
+            });
+        }
+    }
+    // 5. Efficiency metrics
+    const efficiency = computeEfficiency(rubric, trace);
+    const allChecksPassed = checks.every((c) => c.passed);
+    return {
+        taskId,
+        passed: allChecksPassed,
+        checks,
+        efficiency,
+    };
+}
+function computeEfficiency(rubric, trace) {
+    const toolCallCount = trace.toolCalls.length;
+    const totalTokens = trace.usage.totalTokens;
+    const withinToolBudget = rubric.maxToolCalls == null || toolCallCount <= rubric.maxToolCalls;
+    const withinTokenBudget = rubric.maxTotalTokens == null || totalTokens <= rubric.maxTotalTokens;
+    return {
+        toolCallCount,
+        totalTokens,
+        durationMs: trace.durationMs,
+        filesReadCount: trace.filesRead.length,
+        symbolsQueriedCount: trace.symbolsQueried.length,
+        withinBudget: withinToolBudget && withinTokenBudget,
+    };
+}

package/dist/src/benchmark/index.js

@@ -0,0 +1,4 @@
+export { loadBenchmarkTask, loadBenchmarkTasks } from "./task-loader.js";
+export { evaluate } from "./evaluator.js";
+export { runBenchmarkTask, runBenchmarkSuite, } from "./runner.js";
+export { buildReport, buildReportFromEvaluations, formatReport, compareReports, } from "./reporter.js";

package/dist/src/benchmark/reporter.js

@@ -0,0 +1,177 @@
+/**
+ * Generates benchmark reports from evaluation results and traces.
+ */
+import { evaluate } from "./evaluator.js";
+/**
+ * Build a full benchmark report from tasks and their traces.
+ */
+export function buildReport(tasks, traces, variant, model) {
+    const taskMap = new Map(tasks.map((t) => [t.id, t]));
+    const results = traces.map((trace) => {
+        const task = taskMap.get(trace.taskId);
+        if (!task) {
+            throw new Error(`No task definition found for trace: ${trace.taskId}`);
+        }
+        const evaluation = evaluate(task.id, task.rubric, trace);
+        return {
+            taskId: task.id,
+            category: task.category,
+            evaluation,
+            trace,
+        };
+    });
+    return {
+        variant,
+        model,
+        generatedAt: new Date().toISOString(),
+        results,
+        summary: computeSummary(results),
+    };
+}
+/**
+ * Build a report from pre-computed evaluations and traces.
+ */
+export function buildReportFromEvaluations(evaluations, traces, tasks, variant, model) {
+    const taskMap = new Map(tasks.map((t) => [t.id, t]));
+    const evalMap = new Map(evaluations.map((e) => [e.taskId, e]));
+    const results = traces.map((trace) => {
+        const task = taskMap.get(trace.taskId);
+        const evaluation = evalMap.get(trace.taskId);
+        if (!task || !evaluation) {
+            throw new Error(`Missing task or evaluation for: ${trace.taskId}`);
+        }
+        return {
+            taskId: task.id,
+            category: task.category,
+            evaluation,
+            trace,
+        };
+    });
+    return {
+        variant,
+        model,
+        generatedAt: new Date().toISOString(),
+        results,
+        summary: computeSummary(results),
+    };
+}
+function computeSummary(results) {
+    const total = results.length;
+    const passed = results.filter((r) => r.evaluation.passed).length;
+    // By category
+    const byCategory = {};
+    for (const r of results) {
+        const cat = r.category;
+        if (!byCategory[cat]) {
+            byCategory[cat] = { total: 0, passed: 0, passRate: 0 };
+        }
+        byCategory[cat].total += 1;
+        if (r.evaluation.passed)
+            byCategory[cat].passed += 1;
+    }
+    for (const entry of Object.values(byCategory)) {
+        entry.passRate = entry.total > 0 ? entry.passed / entry.total : 0;
+    }
+    // Averages
+    const avgToolCalls = total > 0
+        ? results.reduce((sum, r) => sum + r.evaluation.efficiency.toolCallCount, 0) / total
+        : 0;
+    const avgTotalTokens = total > 0
+        ? results.reduce((sum, r) => sum + r.evaluation.efficiency.totalTokens, 0) / total
+        : 0;
+    const avgDurationMs = total > 0
+        ? results.reduce((sum, r) => sum + r.evaluation.efficiency.durationMs, 0) / total
+        : 0;
+    return {
+        totalTasks: total,
+        passed,
+        failed: total - passed,
+        passRate: total > 0 ? passed / total : 0,
+        byCategory,
+        avgToolCalls,
+        avgTotalTokens,
+        avgDurationMs,
+    };
+}
+/**
+ * Format a report as a human-readable string for terminal output.
+ */
+export function formatReport(report) {
+    const lines = [];
+    lines.push(`Benchmark Report: ${report.variant}`);
+    lines.push(`Model: ${report.model}`);
+    lines.push(`Generated: ${report.generatedAt}`);
+    lines.push("");
+    // Summary
+    const s = report.summary;
+    lines.push(`Results: ${s.passed}/${s.totalTasks} passed (${(s.passRate * 100).toFixed(1)}%)`);
+    lines.push("");
+    // By category
+    lines.push("By category:");
+    for (const [cat, stats] of Object.entries(s.byCategory)) {
+        lines.push(`  ${cat}: ${stats.passed}/${stats.total} (${(stats.passRate * 100).toFixed(1)}%)`);
+    }
+    lines.push("");
+    // Efficiency
+    lines.push("Efficiency (averages):");
+    lines.push(`  Tool calls: ${s.avgToolCalls.toFixed(1)}`);
+    lines.push(`  Total tokens: ${s.avgTotalTokens.toFixed(0)}`);
+    lines.push(`  Duration: ${s.avgDurationMs.toFixed(0)}ms`);
+    lines.push("");
+    // Per-task details
+    lines.push("Task details:");
+    for (const r of report.results) {
+        const status = r.evaluation.passed ? "PASS" : "FAIL";
+        lines.push(`  [${status}] ${r.taskId}`);
+        for (const check of r.evaluation.checks) {
+            const checkMark = check.passed ? "+" : "-";
+            const detail = check.detail ? ` (${check.detail})` : "";
+            lines.push(`    [${checkMark}] ${check.name}${detail}`);
+        }
+        const eff = r.evaluation.efficiency;
+        lines.push(`    tools: ${eff.toolCallCount}, tokens: ${eff.totalTokens}, files: ${eff.filesReadCount}, symbols: ${eff.symbolsQueriedCount}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Compare two reports side by side.
+ */
+export function compareReports(baseline, candidate) {
+    const lines = [];
+    lines.push(`Comparison: "${baseline.variant}" vs "${candidate.variant}"`);
+    lines.push(`Models: ${baseline.model} vs ${candidate.model}`);
+    lines.push("");
+    const bs = baseline.summary;
+    const cs = candidate.summary;
+    lines.push("Overall:");
+    lines.push(`  Pass rate: ${(bs.passRate * 100).toFixed(1)}% -> ${(cs.passRate * 100).toFixed(1)}% (${formatDelta(cs.passRate - bs.passRate, true)})`);
+    lines.push(`  Avg tool calls: ${bs.avgToolCalls.toFixed(1)} -> ${cs.avgToolCalls.toFixed(1)} (${formatDelta(cs.avgToolCalls - bs.avgToolCalls, false)})`);
+    lines.push(`  Avg tokens: ${bs.avgTotalTokens.toFixed(0)} -> ${cs.avgTotalTokens.toFixed(0)} (${formatDelta(cs.avgTotalTokens - bs.avgTotalTokens, false)})`);
+    lines.push(`  Avg duration: ${bs.avgDurationMs.toFixed(0)}ms -> ${cs.avgDurationMs.toFixed(0)}ms (${formatDelta(cs.avgDurationMs - bs.avgDurationMs, false)})`);
+    lines.push("");
+    // Per-task comparison
+    const baseResults = new Map(baseline.results.map((r) => [r.taskId, r]));
+    lines.push("Per-task changes:");
+    for (const cr of candidate.results) {
+        const br = baseResults.get(cr.taskId);
+        if (!br) {
+            lines.push(`  [NEW] ${cr.taskId}: ${cr.evaluation.passed ? "PASS" : "FAIL"}`);
+            continue;
+        }
+        if (br.evaluation.passed !== cr.evaluation.passed) {
+            const change = cr.evaluation.passed ? "FIXED" : "REGRESSED";
+            lines.push(`  [${change}] ${cr.taskId}`);
+        }
+    }
+    return lines.join("\n");
+}
+function formatDelta(delta, higherIsBetter) {
+    const sign = delta >= 0 ? "+" : "";
+    const formatted = `${sign}${delta.toFixed(1)}`;
+    if (Math.abs(delta) < 0.01)
+        return "no change";
+    if (higherIsBetter) {
+        return delta > 0 ? `${formatted} better` : `${formatted} worse`;
+    }
+    return delta < 0 ? `${formatted} better` : `${formatted} worse`;
+}

package/dist/src/benchmark/runner.js

@@ -0,0 +1,100 @@
+/**
+ * Benchmark runner — executes tasks via the agent and captures traces.
+ *
+ * Uses CodingAgent directly (not the CLI subprocess) for full control
+ * over tool-call instrumentation and trace capture.
+ */
+import { execSync } from "node:child_process";
+import { CodingAgent, Session, ToolRegistry, } from "@minicode/agent-sdk";
+function getGitCommitSha() {
+    try {
+        return execSync("git rev-parse HEAD", { encoding: "utf8" }).trim();
+    }
+    catch {
+        return "unknown";
+    }
+}
+const STRUCTURAL_TOOLS = new Set([
+    "read_symbol",
+    "find_references",
+    "get_dependencies",
+    "search_code_map",
+]);
+/**
+ * Run a single benchmark task and return the captured trace.
+ */
+export async function runBenchmarkTask(task, options) {
+    const captured = [];
+    const filesRead = new Set();
+    const symbolsQueried = new Set();
+    // Wrap each tool to capture calls
+    const instrumentedTools = options.tools.map((tool) => ({
+        ...tool,
+        execute: async (input) => {
+            const start = performance.now();
+            const output = await tool.execute(input);
+            const durationMs = performance.now() - start;
+            captured.push({
+                name: tool.name,
+                input,
+                output: output.length > 2000 ? output.slice(0, 2000) + "…[truncated]" : output,
+                durationMs,
+            });
+            // Track files read
+            if (tool.name === "read_file" || tool.name === "read_symbol") {
+                const filePath = input.path ?? input.file_path ?? input.filePath;
+                if (typeof filePath === "string")
+                    filesRead.add(filePath);
+            }
+            // Track symbol queries
+            if (STRUCTURAL_TOOLS.has(tool.name)) {
+                const sym = input.symbol ?? input.symbolName ?? input.name ?? input.query;
+                if (typeof sym === "string")
+                    symbolsQueried.add(sym);
+            }
+            return output;
+        },
+    }));
+    const registry = new ToolRegistry(instrumentedTools);
+    const session = new Session();
+    const agent = new CodingAgent({
+        config: options.config,
+        modelClient: options.modelClient,
+        toolRegistry: registry,
+        session,
+    });
+    const startedAt = new Date().toISOString();
+    const start = performance.now();
+    const { text, usage } = await agent.runTurn(task.prompt);
+    const durationMs = performance.now() - start;
+    const trace = {
+        taskId: task.id,
+        model: options.config.model,
+        variant: options.variant,
+        commitSha: getGitCommitSha(),
+        response: text,
+        toolCalls: captured,
+        filesRead: [...filesRead],
+        symbolsQueried: [...symbolsQueried],
+        usage: {
+            inputTokens: usage?.inputTokens ?? 0,
+            outputTokens: usage?.outputTokens ?? 0,
+            totalTokens: (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0),
+        },
+        durationMs,
+        startedAt,
+    };
+    options.onTaskComplete?.(task.id, trace);
+    return trace;
+}
+/**
+ * Run all provided benchmark tasks sequentially.
+ */
+export async function runBenchmarkSuite(tasks, options) {
+    const traces = [];
+    for (const task of tasks) {
+        const trace = await runBenchmarkTask(task, options);
+        traces.push(trace);
+    }
+    return traces;
+}

package/dist/src/benchmark/task-loader.js

@@ -0,0 +1,78 @@
+/**
+ * Loads benchmark tasks from the benchmarks/tasks/ directory.
+ *
+ * Each task lives in a category subdirectory and contains:
+ *   - task.json   — task metadata, prompt, and rubric
+ */
+import { readFile, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+const VALID_CATEGORIES = new Set([
+    "navigation",
+    "editing",
+    "refactors",
+    "debugging",
+    "planning",
+]);
+function isValidCategory(name) {
+    return VALID_CATEGORIES.has(name);
+}
+/**
+ * Load all benchmark tasks from the given base directory.
+ * Expects: `<baseDir>/<category>/<task-name>/task.json`
+ */
+export async function loadBenchmarkTasks(baseDir) {
+    const tasks = [];
+    const entries = await readdir(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !isValidCategory(entry.name))
+            continue;
+        const category = entry.name;
+        const categoryDir = path.join(baseDir, category);
+        const taskDirs = await readdir(categoryDir, { withFileTypes: true });
+        for (const taskDir of taskDirs) {
+            if (!taskDir.isDirectory())
+                continue;
+            const taskJsonPath = path.join(categoryDir, taskDir.name, "task.json");
+            const exists = await stat(taskJsonPath)
+                .then(() => true)
+                .catch(() => false);
+            if (!exists)
+                continue;
+            const raw = await readFile(taskJsonPath, "utf8");
+            const parsed = JSON.parse(raw);
+            tasks.push({
+                id: `${category}/${taskDir.name}`,
+                title: parsed.title,
+                category,
+                prompt: parsed.prompt,
+                workspaceRoot: parsed.workspaceRoot,
+                rubric: parsed.rubric,
+            });
+        }
+    }
+    return tasks.sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+ * Load a single benchmark task by its id (e.g. "navigation/find-symbol-definition").
+ */
+export async function loadBenchmarkTask(baseDir, taskId) {
+    const taskJsonPath = path.join(baseDir, taskId, "task.json");
+    const exists = await stat(taskJsonPath)
+        .then(() => true)
+        .catch(() => false);
+    if (!exists)
+        return undefined;
+    const raw = await readFile(taskJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const [category] = taskId.split("/");
+    if (!category || !isValidCategory(category))
+        return undefined;
+    return {
+        id: taskId,
+        title: parsed.title,
+        category,
+        prompt: parsed.prompt,
+        workspaceRoot: parsed.workspaceRoot,
+        rubric: parsed.rubric,
+    };
+}

package/dist/src/benchmark/types.js

@@ -0,0 +1,5 @@
+/**
+ * Benchmark harness types for measuring agent quality, efficiency,
+ * and structural-tool usage across repeatable tasks.
+ */
+export {};

package/dist/src/cli/args.js

@@ -11,6 +11,7 @@ export function parseCliArgs(argv) {
     let json = false;
     let outFile;
     let serve = false;
+    let pluginInstall = false;
     let port = 4567;
     const taskParts = [];
     for (let i = 0; i < args.length; i += 1) {
@@ -22,6 +23,11 @@ export function parseCliArgs(argv) {
             serve = true;
             continue;
         }
+        if (arg === "plugin" && args[i + 1] === "install") {
+            pluginInstall = true;
+            i += 1;
+            continue;
+        }
         if (arg === "--port") {
             const value = args[i + 1];
             if (!value || value.startsWith("-")) {
@@ -81,6 +87,7 @@ export function parseCliArgs(argv) {
         serve,
         port,
         task: taskParts.join(" ").trim(),
+        pluginInstall,
     };
 }
 export function validateCliArgs(args) {
@@ -93,4 +100,7 @@ export function validateCliArgs(args) {
     if (args.serve && (args.oneshot || args.json || args.outFile)) {
         throw new CliUsageError("serve mode is mutually exclusive with --oneshot, --json, and --out.");
     }
+    if (args.pluginInstall && (args.serve || args.oneshot)) {
+        throw new CliUsageError("plugin install is mutually exclusive with serve and --oneshot.");
+    }
 }

package/dist/src/cli/config-slash-command.js

@@ -0,0 +1,135 @@
+import { formatConfigForDisplay, MINICODE_HOME, resolveConfigEnv } from "../agent/config.js";
+import { formatPersistedConfigValue, getEditableConfigDefinition, getEffectiveEditableConfigValue, isEditableConfigKey, listEditableConfigDefinitions, loadPersistedConfig, setPersistedConfigValue, unsetPersistedConfigValue, } from "../agent/editable-config.js";
+function renderUsage() {
+    return [
+        'Usage:',
+        '  /config',
+        '  /config keys',
+        '  /config get <key>',
+        '  /config set <key> <value>',
+        '  /config unset <key>',
+    ].join("\n");
+}
+function renderEditableKeys() {
+    const lines = [
+        "Editable config keys (persisted in ~/.minicode/agent.config.json; environment variables take precedence):",
+    ];
+    for (const definition of listEditableConfigDefinitions()) {
+        const valueHint = definition.type === "enum"
+            ? `<${definition.values?.join("|")}>`
+            : `<${definition.type}>`;
+        lines.push(`  ${definition.key} ${valueHint} — ${definition.description} (env: ${definition.envVar})`);
+    }
+    lines.push("");
+    lines.push('Use "/config set <key> <value>" to update your global config.');
+    lines.push("Secrets like API keys stay env-only for now.");
+    return lines.join("\n");
+}
+async function renderConfigValue(key, context) {
+    if (!isEditableConfigKey(key)) {
+        return `Unknown editable config key "${key}".\n\n${renderEditableKeys()}`;
+    }
+    const minicodeHome = context.minicodeHome ?? MINICODE_HOME;
+    const definition = getEditableConfigDefinition(key);
+    const persisted = await loadPersistedConfig(minicodeHome);
+    const env = await resolveConfigEnv({ minicodeHome });
+    const envValue = env.values[definition.envVar];
+    return [
+        `${definition.key}`,
+        `  effective: ${getEffectiveEditableConfigValue(context.config, key)}`,
+        `  config file: ${formatPersistedConfigValue(persisted[definition.fileKey])}`,
+        `  env override (${definition.envVar}): ${formatPersistedConfigValue(envValue)}`,
+    ].join("\n");
+}
+async function persistConfigValue(key, rawValue, context) {
+    if (!isEditableConfigKey(key)) {
+        return `Unknown editable config key "${key}".\n\n${renderEditableKeys()}`;
+    }
+    const minicodeHome = context.minicodeHome ?? MINICODE_HOME;
+    const definition = getEditableConfigDefinition(key);
+    const env = await resolveConfigEnv({ minicodeHome });
+    try {
+        const result = await setPersistedConfigValue({
+            key,
+            rawValue,
+            minicodeHome,
+        });
+        const lines = [
+            `Saved config: ${key} = ${formatPersistedConfigValue(result.storedValue)}`,
+            `File: ${result.path}`,
+            "Restart minicode to pick up persisted config changes in a new session.",
+        ];
+        if (env.values[definition.envVar] !== undefined) {
+            lines.push(`Note: ${definition.envVar} is currently set and will override this persisted value until it is unset.`);
+        }
+        return lines.join("\n");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return `Failed to save config: ${message}`;
+    }
+}
+async function removeConfigValue(key, context) {
+    if (!isEditableConfigKey(key)) {
+        return `Unknown editable config key "${key}".\n\n${renderEditableKeys()}`;
+    }
+    const minicodeHome = context.minicodeHome ?? MINICODE_HOME;
+    const definition = getEditableConfigDefinition(key);
+    const env = await resolveConfigEnv({ minicodeHome });
+    await unsetPersistedConfigValue({
+        key,
+        minicodeHome,
+    });
+    const lines = [
+        `Removed persisted value for "${key}".`,
+        `File: ${minicodeHome}/agent.config.json`,
+        "Restart minicode to ensure the updated config is applied in a new session.",
+    ];
+    if (env.values[definition.envVar] !== undefined) {
+        lines.push(`Note: ${definition.envVar} is still set in the environment, so the effective value may remain unchanged.`);
+    }
+    return lines.join("\n");
+}
+export async function handleConfigSlashCommand(trimmed, context) {
+    if (!(trimmed === "/config" || trimmed.startsWith("/config "))) {
+        return { handled: false };
+    }
+    const rest = trimmed.slice("/config".length).trim();
+    if (rest.length === 0) {
+        return { handled: true, message: formatConfigForDisplay(context.config) };
+    }
+    const tokens = rest.split(/\s+/);
+    const [subcommand, ...subArgs] = tokens;
+    if (subcommand === "keys") {
+        return { handled: true, message: renderEditableKeys() };
+    }
+    if (subcommand === "get") {
+        if (subArgs.length !== 1) {
+            return { handled: true, message: renderUsage() };
+        }
+        return {
+            handled: true,
+            message: await renderConfigValue(subArgs[0], context),
+        };
+    }
+    if (subcommand === "set") {
+        if (subArgs.length < 2) {
+            return { handled: true, message: renderUsage() };
+        }
+        const [key, ...valueParts] = subArgs;
+        return {
+            handled: true,
+            message: await persistConfigValue(key, valueParts.join(" "), context),
+        };
+    }
+    if (subcommand === "unset") {
+        if (subArgs.length !== 1) {
+            return { handled: true, message: renderUsage() };
+        }
+        return {
+            handled: true,
+            message: await removeConfigValue(subArgs[0], context),
+        };
+    }
+    return { handled: true, message: renderUsage() };
+}

package/dist/src/cli/plugin-install.js

@@ -0,0 +1,69 @@
+/**
+ * Install the minicode Claude Code plugin globally.
+ *
+ * Creates a symlink from ~/.claude/plugins/minicode → the plugin directory
+ * shipped alongside the minicode package.
+ */
+import { mkdir, symlink, readlink, unlink, stat } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+/**
+ * Resolve the plugin source directory.
+ * In dev (tsx): __dirname = src/cli → go up to project root, then plugin/
+ * In prod (dist): __dirname = dist/src/cli → go up to project root, then plugin/
+ */
+function getPluginSourceDir() {
+    if (__dirname.includes(`${path.sep}dist${path.sep}`)) {
+        return path.resolve(__dirname, "../../../plugin");
+    }
+    return path.resolve(__dirname, "../../plugin");
+}
+export async function installPlugin() {
+    const pluginsDir = path.join(os.homedir(), ".claude", "plugins");
+    const targetDir = path.join(pluginsDir, "minicode");
+    const sourceDir = getPluginSourceDir();
+    // Verify the plugin source exists
+    try {
+        await stat(path.join(sourceDir, ".claude-plugin", "plugin.json"));
+    }
+    catch {
+        console.error(`Error: plugin source not found at ${sourceDir}`);
+        console.error("Make sure you are running from a minicode installation.");
+        process.exit(1);
+    }
+    // Create ~/.claude/plugins/ if it doesn't exist
+    await mkdir(pluginsDir, { recursive: true });
+    // Check if target already exists
+    try {
+        const existing = await readlink(targetDir);
+        if (existing === sourceDir) {
+            console.log(`Plugin already installed at ${targetDir}`);
+            console.log(`  → ${sourceDir}`);
+            return;
+        }
+        // Different target — remove and re-link
+        await unlink(targetDir);
+    }
+    catch {
+        // Check if it's a directory (not a symlink) that exists
+        try {
+            const stats = await stat(targetDir);
+            if (stats.isDirectory()) {
+                console.error(`Error: ${targetDir} exists and is not a symlink.`);
+                console.error("Remove it manually if you want to reinstall.");
+                process.exit(1);
+            }
+        }
+        catch {
+            // Doesn't exist — good
+        }
+    }
+    await symlink(sourceDir, targetDir, "dir");
+    console.log("minicode plugin installed for Claude Code");
+    console.log(`  ${targetDir} → ${sourceDir}`);
+    console.log("\nThe plugin will load automatically in Claude Code sessions.");
+    console.log("Make sure minicode serve is running for the MCP tools to work:");
+    console.log("  minicode serve");
+}