open-multi-agent-kit 0.78.0

package/dist/cli/v2/cli-v2-skeleton.js

@@ -0,0 +1,350 @@
+/**
+ * Section 21 — CLI v2 Full Migration
+ *
+ * Clipanion-based CLI with RuntimeSidecar pipeline integration.
+ * All commands route through CommandBus → IntentClassifier → CapabilitySelector
+ * → RuntimeSidecar → OutputRouter pipeline.
+ *
+ * Enabled via OMK_CLI_V2=1 environment variable.
+ */
+import { Cli, Command, Option } from "clipanion";
+import { createCommandBus } from "../../runtime/command-bus.js";
+import { classifyIntent, selectCapabilities, compileBloatToNlp, filterMcpConfigForTurn, selectProviderRuntime } from "../../runtime/debloat-nlp.js";
+import { createOutputRouter } from "../../runtime/output-router.js";
+import { createPersistentMemoryStore } from "./persistent-memory.js";
+import { registerSlashCommands } from "../../runtime/slash-commands.js";
+import { registerProviderCommandsV2 } from "./provider-commands.js";
+import { registerWorkflowCommandsV2 } from "./workflow-commands.js";
+import { DEFAULT_AUTHORITY_PROVIDER } from "../../providers/types.js";
+/**
+ * Base class for all OMK v2 commands.
+ * Provides common pipeline execution helpers.
+ */
+export class OmkCommand extends Command {
+    static usage = Command.Usage({
+        description: "OMK CLI v2 command base",
+    });
+    cwd = Option.String("--cwd", process.cwd(), { description: "Working directory" });
+    json = Option.Boolean("--json", false, { description: "JSON output" });
+    theme = Option.String("--theme", "");
+    provider = Option.String("--provider", "", { description: "Provider override" });
+    model = Option.String("--model", "", { description: "Model override" });
+    /**
+     * Execute through the full RuntimeSidecar pipeline:
+     * CommandBus → IntentClassifier → CapabilitySelector → RuntimeSidecar → OutputRouter
+     */
+    async executePipeline(userRequest, intent) {
+        const bus = createCommandBus();
+        registerSlashCommands(bus, {
+            provider: this.provider || undefined,
+            model: this.model || undefined,
+            theme: this.theme || undefined,
+        });
+        const busResult = await bus.dispatch({ kind: "chat", source: "cli", rawText: userRequest });
+        // Intent classification (map non-standard intents to valid RequestIntent)
+        const classifiedIntent = classifyIntent(userRequest);
+        const effectiveIntent = (intent === "run" || intent === "model" || intent === "doctor" || intent === "theme" || intent === "memory")
+            ? "chat"
+            : intent || classifiedIntent;
+        // Capability selection
+        const capabilityPlan = selectCapabilities({
+            intent: effectiveIntent,
+            availableMcp: [],
+            availableSkills: [],
+            failedMcp: [],
+        });
+        // Build RuntimeSidecar via debloated NLP compiler
+        const result = compileBloatToNlp({
+            rawText: userRequest,
+            provider: this.provider || undefined,
+            model: this.model || undefined,
+        });
+        const sidecar = result.runtimeSidecar;
+        // Select provider runtime mode
+        const runtimeMode = selectProviderRuntime({
+            provider: sidecar.provider || DEFAULT_AUTHORITY_PROVIDER,
+            intent: effectiveIntent,
+        });
+        // Filter MCP config for this turn
+        const mcpConfig = filterMcpConfigForTurn({
+            userMcpConfig: {},
+            projectMcpConfig: {},
+            sidecar,
+        });
+        const selectedMcpCount = capabilityPlan.requiredMcp.length + capabilityPlan.optionalMcp.length;
+        const selectedSkillCount = capabilityPlan.selectedSkills.length;
+        const filteredMcpCount = Object.keys(mcpConfig.mcpServers).length;
+        // Route output through ThemeRenderer/NlpRenderer/JsonRenderer
+        const outputMode = this.json ? "json" : "theme";
+        const profile = {
+            format: this.json ? "json" : "nlp",
+            progress: "live",
+            color: "auto",
+            rawProvider: false,
+            explainRouting: false,
+            stdoutMode: outputMode,
+        };
+        const router = createOutputRouter(profile);
+        // Emit pipeline result as OmkEvent
+        router.route({
+            type: "result",
+            data: {
+                kind: "result",
+                content: `Pipeline: ${effectiveIntent} → ${runtimeMode} (${sidecar.provider}/${sidecar.model}); capabilities=${selectedMcpCount} MCP/${selectedSkillCount} skills; mcp=${filteredMcpCount}`,
+                format: "nlp",
+            },
+            turnId: Date.now().toString(),
+            timestamp: new Date().toISOString(),
+        });
+        router.flush();
+        // Also emit bus result events
+        for (const ev of busResult.events) {
+            router.route(ev);
+        }
+        router.flush();
+        return 0;
+    }
+}
+/**
+ * `omk chat` — Interactive chat with provider
+ */
+export class ChatCommand extends OmkCommand {
+    static paths = [["chat"]];
+    static usage = Command.Usage({
+        description: "Start interactive chat with provider",
+        examples: [
+            ["Start chat", "omk chat"],
+            ["With message", "omk chat -m 'hello'"],
+        ],
+    });
+    message = Option.String("-m,--message", "");
+    async execute() {
+        if (this.message) {
+            return this.executePipeline(this.message, "chat");
+        }
+        // Interactive REPL mode
+        const { startChatRepl } = await import("./chat-repl.js");
+        await startChatRepl({
+            provider: this.provider,
+            model: this.model,
+            cwd: this.cwd,
+            json: this.json,
+        });
+        return 0;
+    }
+}
+/**
+ * `omk run` — Execute a goal/task through the pipeline
+ */
+export class RunCommand extends OmkCommand {
+    static paths = [["run"]];
+    static usage = Command.Usage({
+        description: "Execute a goal or task file",
+        examples: [["Run a goal", "omk run goal.md"]],
+    });
+    goalArgs = Option.Rest();
+    workers = Option.String("--workers", "");
+    timeout = Option.String("--timeout", "");
+    async execute() {
+        const userRequest = this.goalArgs.length > 0 ? this.goalArgs.join(" ") : "execute pending tasks";
+        // Run pipeline classification (no stdout output)
+        const classifiedIntent = classifyIntent(userRequest);
+        const result = compileBloatToNlp({ rawText: userRequest });
+        const sidecar = result.runtimeSidecar;
+        const runtimeMode = selectProviderRuntime({ provider: sidecar.provider || DEFAULT_AUTHORITY_PROVIDER, intent: classifiedIntent });
+        // Output structured JSON envelope to stdout only
+        this.context.stdout.write(JSON.stringify({ command: "run", result: { placeholder: true, runtimeMode } }) + "\n");
+        return 0;
+    }
+}
+/**
+ * `omk status` — Show current runtime status through pipeline
+ */
+export class StatusCommand extends OmkCommand {
+    static paths = [["status"]];
+    static usage = Command.Usage({
+        description: "Show current OMK runtime status",
+    });
+    async execute() {
+        return this.executePipeline("show current status", "status");
+    }
+}
+/**
+ * `omk model` — Show or set provider/model
+ */
+export class ModelCommand extends OmkCommand {
+    static paths = [["model"]];
+    static usage = Command.Usage({
+        description: "Show or set current provider/model",
+        examples: [
+            ["Show current model", "omk model"],
+            ["Set model", "omk model auto"],
+        ],
+    });
+    targetArgs = Option.Rest();
+    async execute() {
+        const target = this.targetArgs.join(" ");
+        if (target) {
+            process.env.OMK_PROVIDER = target.split("/")[0] ?? "";
+            process.env.OMK_MODEL = target.split("/")[1] ?? "";
+            this.context.stdout.write(`Provider/model set to: ${target}\n`);
+            return 0;
+        }
+        return this.executePipeline("show current model", "model");
+    }
+}
+/**
+ * `omk doctor` — Health check through pipeline
+ */
+export class DoctorCommand extends OmkCommand {
+    static paths = [["doctor"]];
+    static usage = Command.Usage({
+        description: "Run OMK health checks",
+    });
+    async execute() {
+        return this.executePipeline("run health checks", "doctor");
+    }
+}
+/**
+ * `omk memory` — Project memory management
+ */
+export class MemoryCommand extends OmkCommand {
+    static paths = [["memory"]];
+    static usage = Command.Usage({
+        description: "Manage project memory",
+        examples: [
+            ["Show memory", "omk memory show"],
+            ["Search memory", "omk memory search 'last decision'"],
+        ],
+    });
+    args = Option.Rest();
+    async execute() {
+        const store = createPersistentMemoryStore({ cwd: this.cwd });
+        const subcommand = this.args[0] ?? "";
+        const query = this.args.slice(1).join(" ");
+        switch (subcommand) {
+            case "show": {
+                const capsule = await store.load();
+                this.context.stdout.write(JSON.stringify(capsule, null, 2) + "\n");
+                return 0;
+            }
+            case "search": {
+                if (!query) {
+                    this.context.stderr.write("Usage: omk memory search <query>\n");
+                    return 2;
+                }
+                const results = await store.search(query);
+                this.context.stdout.write(JSON.stringify(results, null, 2) + "\n");
+                return 0;
+            }
+            case "clear": {
+                await store.clear();
+                this.context.stdout.write("Memory cleared.\n");
+                return 0;
+            }
+            default: {
+                const capsule = await store.load();
+                this.context.stdout.write(JSON.stringify(capsule, null, 2) + "\n");
+                return 0;
+            }
+        }
+    }
+}
+/**
+ * `omk theme` — Show or set theme
+ */
+export class ThemeCommand extends OmkCommand {
+    static paths = [["theme"]];
+    static usage = Command.Usage({
+        description: "Show or set CLI theme",
+        examples: [
+            ["Show current theme", "omk theme"],
+            ["Set theme", "omk theme dark"],
+            ["Preview theme", "omk theme preview matrix"],
+            ["List all themes", "omk theme list"],
+        ],
+    });
+    nameArgs = Option.Rest({ required: 0 });
+    async execute() {
+        const name = this.nameArgs.join(" ").trim();
+        const subcommand = this.nameArgs[0] ?? "";
+        const target = this.nameArgs.slice(1).join(" ").trim();
+        // omk theme list — show all themes with color swatches
+        if (subcommand === "list") {
+            const { renderAllThemePreviews, getBuiltinTheme } = await import("../theme/theme-registry.js");
+            const current = process.env.OMK_THEME ?? "omk";
+            const currentPalette = getBuiltinTheme(current) ?? getBuiltinTheme("omk");
+            this.context.stdout.write((currentPalette?.render("header", `Current theme: ${current}`) ?? `Current theme: ${current}`) + "\n\n");
+            this.context.stdout.write(renderAllThemePreviews() + "\n");
+            return 0;
+        }
+        // omk theme preview <name> — show color swatch without switching
+        if (subcommand === "preview") {
+            if (!target) {
+                this.context.stderr.write("Usage: omk theme preview <name>\n");
+                return 2;
+            }
+            const { renderThemePreview, getBuiltinTheme, listBuiltinThemes } = await import("../theme/theme-registry.js");
+            const palette = getBuiltinTheme(target);
+            if (!palette) {
+                const available = listBuiltinThemes().join(", ");
+                this.context.stderr.write(`Unknown theme: ${target}\n`);
+                this.context.stderr.write(`Available: ${available}\n`);
+                return 2;
+            }
+            this.context.stdout.write(renderThemePreview(palette) + "\n");
+            const current = process.env.OMK_THEME ?? "omk";
+            this.context.stdout.write(`\nCurrent theme: ${current}. Use \`omk theme ${target}\` to switch.\n`);
+            return 0;
+        }
+        // omk theme <name> — set theme
+        if (name) {
+            process.env.OMK_THEME = name;
+            const { getBuiltinTheme, renderThemePreview } = await import("../theme/theme-registry.js");
+            const palette = getBuiltinTheme(name);
+            if (palette) {
+                this.context.stdout.write(renderThemePreview(palette) + "\n");
+            }
+            this.context.stdout.write(`\nTheme set to: ${name}\n`);
+            return 0;
+        }
+        // omk theme — show current + all with swatches
+        const { renderAllThemePreviews, getBuiltinTheme } = await import("../theme/theme-registry.js");
+        const current = process.env.OMK_THEME ?? "omk";
+        const currentPalette = getBuiltinTheme(current) ?? getBuiltinTheme("omk");
+        this.context.stdout.write((currentPalette?.render("header", `Current theme: ${current}`) ?? `Current theme: ${current}`) + "\n\n");
+        this.context.stdout.write(renderAllThemePreviews() + "\n");
+        return 0;
+    }
+}
+/**
+ * Register all v2 commands on a Clipanion CLI instance.
+ */
+export function createCliV2() {
+    const cli = new Cli({
+        binaryLabel: "OMK CLI",
+        binaryName: "omk",
+        binaryVersion: "1.1.18",
+    });
+    cli.register(ChatCommand);
+    cli.register(RunCommand);
+    cli.register(StatusCommand);
+    cli.register(ModelCommand);
+    cli.register(DoctorCommand);
+    cli.register(MemoryCommand);
+    cli.register(ThemeCommand);
+    // Section 21: Register migrated provider/model commands
+    registerProviderCommandsV2(cli);
+    // Section 21: Register migrated workflow commands
+    registerWorkflowCommandsV2(cli);
+    return cli;
+}
+/**
+ * Run CLI v2 from argv.
+ * Entry point called from main.ts when OMK_CLI_V2=1.
+ */
+export async function runCliV2(argv) {
+    const cli = createCliV2();
+    const exitCode = await cli.run(argv.slice(2));
+    process.exitCode = exitCode;
+}

package/dist/cli/v2/interactive-prompt.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Section 22 P2 — Clack-based interactive prompts
+ *
+ * Provides:
+ * - confirm/select/spinner for interactive workflows
+ * - Provider selection, model selection, theme selection
+ * - Goal input with validation
+ * - Progress feedback during long operations
+ */
+import * as clack from "@clack/prompts";
+import type { RuntimeSidecar } from "../../runtime/debloat-nlp.js";
+/**
+ * Interactive provider selection.
+ * Returns selected provider/model string.
+ */
+export declare function promptProviderSelection(currentProvider?: string, currentModel?: string): Promise<{
+    provider: string;
+    model: string;
+} | null>;
+/**
+ * Interactive theme selection with preview.
+ */
+export declare function promptThemeSelection(currentTheme?: string): Promise<string | null>;
+/**
+ * Interactive goal input with multiline support.
+ */
+export declare function promptGoalInput(): Promise<string | null>;
+/**
+ * Interactive confirmation with sidecar summary.
+ */
+export declare function promptConfirmExecution(sidecar: RuntimeSidecar, goal: string): Promise<boolean>;
+/**
+ * Spinner wrapper for long-running operations.
+ */
+export declare function createSpinner(_label: string): ReturnType<typeof clack.spinner>;
+/**
+ * Interactive MCP server selection from available servers.
+ */
+export declare function promptMcpSelection(available: string[], required: string[], optional: string[]): Promise<{
+    required: string[];
+    optional: string[];
+} | null>;
+/**
+ * Progress reporter using clack spinner.
+ */
+export declare function withSpinner<T>(message: string, fn: () => Promise<T>): Promise<T>;
+/**
+ * Intro/outro for OMK session.
+ */
+export declare function omkIntro(version: string): void;
+export declare function omkOutro(message: string): void;

package/dist/cli/v2/interactive-prompt.js

@@ -0,0 +1,187 @@
+/**
+ * Section 22 P2 — Clack-based interactive prompts
+ *
+ * Provides:
+ * - confirm/select/spinner for interactive workflows
+ * - Provider selection, model selection, theme selection
+ * - Goal input with validation
+ * - Progress feedback during long operations
+ */
+import * as clack from "@clack/prompts";
+/**
+ * Interactive provider selection.
+ * Returns selected provider/model string.
+ */
+export async function promptProviderSelection(currentProvider, currentModel) {
+    const providers = [
+        { value: "auto", label: "Auto-select", hint: "OMK picks best" },
+        { value: "mimo", label: "MiMo", hint: "Default authority" },
+        { value: "codex", label: "Codex", hint: "CLI/runtime" },
+        { value: "deepseek", label: "DeepSeek", hint: "Read-only advisory" },
+        { value: "qwen", label: "Qwen", hint: "OpenAI-compatible" },
+        { value: "openrouter", label: "OpenRouter", hint: "BYOK router" },
+    ];
+    const provider = await clack.select({
+        message: "Select provider:",
+        options: providers,
+        initialValue: currentProvider ?? "auto",
+    });
+    if (clack.isCancel(provider)) {
+        clack.cancel("Cancelled.");
+        return null;
+    }
+    const model = await clack.text({
+        message: `Model for ${provider}:`,
+        placeholder: currentModel ?? getDefaultModel(provider),
+        defaultValue: currentModel ?? getDefaultModel(provider),
+    });
+    if (clack.isCancel(model)) {
+        clack.cancel("Cancelled.");
+        return null;
+    }
+    return { provider, model };
+}
+/**
+ * Interactive theme selection with preview.
+ */
+export async function promptThemeSelection(currentTheme) {
+    const themes = [
+        { value: "omk", label: "OMK", hint: "Default colorful theme" },
+        { value: "night-city", label: "Night City", hint: "README control image palette" },
+        { value: "green-rain", label: "Green Rain", hint: "Phosphor signal console" },
+        { value: "rust-forge", label: "Rust Forge", hint: "Rust/native safety console" },
+        { value: "neon-circuit", label: "Neon Circuit", hint: "High-energy neon terminal" },
+        { value: "matrix", label: "Matrix", hint: "Classic green-on-black phosphor" },
+        { value: "minimal", label: "Minimal", hint: "Clean, few colors" },
+        { value: "mono", label: "Mono", hint: "Monochrome" },
+        { value: "dark", label: "Dark", hint: "Dark terminal optimized" },
+        { value: "light", label: "Light", hint: "Light terminal optimized" },
+    ];
+    const theme = await clack.select({
+        message: "Select theme:",
+        options: themes,
+        initialValue: currentTheme ?? "omk",
+    });
+    if (clack.isCancel(theme)) {
+        clack.cancel("Cancelled.");
+        return null;
+    }
+    return theme;
+}
+/**
+ * Interactive goal input with multiline support.
+ */
+export async function promptGoalInput() {
+    const goal = await clack.text({
+        message: "Enter your goal:",
+        placeholder: "What do you want to accomplish?",
+        validate: (value) => {
+            if (!value || value.trim().length === 0) {
+                return "Goal cannot be empty";
+            }
+            if (value.length < 5) {
+                return "Goal too short — be more specific";
+            }
+        },
+    });
+    if (clack.isCancel(goal)) {
+        clack.cancel("Cancelled.");
+        return null;
+    }
+    return goal;
+}
+/**
+ * Interactive confirmation with sidecar summary.
+ */
+export async function promptConfirmExecution(sidecar, goal) {
+    clack.log.info("Execution plan:");
+    clack.log.message(`  Intent: ${sidecar.intent}`);
+    clack.log.message(`  Risk: ${sidecar.risk}`);
+    clack.log.message(`  Provider: ${sidecar.provider}/${sidecar.model}`);
+    clack.log.message(`  Required MCP: ${sidecar.requiredMcp.length} servers`);
+    clack.log.message(`  Optional MCP: ${sidecar.optionalMcp.length} servers`);
+    clack.log.message(`  Skills: ${sidecar.selectedSkills.length}`);
+    const confirm = await clack.confirm({
+        message: `Execute goal: "${goal.slice(0, 80)}${goal.length > 80 ? "..." : ""}"?`,
+        initialValue: true,
+    });
+    if (clack.isCancel(confirm)) {
+        clack.cancel("Cancelled.");
+        return false;
+    }
+    return confirm;
+}
+/**
+ * Spinner wrapper for long-running operations.
+ */
+export function createSpinner(_label) {
+    return clack.spinner({ indicator: "dots" });
+}
+/**
+ * Interactive MCP server selection from available servers.
+ */
+export async function promptMcpSelection(available, required, optional) {
+    if (available.length === 0) {
+        clack.log.info("No MCP servers available.");
+        return { required: [], optional: [] };
+    }
+    const selected = await clack.multiselect({
+        message: "Select MCP servers for this session:",
+        options: available.map((name) => ({
+            value: name,
+            label: name,
+            hint: required.includes(name)
+                ? "required"
+                : optional.includes(name)
+                    ? "optional"
+                    : undefined,
+        })),
+        initialValues: [...required, ...optional],
+        required: false,
+    });
+    if (clack.isCancel(selected)) {
+        clack.cancel("Cancelled.");
+        return null;
+    }
+    return {
+        required: selected.filter((s) => required.includes(s)),
+        optional: selected.filter((s) => !required.includes(s)),
+    };
+}
+/**
+ * Progress reporter using clack spinner.
+ */
+export async function withSpinner(message, fn) {
+    const s = clack.spinner();
+    s.start(message);
+    try {
+        const result = await fn();
+        s.stop("Done.");
+        return result;
+    }
+    catch (err) {
+        s.stop(`Failed: ${err instanceof Error ? err.message : String(err)}`);
+        throw err;
+    }
+}
+/**
+ * Intro/outro for OMK session.
+ */
+export function omkIntro(version) {
+    clack.intro(`OMK v${version}`);
+}
+export function omkOutro(message) {
+    clack.outro(message);
+}
+// --- Helpers ---
+function getDefaultModel(provider) {
+    const defaults = {
+        auto: "auto",
+        mimo: "mimo-v2.5-pro",
+        codex: "codex-cli",
+        deepseek: "deepseek-v4",
+        qwen: "qwen-coder",
+        openrouter: "openrouter/auto",
+    };
+    return defaults[provider] ?? "default";
+}

package/dist/cli/v2/persistent-memory.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Section 17 — Persistent Project Memory
+ *
+ * 프로젝트 폴더로 들어가면 이전 세션의 상태를 자동 복원:
+ * - last session, open todos, decisions, current branch, known failure patterns
+ *
+ * Memory Mount Flow:
+ *   cwd → ProjectRootResolver → ProjectIdResolver → MemoryStore.open(projectId)
+ *   → ProjectStateCapsule load → Intent-specific retrieval → Context injection
+ *
+ * Storage: .omk/memory/*.md (human-readable, git-friendly)
+ */
+export interface CapsuleTodo {
+    readonly id: string;
+    readonly content: string;
+    readonly status: "pending" | "in_progress" | "completed" | "cancelled";
+    readonly priority: "high" | "medium" | "low";
+    readonly createdAt: string;
+}
+export interface CapsuleDecision {
+    readonly id: string;
+    readonly summary: string;
+    readonly rationale: string;
+    readonly decidedAt: string;
+    readonly reversible: boolean;
+}
+export interface ProjectStateCapsule {
+    readonly projectId: string;
+    readonly rootPath: string;
+    readonly projectName: string;
+    readonly currentBranch?: string;
+    readonly lastSession?: {
+        readonly sessionId: string;
+        readonly endedAt: string;
+        readonly summary: string;
+        readonly lastGoal?: string;
+    };
+    readonly activeTodos: readonly CapsuleTodo[];
+    readonly recentDecisions: readonly CapsuleDecision[];
+    readonly projectInvariants: readonly string[];
+    readonly preferredCommands: readonly string[];
+    readonly knownFailurePatterns: readonly string[];
+    readonly importantFiles: readonly string[];
+    readonly openQuestions: readonly string[];
+    readonly updatedAt: string;
+}
+export interface MemoryStoreOptions {
+    readonly cwd: string;
+    readonly memoryDir?: string;
+}
+export interface MemorySearchResult {
+    readonly file: string;
+    readonly matches: readonly {
+        line: number;
+        text: string;
+    }[];
+}
+export interface PersistentMemoryStore {
+    load(): Promise<ProjectStateCapsule>;
+    save(capsule: Partial<ProjectStateCapsule>): Promise<void>;
+    appendDecision(decision: Omit<CapsuleDecision, "id" | "decidedAt">): Promise<void>;
+    appendTodo(todo: Omit<CapsuleTodo, "id" | "createdAt">): Promise<void>;
+    search(query: string): Promise<MemorySearchResult[]>;
+    clear(): Promise<void>;
+    getMemoryDir(): string;
+}
+/**
+ * Create a persistent memory store for the given project.
+ */
+export declare function createPersistentMemoryStore(options: MemoryStoreOptions): PersistentMemoryStore;