open-multi-agent-kit 0.78.0

package/dist/cli/runtime/runtime-sidecar.js

@@ -0,0 +1,138 @@
+/**
+ * RuntimeSidecarBuilder — builds RuntimeSidecar from CapabilityPlan + envelope.
+ *
+ * Architecture Doc §4: CapabilitySelector → RuntimeSidecar Builder → NLP Prompt Compiler
+ * Builds the filtered, per-turn runtime context that replaces monolithic config injection.
+ */
+/**
+ * Build a RuntimeSidecar from a CapabilityPlan and CommandEnvelope.
+ * This is the main entry point for the sidecar pipeline.
+ */
+export function buildRuntimeSidecar(plan, envelope) {
+    const filteredMcpConfig = filterMcpConfig(plan);
+    const promptInjection = compilePromptInjection(plan, envelope);
+    const envOverrides = buildEnvOverrides(plan, envelope);
+    const outputProfile = resolveOutputProfile(plan, envelope);
+    return {
+        capabilityPlan: plan,
+        filteredMcpConfig,
+        promptInjection,
+        envOverrides,
+        outputProfile,
+    };
+}
+/**
+ * Filter MCP config to only include servers in the capability plan.
+ * Architecture invariant: availableMcp ≠ required activation.
+ */
+function filterMcpConfig(plan) {
+    const activeServers = new Set(plan.mcpServers);
+    const filtered = {};
+    for (const server of activeServers) {
+        // MCP config is resolved at runtime from project config
+        // Here we just mark which servers should be active
+        filtered[server] = { enabled: true, required: plan.providerHints.requireMcp === true };
+    }
+    return filtered;
+}
+/**
+ * Compile NLP prompt injection based on capability plan.
+ * This replaces the old monolithic prompt bloat.
+ */
+function compilePromptInjection(plan, _envelope) {
+    const parts = [];
+    // Skills injection (compact form)
+    if (plan.skills.length > 0) {
+        parts.push(`[skills:${plan.skills.join(",")}]`);
+    }
+    // Hooks injection
+    if (plan.hooks.length > 0) {
+        parts.push(`[hooks:${plan.hooks.join(",")}]`);
+    }
+    // MCP servers
+    if (plan.mcpServers.length > 0) {
+        parts.push(`[mcp:${plan.mcpServers.join(",")}]`);
+    }
+    // Tools
+    if (plan.tools.length > 0) {
+        parts.push(`[tools:${plan.tools.join(",")}]`);
+    }
+    // Prompt mode directive
+    parts.push(`[mode:${plan.promptMode}]`);
+    return parts.join(" ");
+}
+/**
+ * Build environment variable overrides for the sidecar.
+ */
+function buildEnvOverrides(plan, _envelope) {
+    const env = {};
+    env.OMK_CAPABILITY_PLAN = JSON.stringify({
+        skills: plan.skills,
+        mcpServers: plan.mcpServers,
+        hooks: plan.hooks,
+        tools: plan.tools,
+    });
+    env.OMK_PROMPT_MODE = plan.promptMode;
+    if (plan.providerHints.preferProvider) {
+        env.OMK_PREFER_PROVIDER = plan.providerHints.preferProvider;
+    }
+    if (plan.providerHints.requireToolCalling) {
+        env.OMK_REQUIRE_TOOL_CALLING = "true";
+    }
+    return env;
+}
+/**
+ * Resolve output profile from plan and envelope.
+ * Architecture invariant: provider raw stdout ≠ user output.
+ */
+function resolveOutputProfile(plan, envelope) {
+    // Base from envelope
+    const base = envelope.output;
+    // Adjust based on prompt mode
+    switch (plan.promptMode) {
+        case "minimal":
+            return { ...base, format: "silent", includeMessages: false, includeTrace: false };
+        case "compact":
+            return { ...base, includeMessages: false };
+        case "nlp":
+            return { ...base, format: "nlp" };
+        case "full":
+        default:
+            return base;
+    }
+}
+/**
+ * Create a minimal sidecar for sub-agent workers.
+ * Used by ParallelOrchestrator when dispatching tasks.
+ */
+export function createSubAgentSidecar(plan, taskGoal) {
+    return {
+        capabilityPlan: plan,
+        filteredMcpConfig: filterMcpConfig(plan),
+        promptInjection: compilePromptInjection(plan, {
+            kind: "task",
+            input: {
+                source: "argv",
+                rawArgs: [taskGoal],
+                metadata: { cwd: process.cwd(), invokedAt: new Date().toISOString(), isTty: false },
+            },
+            config: { cwd: process.cwd(), env: process.env },
+            output: { format: "nlp", pretty: false, includeMessages: false, includeTrace: false, stream: true, destination: "stdout" },
+            theme: { name: "omk", mode: "dark" },
+            runtime: {},
+        }),
+        envOverrides: buildEnvOverrides(plan, {
+            kind: "task",
+            input: {
+                source: "argv",
+                rawArgs: [taskGoal],
+                metadata: { cwd: process.cwd(), invokedAt: new Date().toISOString(), isTty: false },
+            },
+            config: { cwd: process.cwd(), env: process.env },
+            output: { format: "nlp", pretty: false, includeMessages: false, includeTrace: false, stream: true, destination: "stdout" },
+            theme: { name: "omk", mode: "dark" },
+            runtime: {},
+        }),
+        outputProfile: { format: "nlp", pretty: false, includeMessages: false, includeTrace: false, stream: true, destination: "stdout" },
+    };
+}

package/dist/cli/runtime/task-controller.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Phase 1 — Task Controller
+ * Handles the 'task' command. Adapter shell around the core task runner.
+ * Collects events via EventBus and returns a normalized CliExecutionResult.
+ */
+import type { CommandEnvelope, CliExecutionResult } from "./types.js";
+export declare function handleTaskCommand(envelope: CommandEnvelope): Promise<CliExecutionResult>;

package/dist/cli/runtime/task-controller.js

@@ -0,0 +1,29 @@
+/**
+ * Phase 1 — Task Controller
+ * Handles the 'task' command. Adapter shell around the core task runner.
+ * Collects events via EventBus and returns a normalized CliExecutionResult.
+ */
+import { createCliEventBus } from "./event-bus.js";
+export async function handleTaskCommand(envelope) {
+    const bus = createCliEventBus();
+    // TODO: wire to core task runner once available
+    bus.emit({
+        type: "task-started",
+        taskId: envelope.runtime.runId ?? "task-stub",
+        taskTitle: envelope.input.goal ?? "task",
+        timestamp: new Date().toISOString(),
+    });
+    bus.emit({
+        type: "task-completed",
+        taskId: envelope.runtime.runId ?? "task-stub",
+        taskTitle: envelope.input.goal ?? "task",
+        timestamp: new Date().toISOString(),
+    });
+    return {
+        command: "task",
+        success: true,
+        exitCode: 0,
+        result: { placeholder: true, goal: envelope.input.goal },
+        events: bus.snapshot(),
+    };
+}

package/dist/cli/runtime/types.d.ts

@@ -0,0 +1,312 @@
+/**
+ * Phase 1 — CLI Runtime Types
+ * Normalized command envelope, output profile, execution result, and errors.
+ * Based on the CLI architecture redesign spec (2026-05-25).
+ */
+export type CommandKind = "run" | "task" | "plan" | "chat" | "provider" | "theme" | "doctor";
+export type InputSource = "argv" | "stdin" | "file" | "editor" | "interactive" | "nl-command";
+export type OutputFormat = "json" | "jsonl" | "markdown" | "nlp" | "silent" | "dashboard";
+export interface NormalizedInput {
+    readonly source: InputSource;
+    readonly goal?: string;
+    readonly goalFile?: string;
+    readonly teamFile?: string;
+    readonly taskFile?: string;
+    readonly orchestratorFile?: string;
+    readonly coordinatorFile?: string;
+    readonly rawArgs: readonly string[];
+    readonly metadata: {
+        readonly cwd: string;
+        readonly invokedAt: string;
+        readonly isTty: boolean;
+    };
+}
+export interface OutputProfile {
+    readonly format: OutputFormat;
+    readonly pretty: boolean;
+    readonly includeMessages: boolean;
+    readonly includeTrace: boolean;
+    readonly stream: boolean;
+    readonly destination: "stdout" | "file";
+    readonly outputFile?: string;
+}
+export interface ResolvedTheme {
+    readonly name: string;
+    readonly mode: "dark" | "light" | "auto" | "mono";
+}
+export interface RuntimeOptions {
+    readonly runId?: string;
+    readonly workers?: string;
+    readonly provider?: string;
+    readonly sudo?: boolean;
+}
+export interface CliResolvedConfig {
+    readonly cwd: string;
+    readonly env: NodeJS.ProcessEnv;
+    readonly projectConfig?: Record<string, unknown>;
+    readonly userConfig?: Record<string, unknown>;
+}
+export interface CommandEnvelope {
+    readonly kind: CommandKind;
+    readonly input: NormalizedInput;
+    readonly config: CliResolvedConfig;
+    readonly output: OutputProfile;
+    readonly theme: ResolvedTheme;
+    readonly runtime: RuntimeOptions;
+}
+export type CliErrorKind = "usage" | "validation" | "io" | "provider" | "runtime" | "theme" | "internal";
+export interface NormalizedCliError {
+    readonly kind: CliErrorKind;
+    readonly message: string;
+    readonly cause?: unknown;
+    readonly hint?: string;
+    readonly docsUrl?: string;
+}
+export interface TokenUsageSummary {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly totalTokens: number;
+    readonly model?: string;
+}
+export type NormalizedRunEvent = AgentStartedEvent | AgentCompletedEvent | ProviderRequestStartedEvent | ProviderRequestCompletedEvent | ProviderRequestFailedEvent | ProviderFallbackEvent | ProviderAssistEvent | ProviderSkipEvent | TaskStartedEvent | TaskCompletedEvent | TaskFailedEvent | ToolCalledEvent | TokenUsageEvent | TraceSpanEvent | ApprovalRequestedEvent;
+export interface AgentStartedEvent {
+    readonly type: "agent-started";
+    readonly agentName: string;
+    readonly timestamp: string;
+}
+export interface AgentCompletedEvent {
+    readonly type: "agent-completed";
+    readonly agentName: string;
+    readonly success: boolean;
+    readonly timestamp: string;
+}
+export interface ProviderRequestStartedEvent {
+    readonly type: "provider-request-started";
+    readonly provider: string;
+    readonly taskId: string;
+    readonly taskTitle?: string;
+    readonly role?: string;
+    readonly requestedProvider?: string;
+    readonly authority?: string;
+    readonly reason?: string;
+    readonly timestamp: string;
+}
+export interface ProviderRequestCompletedEvent {
+    readonly type: "provider-request-completed";
+    readonly provider: string;
+    readonly taskId: string;
+    readonly taskTitle?: string;
+    readonly role?: string;
+    readonly requestedProvider?: string;
+    readonly authority?: string;
+    readonly durationMs?: number;
+    readonly attempts?: number;
+    readonly timestamp: string;
+}
+export interface ProviderRequestFailedEvent {
+    readonly type: "provider-request-failed";
+    readonly provider: string;
+    readonly taskId: string;
+    readonly taskTitle?: string;
+    readonly role?: string;
+    readonly requestedProvider?: string;
+    readonly authority?: string;
+    readonly durationMs?: number;
+    readonly attempts?: number;
+    readonly error: string;
+    readonly timestamp: string;
+}
+export interface ProviderFallbackEvent {
+    readonly type: "provider-fallback";
+    readonly taskId: string;
+    readonly from: string;
+    readonly to: string;
+    readonly reason: string;
+    readonly attempts?: number;
+    readonly failureKind?: string;
+    readonly timestamp: string;
+}
+export interface ProviderAssistEvent {
+    readonly type: "provider-assist";
+    readonly taskId: string;
+    readonly provider: string;
+    readonly participation: "advisory";
+    readonly success: boolean;
+    readonly model?: string;
+    readonly modelTier?: string;
+    readonly summary?: string;
+    readonly failureReason?: string;
+    readonly timestamp: string;
+}
+export interface ProviderSkipEvent {
+    readonly type: "provider-skip";
+    readonly taskId: string;
+    readonly provider: string;
+    readonly reason: string;
+    readonly attempts?: number;
+    readonly failureKind?: string;
+    readonly timestamp: string;
+}
+export interface TaskStartedEvent {
+    readonly type: "task-started";
+    readonly taskId: string;
+    readonly taskTitle: string;
+    readonly timestamp: string;
+}
+export interface TaskCompletedEvent {
+    readonly type: "task-completed";
+    readonly taskId: string;
+    readonly taskTitle: string;
+    readonly timestamp: string;
+}
+export interface TaskFailedEvent {
+    readonly type: "task-failed";
+    readonly taskId: string;
+    readonly taskTitle: string;
+    readonly error: string;
+    readonly timestamp: string;
+}
+export interface ToolCalledEvent {
+    readonly type: "tool-called";
+    readonly toolName: string;
+    readonly args: unknown;
+    readonly timestamp: string;
+}
+export interface TokenUsageEvent {
+    readonly type: "token-usage";
+    readonly usage: TokenUsageSummary;
+    readonly timestamp: string;
+}
+export interface TraceSpanEvent {
+    readonly type: "trace-span";
+    readonly spanName: string;
+    readonly durationMs: number;
+    readonly timestamp: string;
+}
+export interface ApprovalRequestedEvent {
+    readonly type: "approval-requested";
+    readonly action: string;
+    readonly timestamp: string;
+}
+export interface CliExecutionResult {
+    readonly command: CommandKind;
+    readonly success: boolean;
+    readonly exitCode: 0 | 1 | 2 | 3;
+    readonly result?: unknown;
+    readonly events: readonly NormalizedRunEvent[];
+    readonly error?: NormalizedCliError;
+    readonly tokenUsage?: TokenUsageSummary;
+}
+export type TaskStatus = "running" | "pending" | "completed" | "failed";
+export interface NlpRenderInput {
+    readonly command: "run" | "task" | "plan";
+    readonly success: boolean;
+    readonly goal?: string;
+    readonly result: unknown;
+    readonly events: readonly NormalizedRunEvent[];
+    readonly tokenUsage?: TokenUsageSummary;
+    readonly errors: readonly NormalizedCliError[];
+}
+export interface RenderedOutput {
+    readonly format: OutputFormat;
+    readonly content: string;
+    readonly sourceResultHash: string;
+    readonly generatedAt: string;
+}
+/**
+ * Intent classification result — rule-based, no LLM required.
+ * Maps user input to a normalized intent kind for capability selection.
+ */
+export type IntentKind = "coding" | "review" | "debugging" | "research" | "planning" | "documentation" | "test-generation" | "refactor" | "shell-operation" | "chat" | "unknown";
+/**
+ * Classified intent with confidence and metadata.
+ */
+export interface ClassifiedIntent {
+    readonly kind: IntentKind;
+    readonly confidence: number;
+    readonly matchedRules: readonly string[];
+    readonly rawInput: string;
+}
+/**
+ * CapabilityPlan — what the runtime sidecar injects for a single turn.
+ * This is the output of CapabilitySelector and the input to RuntimeSidecarBuilder.
+ * Follows the invariant: availableMcp ≠ required activation.
+ */
+export interface CapabilityPlan {
+    readonly skills: readonly string[];
+    readonly mcpServers: readonly string[];
+    readonly hooks: readonly string[];
+    readonly tools: readonly string[];
+    readonly promptMode: "full" | "nlp" | "compact" | "minimal";
+    readonly providerHints: {
+        readonly preferProvider?: string;
+        readonly fallbackProvider?: string;
+        readonly requireToolCalling?: boolean;
+        readonly requireMcp?: boolean;
+    };
+    readonly rationale: string;
+}
+/**
+ * RuntimeSidecar — the filtered, per-turn runtime context.
+ * Built from CapabilityPlan + CommandEnvelope.
+ * This replaces the old monolithic config injection.
+ */
+export interface RuntimeSidecar {
+    readonly capabilityPlan: CapabilityPlan;
+    readonly filteredMcpConfig: Record<string, unknown>;
+    readonly promptInjection: string;
+    readonly envOverrides: Record<string, string>;
+    readonly outputProfile: OutputProfile;
+}
+/**
+ * ProviderAdapter — abstract interface for any LLM provider.
+ * Replaces Kimi-specific wiring. Each provider implements this.
+ */
+export interface ProviderAdapter {
+    readonly name: string;
+    readonly supportsStreaming: boolean;
+    readonly supportsToolCalling: boolean;
+    readonly supportsMcp: boolean;
+    send(request: ProviderRequest): AsyncIterable<ProviderChunk>;
+    abort?(): void;
+}
+export interface ProviderRequest {
+    readonly prompt: string;
+    readonly systemPrompt?: string;
+    readonly tools?: readonly unknown[];
+    readonly mcpConfig?: Record<string, unknown>;
+    readonly sidecar: RuntimeSidecar;
+    readonly signal?: AbortSignal;
+}
+export interface ProviderChunk {
+    readonly type: "text" | "tool_call" | "error" | "done" | "mcp_event";
+    readonly content?: string;
+    readonly toolName?: string;
+    readonly toolArgs?: unknown;
+    readonly error?: string;
+    readonly metadata?: Record<string, unknown>;
+}
+/**
+ * SubAgentTask — a task dispatched to a parallel sub-agent.
+ * Each sub-agent gets its own CapabilityPlan (skills, hooks, MCP).
+ */
+export interface SubAgentTask {
+    readonly id: string;
+    readonly name: string;
+    readonly role: string;
+    readonly goal: string;
+    readonly capabilityPlan: CapabilityPlan;
+    readonly dependsOn: readonly string[];
+    readonly priority: number;
+    readonly timeout?: number;
+}
+/**
+ * OrchestratorGoal — top-level goal managed by the orchestrator.
+ */
+export interface OrchestratorGoal {
+    readonly id: string;
+    readonly objective: string;
+    readonly tasks: readonly SubAgentTask[];
+    readonly maxWorkers: number;
+    readonly status: "pending" | "running" | "completed" | "failed";
+}

package/dist/cli/runtime/types.js

@@ -0,0 +1,6 @@
+/**
+ * Phase 1 — CLI Runtime Types
+ * Normalized command envelope, output profile, execution result, and errors.
+ * Based on the CLI architecture redesign spec (2026-05-25).
+ */
+export {};

package/dist/cli/theme/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * CLI Theme — Barrel export for terminal capability, theme registry, and theme resolver.
+ */
+export { getTerminalCapability, defaultThemeForCapability, } from "./terminal-capability.js";
+export type { TerminalCapability, ColorDepth, } from "./terminal-capability.js";
+export { getBuiltinTheme, listBuiltinThemes, registerBuiltinTheme, __registry, } from "./theme-registry.js";
+export type { SemanticToken, ThemePalette, } from "./theme-registry.js";
+export { resolveTheme } from "./theme-resolver.js";
+export type { ResolveThemeOptions } from "./theme-resolver.js";

package/dist/cli/theme/index.js

@@ -0,0 +1,6 @@
+/**
+ * CLI Theme — Barrel export for terminal capability, theme registry, and theme resolver.
+ */
+export { getTerminalCapability, defaultThemeForCapability, } from "./terminal-capability.js";
+export { getBuiltinTheme, listBuiltinThemes, registerBuiltinTheme, __registry, } from "./theme-registry.js";
+export { resolveTheme } from "./theme-resolver.js";

package/dist/cli/theme/terminal-capability.d.ts

@@ -0,0 +1,18 @@
+/**
+ * CLI Theme — Terminal Capability Detection
+ * Detects color support, unicode, TTY status, and terminal dimensions.
+ */
+export type ColorDepth = 0 | 1 | 4 | 8 | 24;
+export interface TerminalCapability {
+    readonly isTty: boolean;
+    readonly isCi: boolean;
+    readonly colorDisabled: boolean;
+    readonly colorDepth: ColorDepth;
+    readonly unicode: boolean;
+    readonly width: number;
+}
+export declare function getTerminalCapability(): TerminalCapability;
+export declare function defaultThemeForCapability(cap: TerminalCapability): {
+    name: string;
+    mode: "dark" | "light" | "auto" | "mono";
+};

package/dist/cli/theme/terminal-capability.js

@@ -0,0 +1,88 @@
+/**
+ * CLI Theme — Terminal Capability Detection
+ * Detects color support, unicode, TTY status, and terminal dimensions.
+ */
+function detectCi() {
+    return !!(process.env.CI
+        || process.env.CONTINUOUS_INTEGRATION
+        || process.env.BUILD_ID
+        || process.env.BUILD_NUMBER
+        || process.env.GITHUB_ACTIONS
+        || process.env.GITLAB_CI
+        || process.env.TRAVIS
+        || process.env.CIRCLECI
+        || process.env.APPVEYOR
+        || process.env.JENKINS_URL);
+}
+function detectColorDepth() {
+    // Explicit opt-out
+    if (process.env.NO_COLOR !== undefined || process.env.TERM === "dumb") {
+        return 0;
+    }
+    const force = process.env.FORCE_COLOR;
+    if (force === "0" || force === "false")
+        return 0;
+    if (force === "1")
+        return 1;
+    if (force === "2")
+        return 4;
+    if (force === "3")
+        return 8;
+    // 24-bit truecolor
+    if (process.env.COLORTERM === "truecolor" || process.env.COLORTERM === "24bit") {
+        return 24;
+    }
+    // Terminfo-based detection
+    const term = process.env.TERM || "";
+    if (term.includes("256color") || term.includes("256")) {
+        return 8;
+    }
+    if (term.includes("color") || term.includes("xterm") || term.includes("screen") || term.includes("tmux")) {
+        return 4;
+    }
+    // TTY without explicit color support → assume basic ANSI
+    if (process.stdout.isTTY) {
+        return 1;
+    }
+    return 0;
+}
+function detectUnicode() {
+    if (process.env.OMK_UNICODE === "0" || process.env.OMK_UNICODE === "false") {
+        return false;
+    }
+    if (process.env.OMK_UNICODE === "1" || process.env.OMK_UNICODE === "true") {
+        return true;
+    }
+    if (process.platform === "win32") {
+        // Windows Terminal and modern consoles support unicode
+        return !!process.env.WT_SESSION || !!process.env.TERMINAL_EMULATOR;
+    }
+    return process.stdout.isTTY ?? false;
+}
+function getTerminalWidth() {
+    if (typeof process.stdout.columns === "number" && process.stdout.columns > 0) {
+        return process.stdout.columns;
+    }
+    return 80;
+}
+export function getTerminalCapability() {
+    const isCi = detectCi();
+    const colorDepth = detectColorDepth();
+    return {
+        isTty: process.stdout.isTTY ?? false,
+        isCi,
+        colorDisabled: colorDepth === 0,
+        colorDepth,
+        unicode: detectUnicode(),
+        width: getTerminalWidth(),
+    };
+}
+export function defaultThemeForCapability(cap) {
+    if (cap.colorDisabled || cap.colorDepth === 0) {
+        return { name: "mono", mode: "mono" };
+    }
+    if (cap.isCi) {
+        return { name: "minimal", mode: "auto" };
+    }
+    return { name: "omk", mode: "dark" };
+}

package/dist/cli/theme/theme-registry.d.ts

@@ -0,0 +1,25 @@
+/**
+ * CLI Theme — Built-in Theme Registry
+ * Maps semantic tokens to ANSI colors. Reuses src/theme/colors.ts exports.
+ */
+export type SemanticToken = "success" | "warning" | "error" | "info" | "agent" | "task" | "tool" | "header" | "subheader" | "dim" | "bold" | "reset" | "separator" | "bullet" | "labelKey" | "labelValue";
+export interface ThemePalette {
+    readonly name: string;
+    readonly mode: "dark" | "light" | "auto" | "mono";
+    readonly supportsColor: boolean;
+    readonly render: (token: SemanticToken, text: string) => string;
+}
+declare const registry: Map<string, ThemePalette>;
+export declare function getBuiltinTheme(name: string): ThemePalette | undefined;
+export declare function listBuiltinThemes(): readonly string[];
+export declare function registerBuiltinTheme(name: string, palette: ThemePalette): void;
+/**
+ * Render a color swatch preview bar for a theme.
+ * Shows success/warning/error/agent/header colors in labeled blocks.
+ */
+export declare function renderThemePreview(palette: ThemePalette, label?: string): string;
+/**
+ * Render all built-in themes as color swatch previews.
+ */
+export declare function renderAllThemePreviews(): string;
+export { registry as __registry };