open-multi-agent-kit 0.78.0

package/dist/cli/v2/workflow-commands.js

@@ -0,0 +1,198 @@
+/**
+ * Section 21 — CLI v2 Workflow Commands (Clipanion)
+ *
+ * Migrates Commander workflow commands (run, plan, parallel, orchestrate, etc.)
+ * to Clipanion classes that delegate to existing command implementations.
+ */
+import { Command, Option } from "clipanion";
+// ──────────────────────────────────────────────
+// Workflow Commands
+// ──────────────────────────────────────────────
+export class PlanCommand extends Command {
+    static paths = [["plan"]];
+    static usage = Command.Usage({
+        description: "Strategic planning with optional interview workflow",
+        examples: [["Plan a feature", "omk plan 'add user authentication'"]],
+    });
+    goal = Option.String({ required: true });
+    thinking = Option.String("--thinking", "high");
+    specKit = Option.Boolean("--spec-kit", false);
+    async execute() {
+        const { planCommand } = await import("../../commands/plan.js");
+        await planCommand(this.goal, {
+            thinking: this.thinking,
+            specKit: this.specKit,
+        });
+        return 0;
+    }
+}
+export class FeatureCommand extends Command {
+    static paths = [["feature"]];
+    static usage = Command.Usage({
+        description: "Feature development workflow",
+    });
+    goal = Option.String({ required: true });
+    specKit = Option.Boolean("--spec-kit", false);
+    async execute() {
+        const { featureCommand } = await import("../../commands/workflow.js");
+        await featureCommand(this.goal, { specKit: this.specKit });
+        return 0;
+    }
+}
+export class BugfixCommand extends Command {
+    static paths = [["bugfix"]];
+    static usage = Command.Usage({
+        description: "Bug fix workflow",
+    });
+    goal = Option.String({ required: true });
+    specKit = Option.Boolean("--spec-kit", false);
+    async execute() {
+        const { bugfixCommand } = await import("../../commands/workflow.js");
+        await bugfixCommand(this.goal, { specKit: this.specKit });
+        return 0;
+    }
+}
+export class RefactorCommand extends Command {
+    static paths = [["refactor"]];
+    static usage = Command.Usage({
+        description: "Refactoring workflow",
+    });
+    goal = Option.String({ required: true });
+    specKit = Option.Boolean("--spec-kit", false);
+    async execute() {
+        const { refactorCommand } = await import("../../commands/workflow.js");
+        await refactorCommand(this.goal, { specKit: this.specKit });
+        return 0;
+    }
+}
+export class ReviewCommand extends Command {
+    static paths = [["review"]];
+    static usage = Command.Usage({
+        description: "Code review workflow",
+    });
+    ci = Option.Boolean("--ci", false);
+    soft = Option.Boolean("--soft", false);
+    async execute() {
+        const { reviewCommand } = await import("../../commands/workflow.js");
+        const result = await reviewCommand({ ci: this.ci, soft: this.soft });
+        if (!result && process.exitCode === undefined) {
+            process.exitCode = 1;
+        }
+        return 0;
+    }
+}
+export class TeamCommand extends Command {
+    static paths = [["team"]];
+    static usage = Command.Usage({
+        description: "Multi-agent team workflow",
+    });
+    workers = Option.String("--workers", "auto");
+    async execute() {
+        const { teamCommand } = await import("../../commands/team.js");
+        await teamCommand({ workers: this.workers });
+        return 0;
+    }
+}
+export class OrchestrateCommand extends Command {
+    static paths = [["orchestrate"]];
+    static usage = Command.Usage({
+        description: "Parallel agent orchestration with skill/MCP/hook assignment",
+        examples: [["Orchestrate a goal", "omk orchestrate 'implement auth system'"]],
+    });
+    goal = Option.String({ required: true });
+    workers = Option.String("--workers", "auto");
+    timeout = Option.String("--timeout", "600000");
+    dryRun = Option.Boolean("--dry-run", false);
+    output = Option.String("--output", "");
+    async execute() {
+        const { orchestrateCommand } = await import("../../commands/orchestrate.js");
+        const result = await orchestrateCommand(this.goal, {
+            workers: this.workers,
+            timeout: this.timeout,
+            dryRun: this.dryRun,
+            output: this.output || undefined,
+        });
+        if (result && !result.success && process.exitCode === undefined) {
+            process.exitCode = 1;
+        }
+        return 0;
+    }
+}
+// ──────────────────────────────────────────────
+// Consent Command
+// ──────────────────────────────────────────────
+export class ConsentCommand extends Command {
+    static paths = [["consent"]];
+    static usage = Command.Usage({
+        description: "Manage data sharing consent levels (L0-L4)",
+        examples: [
+            ["Show status", "omk consent status"],
+            ["Enable level", "omk consent enable l1"],
+            ["Preview data", "omk consent preview"],
+            ["Revoke all", "omk consent revoke"],
+        ],
+    });
+    subcommand = Option.String({ required: true });
+    level = Option.String("");
+    async execute() {
+        const consent = await import("../../commands/consent.js");
+        switch (this.subcommand) {
+            case "status":
+                consent.consentStatus();
+                break;
+            case "enable": {
+                if (!this.level) {
+                    this.context.stderr.write("Usage: omk consent enable <level>\n");
+                    return 2;
+                }
+                const lv = this.level.toLowerCase();
+                if (!["l0", "l1", "l2", "l3"].includes(lv)) {
+                    this.context.stderr.write(`Invalid level: ${this.level}. Use l0, l1, l2, or l3.` + "\n");
+                    return 1;
+                }
+                consent.consentEnable(lv);
+                break;
+            }
+            case "disable": {
+                if (!this.level) {
+                    this.context.stderr.write("Usage: omk consent disable <level>\n");
+                    return 2;
+                }
+                const lv = this.level.toLowerCase();
+                if (!["l0", "l1", "l2", "l3"].includes(lv)) {
+                    this.context.stderr.write(`Invalid level: ${this.level}. Use l0, l1, l2, or l3.` + "\n");
+                    return 1;
+                }
+                consent.consentDisable(lv);
+                break;
+            }
+            case "preview":
+                consent.consentPreview();
+                break;
+            case "export":
+                consent.consentExport();
+                break;
+            case "revoke":
+                consent.consentRevoke();
+                break;
+            default:
+                this.context.stderr.write(`Unknown consent subcommand: ${this.subcommand}` + "\n");
+                this.context.stderr.write("Valid: status, enable, disable, preview, export, revoke\n");
+                return 2;
+        }
+        return 0;
+    }
+}
+/**
+ * Register all workflow commands on a Clipanion CLI instance.
+ */
+export function registerWorkflowCommandsV2(cli) {
+    cli.register(PlanCommand);
+    cli.register(FeatureCommand);
+    cli.register(BugfixCommand);
+    cli.register(RefactorCommand);
+    cli.register(ReviewCommand);
+    cli.register(TeamCommand);
+    cli.register(OrchestrateCommand);
+    cli.register(ConsentCommand);
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+function shouldRunOpenDesignSmoke(argv) {
+    const commandIndex = argv.findIndex((arg, index) => index >= 2 && arg === "open-design-agent");
+    return commandIndex >= 2 && argv.slice(commandIndex + 1).includes("--smoke");
+}
+if (shouldRunOpenDesignSmoke(process.argv)) {
+    process.stdout.write("ok\n");
+    process.exit(0);
+}
+if (process.env.OMK_CLI_V2 === "1") {
+    const { runCliV2 } = await import("./cli/v2/cli-v2-skeleton.js");
+    await runCliV2(process.argv);
+    process.exit(process.exitCode ?? 0);
+}
+const { runCli } = await import("./cli/main.js");
+await runCli(process.argv);
+export {};

package/dist/cockpit/git-numstat.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Git diff --numstat parser for cockpit modified-files view.
+ */
+export interface GitNumstatEntry {
+    path: string;
+    added: number | null;
+    deleted: number | null;
+}
+export declare function getGitNumstat(root: string, staged?: boolean): Promise<Map<string, GitNumstatEntry>>;
+export declare function getGitBranch(root: string): Promise<string | undefined>;

package/dist/cockpit/git-numstat.js

@@ -0,0 +1,97 @@
+/**
+ * Git diff --numstat parser for cockpit modified-files view.
+ */
+import { execFile } from "child_process";
+import { promisify } from "util";
+const execFileAsync = promisify(execFile);
+export async function getGitNumstat(root, staged = true) {
+    const map = new Map();
+    // Unstaged changes
+    const unstaged = await runNumstat(root, ["diff", "--numstat"]);
+    for (const entry of unstaged) {
+        map.set(entry.path, entry);
+    }
+    // Staged changes
+    if (staged) {
+        const stagedEntries = await runNumstat(root, ["diff", "--cached", "--numstat"]);
+        for (const entry of stagedEntries) {
+            const existing = map.get(entry.path);
+            if (existing) {
+                map.set(entry.path, {
+                    path: entry.path,
+                    added: sumMaybe(existing.added, entry.added),
+                    deleted: sumMaybe(existing.deleted, entry.deleted),
+                });
+            }
+            else {
+                map.set(entry.path, entry);
+            }
+        }
+    }
+    // Untracked files (no numstat available)
+    const untracked = await runUntracked(root);
+    for (const path of untracked) {
+        if (!map.has(path)) {
+            map.set(path, { path, added: null, deleted: null });
+        }
+    }
+    return map;
+}
+async function runNumstat(root, args) {
+    try {
+        const { stdout } = await execFileAsync("git", args, {
+            cwd: root,
+            timeout: 5000,
+            encoding: "utf-8",
+            maxBuffer: 1024 * 1024,
+        });
+        return parseNumstat(String(stdout));
+    }
+    catch {
+        return [];
+    }
+}
+function parseNumstat(stdout) {
+    const entries = [];
+    for (const line of stdout.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        const [addedRaw, deletedRaw, ...pathParts] = line.split("\t");
+        const path = pathParts.join("\t");
+        if (!path)
+            continue;
+        entries.push({
+            path,
+            added: addedRaw === "-" ? null : Number(addedRaw),
+            deleted: deletedRaw === "-" ? null : Number(deletedRaw),
+        });
+    }
+    return entries;
+}
+async function runUntracked(root) {
+    try {
+        const { stdout } = await execFileAsync("git", ["ls-files", "--others", "--exclude-standard"], { cwd: root, timeout: 5000, encoding: "utf-8", maxBuffer: 1024 * 1024 });
+        return String(stdout)
+            .split(/\r?\n/)
+            .map((s) => s.trim())
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function sumMaybe(a, b) {
+    if (a == null && b == null)
+        return null;
+    return (a ?? 0) + (b ?? 0);
+}
+export async function getGitBranch(root) {
+    try {
+        const { stdout } = await execFileAsync("git", ["branch", "--show-current"], { cwd: root, timeout: 3000, encoding: "utf-8" });
+        const branch = String(stdout).trim();
+        return branch || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/cockpit/lsp-status.d.ts

@@ -0,0 +1,5 @@
+/**
+ * LSP status detector for cockpit rail view.
+ */
+import type { LspStatusEntry } from "./types.js";
+export declare function getLspStatus(root: string): Promise<LspStatusEntry[]>;

package/dist/cockpit/lsp-status.js

@@ -0,0 +1,51 @@
+/**
+ * LSP status detector for cockpit rail view.
+ */
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { pathExists } from "../util/fs.js";
+export async function getLspStatus(root) {
+    const lspConfigPath = join(root, ".omk", "lsp.json");
+    if (await pathExists(lspConfigPath)) {
+        try {
+            const raw = await readFile(lspConfigPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                const config = parsed;
+                if (config.servers && typeof config.servers === "object") {
+                    const enabled = config.enabled !== false;
+                    return Object.keys(config.servers).map((name) => ({
+                        name,
+                        status: enabled ? "connected" : "disabled",
+                    }));
+                }
+            }
+            if (Array.isArray(parsed)) {
+                return parsed
+                    .map((item) => {
+                    if (typeof item !== "object" || item == null)
+                        return null;
+                    const name = String(item.name ?? "unknown");
+                    const enabled = Boolean(item.enabled ?? true);
+                    return { name, status: enabled ? "connected" : "disabled" };
+                })
+                    .filter((e) => e != null);
+            }
+        }
+        catch {
+            // fallthrough to fallback
+        }
+    }
+    // Fallback: detect common LSPs by checking if their config exists
+    const entries = [];
+    if (await pathExists(join(root, "tsconfig.json"))) {
+        entries.push({ name: "typescript", status: "disabled" });
+    }
+    if (await pathExists(join(root, "pyproject.toml"))
+        || await pathExists(join(root, "requirements.txt"))
+        || await pathExists(join(root, "uv.lock"))
+        || await pathExists(join(root, "setup.py"))) {
+        entries.push({ name: "python", status: "disabled" });
+    }
+    return entries;
+}

package/dist/cockpit/types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Cockpit rail view types — slim sidebar status model.
+ */
+export interface CockpitRailModel {
+    title: string;
+    subtitle?: string;
+    context: {
+        tokens?: number;
+        usedPercent?: number;
+        costUsd?: number;
+        elapsed?: string;
+    };
+    mcp: Array<{
+        name: string;
+        status: "connected" | "connecting" | "failed" | "disabled" | "unknown";
+        detail?: string;
+    }>;
+    lsp: Array<{
+        name: string;
+        status: "connected" | "disabled" | "failed" | "unknown";
+    }>;
+    todos: Array<{
+        title: string;
+        status: string;
+        agent?: string;
+    }>;
+    modifiedFiles: Array<{
+        path: string;
+        added?: number;
+        deleted?: number;
+        status: string;
+    }>;
+    providers?: Array<{
+        name: string;
+        status: string;
+        detail?: string;
+    }>;
+    evidence?: {
+        failedGates: number;
+        skippedGates: number;
+        latestVerification: string | null;
+    };
+    tokenBurn?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    cwd: string;
+    branch?: string;
+    runtime: {
+        name: string;
+        version: string;
+        provider?: string;
+    };
+}
+export interface GitNumstatEntry {
+    path: string;
+    added: number | null;
+    deleted: number | null;
+}
+export interface LspStatusEntry {
+    name: string;
+    status: "connected" | "disabled" | "failed" | "unknown";
+    pid?: number;
+    project?: string;
+}

package/dist/cockpit/types.js

@@ -0,0 +1,4 @@
+/**
+ * Cockpit rail view types — slim sidebar status model.
+ */
+export {};

package/dist/cockpit/views/rail-view.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Cockpit rail view — slim sidebar renderer without borders.
+ */
+import type { CockpitRailModel } from "../types.js";
+export interface RailRenderOptions {
+    width: number;
+    height?: number;
+}
+export declare function renderRailView(model: CockpitRailModel, options: RailRenderOptions): string;

package/dist/cockpit/views/rail-view.js

@@ -0,0 +1,160 @@
+/**
+ * Cockpit rail view — slim sidebar renderer without borders.
+ */
+import { style } from "../../util/theme.js";
+import { visibleTerminalWidth, truncateLine, fitHeight, sectionHeader, } from "../../util/terminal-layout.js";
+function statusColor(status) {
+    const s = status.toLowerCase();
+    if (s === "connected" || s === "done" || s === "completed")
+        return style.mint;
+    if (s === "failed")
+        return style.red;
+    if (s === "running" || s === "in_progress")
+        return style.purpleBold;
+    if (s === "blocked")
+        return style.orange;
+    if (s === "disabled" || s === "unknown")
+        return style.gray;
+    return style.gray;
+}
+function todoMarker(status) {
+    const s = status.toLowerCase();
+    if (s === "running" || s === "in_progress")
+        return style.purpleBold("▶");
+    if (s === "done" || s === "completed")
+        return style.mintBold("✓");
+    if (s === "failed")
+        return style.red("✕");
+    if (s === "blocked")
+        return style.orange("■");
+    return style.gray("□");
+}
+const RAIL_LIMITS = {
+    mcp: 18,
+    lsp: 4,
+    todos: 8,
+    modifiedFiles: 12,
+};
+export function renderRailView(model, options) {
+    const width = Math.max(28, Math.min(options.width, 56));
+    const lines = [];
+    // Title
+    lines.push(style.creamBold(truncateLine(model.title, width)));
+    if (model.subtitle) {
+        lines.push(style.gray(truncateLine(model.subtitle, width)));
+    }
+    lines.push("");
+    // Context
+    lines.push(sectionHeader("Context"));
+    if (model.context.tokens != null) {
+        lines.push(style.gray(`${model.context.tokens.toLocaleString()} tokens`));
+    }
+    if (model.context.usedPercent != null) {
+        lines.push(style.gray(`${model.context.usedPercent}% used`));
+    }
+    if (model.context.costUsd != null) {
+        lines.push(style.gray(`$${model.context.costUsd.toFixed(2)} spent`));
+    }
+    if (model.context.elapsed) {
+        lines.push(style.gray(model.context.elapsed));
+    }
+    lines.push("");
+    // Providers
+    if (model.providers && model.providers.length > 0) {
+        lines.push(sectionHeader("Providers"));
+        for (const p of model.providers) {
+            const statusStr = p.status.charAt(0).toUpperCase() + p.status.slice(1);
+            const detail = p.detail ? ` ${style.gray(p.detail)}` : "";
+            const bullet = `${style.gray("•")} ${p.name} ${statusColor(p.status)(statusStr)}${detail}`;
+            lines.push(truncateLine(bullet, width));
+        }
+        lines.push("");
+    }
+    // MCP
+    lines.push(sectionHeader("MCP"));
+    for (const item of model.mcp.slice(0, RAIL_LIMITS.mcp)) {
+        const statusStr = item.status.charAt(0).toUpperCase() + item.status.slice(1);
+        const detail = item.detail ? ` ${style.gray(item.detail)}` : "";
+        const bullet = `${style.gray("•")} ${item.name} ${statusColor(item.status)(statusStr)}${detail}`;
+        lines.push(truncateLine(bullet, width));
+    }
+    if (model.mcp.length > RAIL_LIMITS.mcp) {
+        lines.push(style.gray(`• ${model.mcp.length - RAIL_LIMITS.mcp} more ...`));
+    }
+    lines.push("");
+    // LSP
+    lines.push(sectionHeader("LSP"));
+    if (model.lsp.length === 0) {
+        lines.push(style.gray("LSPs are disabled"));
+    }
+    else {
+        for (const item of model.lsp.slice(0, RAIL_LIMITS.lsp)) {
+            const statusStr = item.status.charAt(0).toUpperCase() + item.status.slice(1);
+            const bullet = `${style.gray("•")} ${item.name} ${statusColor(item.status)(statusStr)}`;
+            lines.push(truncateLine(bullet, width));
+        }
+    }
+    lines.push("");
+    // Todo
+    lines.push(sectionHeader("Todo"));
+    for (const todo of model.todos.slice(0, RAIL_LIMITS.todos)) {
+        const marker = todoMarker(todo.status);
+        const agentBadge = todo.agent ? style.gray(`[${todo.agent}] `) : "";
+        const line = `${marker} ${agentBadge}${truncateLine(todo.title, width - 4)}`;
+        lines.push(truncateLine(line, width));
+    }
+    if (model.todos.length > RAIL_LIMITS.todos) {
+        lines.push(style.gray(`□ ${model.todos.length - RAIL_LIMITS.todos} more ...`));
+    }
+    lines.push("");
+    // Evidence Gates
+    if (model.evidence && (model.evidence.failedGates > 0 || model.evidence.skippedGates > 0)) {
+        lines.push(sectionHeader("Evidence"));
+        if (model.evidence.failedGates > 0) {
+            lines.push(`${style.red("✕")} ${style.gray(`${model.evidence.failedGates} failed`)}`);
+        }
+        if (model.evidence.skippedGates > 0) {
+            lines.push(`${style.orange("■")} ${style.gray(`${model.evidence.skippedGates} skipped`)}`);
+        }
+        if (model.evidence.latestVerification) {
+            lines.push(style.gray(truncateLine(model.evidence.latestVerification, width)));
+        }
+        lines.push("");
+    }
+    // Modified Files
+    lines.push(sectionHeader("Modified Files"));
+    for (const file of model.modifiedFiles.slice(0, RAIL_LIMITS.modifiedFiles)) {
+        lines.push(renderModifiedFile(file, width));
+    }
+    if (model.modifiedFiles.length > RAIL_LIMITS.modifiedFiles) {
+        lines.push(style.gray(`• ${model.modifiedFiles.length - RAIL_LIMITS.modifiedFiles} more ...`));
+    }
+    lines.push("");
+    // cwd / branch
+    lines.push(style.gray(truncateLine(model.cwd, width)));
+    if (model.branch) {
+        lines.push(style.cream(truncateLine(model.branch, width)));
+    }
+    lines.push("");
+    // Runtime footer
+    lines.push(`${style.mint("•")} ${style.gray(`${model.runtime.name} ${model.runtime.version}`)}`);
+    return fitHeight(lines.map((l) => truncateLine(l, width)), options.height).join("\n");
+}
+function renderModifiedFile(file, width) {
+    let delta = "";
+    if (file.added != null || file.deleted != null) {
+        const addedPart = file.added != null ? style.mint(`+${file.added}`) : "";
+        const deletedPart = file.deleted != null ? style.red(` -${file.deleted}`) : "";
+        delta = `${addedPart}${deletedPart}`;
+    }
+    else if (file.status === "??" || file.status.includes("?")) {
+        delta = style.blue("?");
+    }
+    else {
+        delta = style.gray(file.status);
+    }
+    const deltaWidth = visibleTerminalWidth(delta);
+    const pathWidth = Math.max(8, width - deltaWidth - 1);
+    const pathPart = style.gray(truncateLine(file.path, pathWidth));
+    return `${pathPart} ${delta}`;
+}

package/dist/commands/agent.d.ts

@@ -0,0 +1,6 @@
+export declare function agentListCommand(): Promise<void>;
+export declare function agentShowCommand(id: string): Promise<void>;
+export declare function agentCreateCommand(name: string, options: {
+    from?: string;
+}): Promise<void>;
+export declare function agentDoctorCommand(): Promise<void>;