open-multi-agent-kit 0.78.0

package/dist/commands/menu.d.ts

@@ -0,0 +1,4 @@
+export declare function menuCommand(options: {
+    runId?: string;
+    workers?: string;
+}): Promise<void>;

package/dist/commands/menu.js

@@ -0,0 +1,213 @@
+import { style, omkCliHero, label, separator } from "../util/theme.js";
+import { t, initI18n } from "../util/i18n.js";
+import { orchestratePrompt } from "../orchestration/orchestrate-prompt.js";
+import { getCurrentMode, getModePresets } from "../util/mode-preset.js";
+export async function menuCommand(options) {
+    await initI18n();
+    const currentMode = await getCurrentMode();
+    const preset = getModePresets().find((p) => p.name === currentMode);
+    const { renderHudDashboard } = await import("./hud.js");
+    try {
+        const hud = await renderHudDashboard({
+            runId: options.runId,
+            terminalWidth: process.stdout.columns || 120,
+        });
+        console.log(hud);
+    }
+    catch {
+        console.log(omkCliHero());
+    }
+    // Show current mode badge
+    if (preset) {
+        console.log("");
+        console.log(label("Mode", `${preset.icon} ${preset.label} (${preset.name})`));
+        console.log(separator(50));
+    }
+    const hasTty = Boolean(process.stdout.isTTY && process.stdin.isTTY);
+    if (!hasTty) {
+        console.log(style.gray("\n  💡 omk chat  — " + t("cli.suggestionChat").replace("  💡 omk chat  — ", "")));
+        console.log(style.gray("  💡 omk hud   — " + t("cli.suggestionHud").replace("  💡 omk hud   — ", "")));
+        console.log(style.gray("  💡 omk --help — " + t("cli.suggestionHelp").replace("  💡 omk --help — ", "").trim()));
+        return;
+    }
+    const { buildCustomHelp } = await import("../util/help-text.js");
+    const customHelp = buildCustomHelp();
+    let answer;
+    try {
+        const { select } = await import("@inquirer/prompts");
+        const ac = new AbortController();
+        const timeoutId = setTimeout(() => ac.abort(), 30_000);
+        answer = await select({
+            message: t("cli.mainMenu"),
+            choices: [
+                { name: t("cli.menuChat"), value: "1" },
+                { name: t("cli.menuHud"), value: "2" },
+                { name: t("cli.menuPlan"), value: "3" },
+                { name: t("cli.menuParallel"), value: "4" },
+                { name: t("cli.menuMode"), value: "m" },
+                { name: t("cli.menuPrevious"), value: "0" },
+                { name: t("cli.menuHelp"), value: "5" },
+                { name: t("cli.menuExit"), value: "q" },
+            ],
+        }, { signal: ac.signal });
+        clearTimeout(timeoutId);
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === "ExitPromptError") {
+            console.log("\n" + style.gray("Cancelled."));
+            process.exit(0);
+        }
+        console.log(style.gray(t("cli.menuUnavailable")));
+        console.log(customHelp);
+        return;
+    }
+    switch (answer) {
+        case "1": {
+            const { spawnSync } = await import("child_process");
+            const chatArgs = [process.argv[1], "chat", "--layout", "auto", "--brand", "omk"];
+            if (options.runId)
+                chatArgs.push("--run-id", options.runId);
+            if (options.workers)
+                chatArgs.push("--workers", options.workers);
+            const result = spawnSync(process.execPath, chatArgs, { stdio: "inherit" });
+            if (result.status && result.status !== 0) {
+                process.exitCode = result.status;
+            }
+            break;
+        }
+        case "2": {
+            const { hudCommand } = await import("./hud.js");
+            await hudCommand({ runId: options.runId, watch: true, refreshMs: 2000 });
+            break;
+        }
+        case "3": {
+            const { planCommand } = await import("./plan.js");
+            const { input } = await import("@inquirer/prompts");
+            let goal;
+            try {
+                goal = await input({ message: "Goal:" });
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === "ExitPromptError") {
+                    console.log(style.gray("Control console closed."));
+                    process.exit(0);
+                }
+                throw err;
+            }
+            await planCommand(goal, { runId: options.runId });
+            break;
+        }
+        case "4": {
+            const { spawnSync } = await import("child_process");
+            const { input } = await import("@inquirer/prompts");
+            let goal;
+            try {
+                goal = await input({ message: "Goal:" });
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === "ExitPromptError") {
+                    console.log(style.gray("Control console closed."));
+                    process.exit(0);
+                }
+                throw err;
+            }
+            const parallelArgs = [process.argv[1], "parallel", goal];
+            if (options.runId)
+                parallelArgs.push("--run-id", options.runId);
+            if (options.workers)
+                parallelArgs.push("--workers", options.workers);
+            const result = spawnSync(process.execPath, parallelArgs, { stdio: "inherit" });
+            if (result.status !== 0) {
+                process.exit(result.status ?? 1);
+            }
+            break;
+        }
+        case "0": {
+            const { selectLatestRunName, listRunCandidates } = await import("./hud.js");
+            const { getOmkPath, pathExists } = await import("../util/fs.js");
+            const runsDir = getOmkPath("runs");
+            let prevRunId = options.runId ?? null;
+            if (!prevRunId && (await pathExists(runsDir))) {
+                const candidates = await listRunCandidates(runsDir);
+                prevRunId = selectLatestRunName(candidates);
+            }
+            if (prevRunId) {
+                const { hudCommand } = await import("./hud.js");
+                await hudCommand({ runId: prevRunId, watch: true, refreshMs: 2000 });
+            }
+            else {
+                console.log(style.gray("  No previous run found."));
+            }
+            break;
+        }
+        case "m":
+        case "mode": {
+            const { modeCommand } = await import("./mode.js");
+            await modeCommand(undefined, { list: false });
+            // After showing current mode, prompt to switch
+            const { select } = await import("@inquirer/prompts");
+            const presets = getModePresets();
+            const modeAnswer = await select({
+                message: "Select mode:",
+                choices: [
+                    ...presets.map((p) => ({
+                        name: `${p.icon} ${p.label} — ${p.description}`,
+                        value: p.name,
+                    })),
+                    { name: "Cancel", value: "cancel" },
+                ],
+            }, { signal: AbortSignal.timeout(30_000) });
+            if (modeAnswer !== "cancel") {
+                await modeCommand(modeAnswer, { list: false });
+            }
+            break;
+        }
+        case "5":
+        case "help":
+        case "h": {
+            console.log(customHelp);
+            break;
+        }
+        case "q":
+        case "quit":
+        case "exit": {
+            console.log(style.gray("Control console closed."));
+            process.exit(0);
+            break;
+        }
+        default: {
+            console.log(style.orange(t("cli.unknownChoice", answer)));
+            const { input } = await import("@inquirer/prompts");
+            let rawPrompt;
+            try {
+                rawPrompt = await input({ message: "Prompt:" });
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === "ExitPromptError") {
+                    console.log(style.gray("Control console closed."));
+                    process.exit(0);
+                }
+                throw err;
+            }
+            try {
+                await orchestratePrompt(rawPrompt, {
+                    sourceCommand: "default",
+                    runId: options.runId,
+                    workers: options.workers,
+                });
+            }
+            catch {
+                const { spawnSync } = await import("child_process");
+                const chatArgs = [process.argv[1], "chat"];
+                if (options.runId)
+                    chatArgs.push("--run-id", options.runId);
+                if (options.workers)
+                    chatArgs.push("--workers", options.workers);
+                const result = spawnSync(process.execPath, chatArgs, { stdio: "inherit" });
+                if (result.status !== 0) {
+                    process.exit(result.status ?? 1);
+                }
+            }
+        }
+    }
+}

package/dist/commands/merge.d.ts

@@ -0,0 +1,8 @@
+interface MergeOptions {
+    run?: string;
+    runId?: string;
+    strategy?: string;
+    dryRun?: boolean;
+}
+export declare function mergeCommand(options: MergeOptions): Promise<void>;
+export {};

package/dist/commands/merge.js

@@ -0,0 +1,229 @@
+import { readdir } from "fs/promises";
+import { join } from "path";
+import { getOmkPath, pathExists, getProjectRoot, injectKimiGlobals } from "../util/fs.js";
+import { runShell } from "../util/shell.js";
+import { getCurrentBranch, isGitRepo } from "../util/git.js";
+import { style, header, status, label, separator } from "../util/theme.js";
+import { t } from "../util/i18n.js";
+import { runQualityGate } from "../mcp/quality-gate.js";
+import { readTextFile } from "../util/fs.js";
+import { getOmkResourceSettings } from "../util/resource-profile.js";
+import { defaultScopedRoleAgentFile, writeScopedAgentFile } from "../util/scoped-agent-file.js";
+export async function mergeCommand(options) {
+    const root = getProjectRoot();
+    const strategy = (options.strategy ?? "first").trim().toLowerCase();
+    const dryRun = Boolean(options.dryRun);
+    if (!(await isGitRepo())) {
+        console.error(status.error("Not a git repository."));
+        process.exit(1);
+    }
+    const runsDir = getOmkPath("runs");
+    if (!(await pathExists(runsDir))) {
+        console.error(status.error(t("merge.noRuns")));
+        process.exit(1);
+    }
+    let runId = options.run ?? options.runId ?? "latest";
+    if (runId === "latest") {
+        const entries = await readdir(runsDir, { withFileTypes: true });
+        const runs = entries.filter((e) => e.isDirectory()).sort().reverse();
+        if (runs.length === 0) {
+            console.error(status.error(t("merge.noRuns")));
+            process.exit(1);
+        }
+        runId = runs[0].name;
+    }
+    const worktreesDir = getOmkPath(`worktrees/${runId}`);
+    if (!(await pathExists(worktreesDir))) {
+        console.log(status.info(t("merge.noWorktrees")));
+        return;
+    }
+    const workerNames = await readdir(worktreesDir, { withFileTypes: true }).then((e) => e.filter((d) => d.isDirectory()).map((d) => d.name));
+    const currentBranch = await getCurrentBranch();
+    if (!currentBranch) {
+        console.error(status.error(t("merge.branchCheckFailed")));
+        process.exit(1);
+    }
+    console.log(header("omk merge"));
+    console.log(label("Run ID", runId));
+    console.log(label("Strategy", strategy));
+    console.log(label("Workers", workerNames.join(", ")));
+    if (dryRun)
+        console.log(style.orange("🟡 DRY RUN — no changes will be applied"));
+    console.log("");
+    // ── 1. Collect diffs from all worktrees ──
+    const workers = [];
+    for (const name of workerNames) {
+        const wtPath = join(worktreesDir, name);
+        const diffResult = await runShell("git", ["-C", wtPath, "diff", currentBranch], { timeout: 15000 });
+        if (diffResult.failed || !diffResult.stdout.trim()) {
+            console.log(style.gray(`  ${name}: no changes`));
+            continue;
+        }
+        const diff = diffResult.stdout;
+        const diffLines = diff.split("\n").length;
+        // Check apply-ability
+        const applyCheck = await runShell("git", ["apply", "--check"], {
+            cwd: root,
+            input: diff,
+            timeout: 15000,
+        });
+        const canApply = !applyCheck.failed;
+        workers.push({ name, path: wtPath, diff, diffLines, canApply });
+        console.log(`  ${style.purpleBold(name)} ${canApply ? style.mint("(clean)") : style.pink("(conflicts)")} ${style.gray(`${diffLines} lines`)}`);
+    }
+    if (workers.length === 0) {
+        console.log(status.warn("No worker changes to merge."));
+        return;
+    }
+    // ── 2. Reviewer scoring ──
+    console.log("");
+    console.log(style.purple("Scoring diffs with reviewer..."));
+    for (const w of workers) {
+        const score = await scoreDiff(w.diff, w.name);
+        w.reviewScore = score.score;
+        w.reviewReason = score.reason;
+        const color = score.score >= 80 ? style.mint : score.score >= 50 ? style.orange : style.pink;
+        console.log(`  ${w.name}: ${color(`${score.score}/100`)} ${style.gray(score.reason)}`);
+    }
+    // ── 3. Test verification in worktrees ──
+    console.log("");
+    console.log(style.purple("Running tests in worktrees..."));
+    for (const w of workers) {
+        const testResult = await runShell("sh", ["-c", "npm test 2>/dev/null || pnpm test 2>/dev/null || yarn test 2>/dev/null || true"], {
+            cwd: w.path,
+            timeout: 120_000,
+        });
+        w.testsPassed = !testResult.failed;
+        console.log(`  ${w.name}: ${w.testsPassed ? style.mint("tests passed") : style.pink("tests failed")}`);
+    }
+    // ── 4. Select winner ──
+    console.log("");
+    console.log(style.purple("Selecting winner..."));
+    const winner = selectWinner(workers, strategy);
+    // ── 5. Apply or preview ──
+    const report = {
+        winner: winner?.name ?? null,
+        reason: winner?.reviewReason ?? "No suitable candidate",
+        conflicts: workers.filter((w) => !w.canApply).map((w) => w.name),
+        filesApplied: 0,
+        dryRun,
+        workers,
+    };
+    if (!winner) {
+        console.log(status.error("No worker diff can be applied cleanly."));
+        printReport(report);
+        process.exit(1);
+    }
+    if (dryRun) {
+        console.log(style.orange(`\n🟡 Dry-run: would apply ${winner.name}`));
+        printReport(report);
+        return;
+    }
+    // Apply winner patch
+    console.log(style.purple(`\nApplying ${winner.name}...`));
+    const applyResult = await runShell("git", ["apply"], {
+        cwd: root,
+        input: winner.diff,
+        timeout: 15000,
+    });
+    if (applyResult.failed) {
+        console.error(status.error(`Failed to apply patch from ${winner.name}`));
+        console.error(applyResult.stderr);
+        process.exit(1);
+    }
+    const stagedFiles = await runShell("git", ["diff", "--cached", "--name-only"], { cwd: root, timeout: 5000 });
+    report.filesApplied = stagedFiles.stdout.trim().split("\n").filter(Boolean).length;
+    // ── 6. Verify ──
+    console.log(style.purple("Verifying merge..."));
+    const config = await readTextFile(join(root, ".omk", "config.toml"), "");
+    const qgResult = await runQualityGate(root, config);
+    const qgFailed = Object.values(qgResult).some((r) => r.status === "failed" || r.status === "timeout" || r.status === "error");
+    if (qgFailed) {
+        console.error(status.error("Quality gate failed after merge."));
+        printReport(report);
+        process.exit(1);
+    }
+    // ── 7. Summary ──
+    console.log("");
+    console.log(status.ok("Merge complete"));
+    printReport(report);
+}
+// ── Helpers ───────────────────────────────────────────────────
+async function scoreDiff(diff, workerName) {
+    const root = getProjectRoot();
+    const agentFile = join(root, ".omk", "agents", "roles", "reviewer.yaml");
+    if (!(await pathExists(agentFile))) {
+        return { score: 50, reason: "reviewer agent not found" };
+    }
+    const prompt = `Score this diff from 0-100. Return ONLY a JSON object like {"score": 85, "reason": "concise reason"}.\n\n--- DIFF from ${workerName} ---\n${diff.slice(0, 8000)}\n--- END DIFF ---`;
+    const resources = await getOmkResourceSettings();
+    const scopedAgentFile = await writeScopedAgentFile({
+        baseAgentFile: agentFile,
+        outputFile: defaultScopedRoleAgentFile(root, undefined, "reviewer"),
+        role: "reviewer",
+        resources,
+    });
+    const args = ["--print", "--output-format=stream-json", "--agent-file", scopedAgentFile];
+    await injectKimiGlobals(args, {
+        role: "reviewer",
+        mcpScope: resources.mcpScope,
+        skillsScope: resources.skillsScope,
+        hooksScope: resources.hooksScope,
+    });
+    args.push("-p", prompt);
+    const result = await runShell("kimi", args, { cwd: root, timeout: 60_000 });
+    if (result.failed) {
+        return { score: 50, reason: "review failed" };
+    }
+    try {
+        const json = JSON.parse(result.stdout.trim().split("\n").pop() ?? "{}");
+        const score = Math.max(0, Math.min(100, Number(json.score) || 50));
+        const reason = String(json.reason || "no reason given").slice(0, 60);
+        return { score, reason };
+    }
+    catch {
+        // Fallback: try to extract score from text
+        const match = result.stdout.match(/(\d{1,3})\s*\/\s*100/);
+        if (match) {
+            return { score: Number(match[1]), reason: "extracted from text" };
+        }
+        return { score: 50, reason: "parse failed" };
+    }
+}
+function selectWinner(workers, strategy) {
+    const eligible = workers.filter((w) => w.canApply);
+    if (eligible.length === 0)
+        return null;
+    if (strategy === "first") {
+        return eligible[0];
+    }
+    // best: composite score (review * 0.4 + test bonus * 0.3 + diff-size penalty * 0.3)
+    const scored = eligible.map((w) => {
+        const testBonus = w.testsPassed ? 30 : 0;
+        const sizePenalty = Math.max(0, Math.min(20, w.diffLines / 100));
+        const composite = (w.reviewScore ?? 50) * 0.4 + testBonus * 0.3 - sizePenalty * 0.3;
+        return { worker: w, composite };
+    });
+    scored.sort((a, b) => b.composite - a.composite);
+    return scored[0].worker;
+}
+function printReport(report) {
+    console.log("");
+    console.log(separator());
+    console.log(label("Winner", report.winner ?? style.pink("none")));
+    console.log(label("Reason", report.reason));
+    console.log(label("Conflicts", report.conflicts.length > 0 ? report.conflicts.join(", ") : "none"));
+    console.log(label("Files applied", String(report.filesApplied)));
+    if (report.dryRun)
+        console.log(label("Mode", style.orange("dry-run")));
+    console.log("");
+    console.log(style.purpleBold("Worker Breakdown"));
+    for (const w of report.workers) {
+        const s = w.reviewScore ?? 0;
+        const scoreColor = s >= 80 ? style.mint : s >= 50 ? style.orange : style.pink;
+        console.log(`  ${w.name}: ${scoreColor(`${s}/100`)} ` +
+            `${w.testsPassed ? style.mint("✓ tests") : style.pink("✗ tests")} ` +
+            `${w.canApply ? style.mint("✓ clean") : style.pink("✗ conflict")} ` +
+            style.gray(`${w.diffLines} lines`));
+    }
+}

package/dist/commands/mode.d.ts

@@ -0,0 +1,3 @@
+export declare function modeCommand(presetArg: string | undefined, options: {
+    list?: boolean;
+}): Promise<void>;

package/dist/commands/mode.js

@@ -0,0 +1,60 @@
+import { style, status, label, header, separator } from "../util/theme.js";
+import { getCurrentMode, setCurrentMode, getModePresets, isValidMode, } from "../util/mode-preset.js";
+import { t } from "../util/i18n.js";
+export async function modeCommand(presetArg, options) {
+    // omk mode list
+    if (options.list) {
+        await printModeList();
+        return;
+    }
+    // omk mode (no args) → show current
+    if (!presetArg) {
+        const current = await getCurrentMode();
+        const preset = getModePresets().find((p) => p.name === current);
+        console.log(header(t("mode.currentHeader")));
+        if (preset) {
+            console.log(label(t("mode.name"), `${preset.icon} ${preset.label}`));
+            console.log(label(t("mode.description"), preset.description));
+        }
+        else {
+            console.log(label(t("mode.name"), current));
+        }
+        console.log(separator(40));
+        console.log(style.gray(t("mode.switchHint")));
+        return;
+    }
+    let mode = presetArg.toLowerCase().trim();
+    if (mode === "default")
+        mode = "agent"; // backward compatibility
+    if (!isValidMode(mode)) {
+        console.error(status.error(t("mode.invalid", mode)));
+        console.log(style.gray(t("mode.validValues")));
+        for (const p of getModePresets()) {
+            console.log(`  ${p.icon} ${style.cream(p.name)} — ${p.description}`);
+        }
+        process.exit(1);
+    }
+    const from = await getCurrentMode();
+    if (from === mode) {
+        console.log(status.ok(t("mode.alreadySet", mode)));
+        return;
+    }
+    await setCurrentMode(mode);
+    const preset = getModePresets().find((p) => p.name === mode);
+    console.log(status.ok(t("mode.switched", from, mode)));
+    if (preset) {
+        console.log(label(t("mode.description"), preset.description));
+    }
+}
+async function printModeList() {
+    const current = await getCurrentMode();
+    console.log(header(t("mode.listHeader")));
+    for (const p of getModePresets()) {
+        const isCurrent = p.name === current;
+        const marker = isCurrent ? style.mint("▸") : " ";
+        const name = isCurrent ? style.mintBold(p.name) : style.cream(p.name);
+        console.log(` ${marker} ${p.icon} ${name} — ${p.description}`);
+    }
+    console.log(separator(40));
+    console.log(style.gray(t("mode.switchHint")));
+}

package/dist/commands/model.d.ts

@@ -0,0 +1,15 @@
+export interface ModelJsonOptions {
+    json?: boolean;
+}
+export interface ThinkCommandOptions extends ModelJsonOptions {
+    provider?: string;
+    model?: string;
+    exportEnv?: boolean;
+}
+export declare function modelListCommand(options?: ModelJsonOptions): Promise<void>;
+export declare function modelAliasesCommand(options?: ModelJsonOptions): Promise<void>;
+export declare function modelAliasAddCommand(alias: string, target: string, options?: ModelJsonOptions): Promise<void>;
+export declare function modelAliasRemoveCommand(alias: string, options?: ModelJsonOptions): Promise<void>;
+export declare function modelResolveCommand(model: string, options?: ModelJsonOptions): Promise<void>;
+export declare function modelUseCommand(model: string, options?: ModelJsonOptions): Promise<void>;
+export declare function thinkCommand(level?: string, variant?: string, options?: ThinkCommandOptions): Promise<void>;