open-multi-agent-kit 0.78.0

package/dist/cli/output/error-renderer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Theme-aware error renderer.
+ * Converts NormalizedCliError into human-readable messages with hints.
+ */
+import type { NormalizedCliError, ResolvedTheme } from "../runtime/types.js";
+export declare function renderError(error: NormalizedCliError, theme?: ResolvedTheme): string;
+/**
+ * Plain-text variant for file output or non-TTY environments.
+ */
+export declare function renderErrorPlain(error: NormalizedCliError): string;

package/dist/cli/output/error-renderer.js

@@ -0,0 +1,68 @@
+import { style, status } from "../../theme/index.js";
+export function renderError(error, theme) {
+    const lines = [];
+    const isMono = theme?.mode === "mono";
+    // Header: kind + message
+    const kindLabel = `[${error.kind.toUpperCase()}]`;
+    if (isMono) {
+        lines.push(`✖ ${kindLabel} ${error.message}`);
+    }
+    else {
+        lines.push(status.fail(kindLabel) + " " + style.redBold(error.message));
+    }
+    // Hint
+    if (error.hint) {
+        if (isMono) {
+            lines.push(`  Hint: ${error.hint}`);
+        }
+        else {
+            lines.push(style.orange("  💡 " + error.hint));
+        }
+    }
+    // Docs URL
+    if (error.docsUrl) {
+        if (isMono) {
+            lines.push(`  Docs: ${error.docsUrl}`);
+        }
+        else {
+            lines.push(style.blue("  📖 " + error.docsUrl));
+        }
+    }
+    // Cause
+    if (error.cause) {
+        const causeText = typeof error.cause === "string"
+            ? error.cause
+            : error.cause instanceof Error
+                ? error.cause.message
+                : JSON.stringify(error.cause);
+        if (isMono) {
+            lines.push(`  Cause: ${causeText}`);
+        }
+        else {
+            lines.push(style.dim + "  Cause: " + causeText + style.reset);
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Plain-text variant for file output or non-TTY environments.
+ */
+export function renderErrorPlain(error) {
+    const lines = [];
+    lines.push(`[${error.kind.toUpperCase()}] ${error.message}`);
+    if (error.hint) {
+        lines.push(`  Hint: ${error.hint}`);
+    }
+    if (error.docsUrl) {
+        lines.push(`  Docs: ${error.docsUrl}`);
+    }
+    if (error.cause) {
+        const causeText = typeof error.cause === "string"
+            ? error.cause
+            : error.cause instanceof Error
+                ? error.cause.message
+                : JSON.stringify(error.cause);
+        lines.push(`  Cause: ${causeText}`);
+    }
+    return lines.join("\n");
+}

package/dist/cli/output/hash.d.ts

@@ -0,0 +1 @@
+export declare function hashResult(result: unknown): string;

package/dist/cli/output/hash.js

@@ -0,0 +1,10 @@
+/**
+ * Small deterministic hash helper for sourceResultHash.
+ */
+import { createHash } from "node:crypto";
+export function hashResult(result) {
+    return createHash("sha256")
+        .update(JSON.stringify(result), "utf-8")
+        .digest("hex")
+        .slice(0, 16);
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Output renderers barrel export.
+ */
+export { routeOutput } from "./output-router.js";
+export { renderJson, renderJsonl } from "./json-renderer.js";
+export { renderMarkdown } from "./markdown-renderer.js";
+export { renderNlp } from "./nlp-renderer.js";
+export { renderError, renderErrorPlain } from "./error-renderer.js";
+export { hashResult } from "./hash.js";

package/dist/cli/output/index.js

@@ -0,0 +1,9 @@
+/**
+ * Output renderers barrel export.
+ */
+export { routeOutput } from "./output-router.js";
+export { renderJson, renderJsonl } from "./json-renderer.js";
+export { renderMarkdown } from "./markdown-renderer.js";
+export { renderNlp } from "./nlp-renderer.js";
+export { renderError, renderErrorPlain } from "./error-renderer.js";
+export { hashResult } from "./hash.js";

package/dist/cli/output/json-renderer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * JSON / JSONL renderer.
+ * Canonical JSON is the source of truth; everything else is a rendering layer.
+ */
+import type { CliExecutionResult, OutputProfile, RenderedOutput } from "../runtime/types.js";
+export declare function renderJson(result: CliExecutionResult, profile: OutputProfile): RenderedOutput;
+export declare function renderJsonl(result: CliExecutionResult, _profile: OutputProfile): RenderedOutput;

package/dist/cli/output/json-renderer.js

@@ -0,0 +1,35 @@
+import { hashResult } from "./hash.js";
+export function renderJson(result, profile) {
+    const space = profile.pretty ? 2 : undefined;
+    const content = JSON.stringify(result, null, space);
+    return {
+        format: "json",
+        content,
+        sourceResultHash: hashResult(result),
+        generatedAt: new Date().toISOString(),
+    };
+}
+export function renderJsonl(result, _profile) {
+    const lines = [];
+    // Summary record
+    lines.push(JSON.stringify({
+        type: "summary",
+        command: result.command,
+        success: result.success,
+        exitCode: result.exitCode,
+        tokenUsage: result.tokenUsage,
+        error: result.error,
+        result: result.result,
+    }));
+    // One record per event
+    for (const event of result.events) {
+        lines.push(JSON.stringify(event));
+    }
+    const content = lines.join("\n");
+    return {
+        format: "jsonl",
+        content,
+        sourceResultHash: hashResult(result),
+        generatedAt: new Date().toISOString(),
+    };
+}

package/dist/cli/output/markdown-renderer.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Markdown report renderer.
+ */
+import type { CliExecutionResult, OutputProfile, RenderedOutput } from "../runtime/types.js";
+export declare function renderMarkdown(result: CliExecutionResult, _profile: OutputProfile): RenderedOutput;

package/dist/cli/output/markdown-renderer.js

@@ -0,0 +1,86 @@
+import { hashResult } from "./hash.js";
+export function renderMarkdown(result, _profile) {
+    const lines = [];
+    const statusIcon = result.success ? "✅" : "❌";
+    lines.push(`# OMK Execution Report`);
+    lines.push(``);
+    lines.push(`| Property | Value |`);
+    lines.push(`|----------|-------|`);
+    lines.push(`| Command  | \`${result.command}\` |`);
+    lines.push(`| Status   | ${statusIcon} ${result.success ? "Success" : "Failed"} |`);
+    lines.push(`| Exit Code| ${result.exitCode} |`);
+    lines.push(``);
+    if (result.tokenUsage) {
+        lines.push(`## Token Usage`);
+        lines.push(``);
+        lines.push(`| Metric | Value |`);
+        lines.push(`|--------|-------|`);
+        lines.push(`| Input Tokens | ${result.tokenUsage.inputTokens.toLocaleString()} |`);
+        lines.push(`| Output Tokens| ${result.tokenUsage.outputTokens.toLocaleString()} |`);
+        lines.push(`| Total Tokens | ${result.tokenUsage.totalTokens.toLocaleString()} |`);
+        if (result.tokenUsage.model) {
+            lines.push(`| Model | ${result.tokenUsage.model} |`);
+        }
+        lines.push(``);
+    }
+    if (result.events.length > 0) {
+        lines.push(`## Events`);
+        lines.push(``);
+        for (const event of result.events) {
+            lines.push(renderEventMarkdown(event));
+        }
+        lines.push(``);
+    }
+    if (result.error) {
+        lines.push(`## Error`);
+        lines.push(``);
+        lines.push(`- **Kind**: \`${result.error.kind}\``);
+        lines.push(`- **Message**: ${result.error.message}`);
+        if (result.error.hint) {
+            lines.push(`- **Hint**: ${result.error.hint}`);
+        }
+        if (result.error.docsUrl) {
+            lines.push(`- **Docs**: [Documentation](${result.error.docsUrl})`);
+        }
+        lines.push(``);
+    }
+    if (result.result !== undefined) {
+        lines.push(`## Result`);
+        lines.push(``);
+        lines.push("```json");
+        lines.push(JSON.stringify(result.result, null, 2));
+        lines.push("```");
+        lines.push(``);
+    }
+    const content = lines.join("\n");
+    return {
+        format: "markdown",
+        content,
+        sourceResultHash: hashResult(result),
+        generatedAt: new Date().toISOString(),
+    };
+}
+function renderEventMarkdown(event) {
+    switch (event.type) {
+        case "agent-started":
+            return `- **Agent Started**: \`${event.agentName}\` at ${event.timestamp}`;
+        case "agent-completed":
+            return `- **Agent Completed**: \`${event.agentName}\` (${event.success ? "success" : "failure"}) at ${event.timestamp}`;
+        case "task-started":
+            return `- **Task Started**: \`${event.taskTitle}\` (${event.taskId}) at ${event.timestamp}`;
+        case "task-completed":
+            return `- **Task Completed**: \`${event.taskTitle}\` (${event.taskId}) at ${event.timestamp}`;
+        case "task-failed":
+            return `- **Task Failed**: \`${event.taskTitle}\` (${event.taskId}) — ${event.error} at ${event.timestamp}`;
+        case "tool-called":
+            return `- **Tool Called**: \`${event.toolName}\` at ${event.timestamp}`;
+        case "token-usage":
+            return `- **Token Usage**: ${event.usage.totalTokens.toLocaleString()} total tokens at ${event.timestamp}`;
+        case "trace-span":
+            return `- **Trace**: \`${event.spanName}\` (${event.durationMs}ms) at ${event.timestamp}`;
+        case "approval-requested":
+            return `- **Approval Requested**: \`${event.action}\` at ${event.timestamp}`;
+        default:
+            return `- **Event**: ${event.type}`;
+    }
+}

package/dist/cli/output/nlp-renderer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Deterministic NLP renderer.
+ * Converts RunResult / events into human-readable natural language.
+ * NO LLM calls — purely rule-based, deterministic text generation.
+ */
+import type { CliExecutionResult, OutputProfile, RenderedOutput } from "../runtime/types.js";
+export declare function renderNlp(result: CliExecutionResult, profile: OutputProfile): RenderedOutput;

package/dist/cli/output/nlp-renderer.js

@@ -0,0 +1,96 @@
+import { hashResult } from "./hash.js";
+export function renderNlp(result, profile) {
+    const sentences = [];
+    // Overall outcome
+    const outcome = result.success ? "completed successfully" : "failed";
+    sentences.push(`The \`${result.command}\` command ${outcome} with exit code ${result.exitCode}.`);
+    // Agent summary
+    const agentsStarted = result.events.filter((e) => e.type === "agent-started");
+    const agentsCompleted = result.events.filter((e) => e.type === "agent-completed");
+    if (agentsStarted.length > 0) {
+        const names = agentsStarted.map((e) => e.agentName);
+        sentences.push(`${agentsStarted.length} agent${agentsStarted.length > 1 ? "s were" : " was"} started: ${names.join(", ")}.`);
+    }
+    const succeededAgents = agentsCompleted
+        .filter((e) => e.success)
+        .map((e) => e.agentName);
+    const failedAgents = agentsCompleted
+        .filter((e) => !e.success)
+        .map((e) => e.agentName);
+    if (succeededAgents.length > 0) {
+        sentences.push(`${succeededAgents.length} agent${succeededAgents.length > 1 ? "s" : ""} finished successfully.`);
+    }
+    if (failedAgents.length > 0) {
+        sentences.push(`${failedAgents.length} agent${failedAgents.length > 1 ? "s" : ""} encountered errors.`);
+    }
+    const providerCompletions = result.events.filter((e) => e.type === "provider-request-completed");
+    const providerFailures = result.events.filter((e) => e.type === "provider-request-failed");
+    const providerFallbacks = result.events.filter((e) => e.type === "provider-fallback");
+    const providerAssists = result.events.filter((e) => e.type === "provider-assist");
+    const providerSkips = result.events.filter((e) => e.type === "provider-skip");
+    if (providerCompletions.length > 0 || providerFailures.length > 0) {
+        const providers = [...new Set([...providerCompletions, ...providerFailures].map((e) => e.provider))];
+        sentences.push(`Provider routing: ${providerCompletions.length} completed, ${providerFailures.length} failed via ${providers.join(", ")}.`);
+    }
+    if (providerFallbacks.length > 0) {
+        sentences.push(`Provider fallback: ${providerFallbacks.map((e) => `${e.from} → ${e.to}`).join(", ")}.`);
+    }
+    if (providerAssists.length > 0) {
+        sentences.push(`Provider advisory: ${providerAssists.length} advisory assist${providerAssists.length > 1 ? "s" : ""} recorded.`);
+    }
+    if (providerSkips.length > 0) {
+        sentences.push(`Provider skips: ${providerSkips.map((e) => e.provider).join(", ")}.`);
+    }
+    // Task summary
+    const tasksStarted = result.events.filter((e) => e.type === "task-started");
+    const tasksCompleted = result.events.filter((e) => e.type === "task-completed");
+    const tasksFailed = result.events.filter((e) => e.type === "task-failed");
+    if (tasksStarted.length > 0) {
+        const remaining = tasksStarted.length - tasksCompleted.length - tasksFailed.length;
+        sentences.push(`Task breakdown: ${tasksCompleted.length} completed, ${tasksFailed.length} failed${remaining > 0 ? `, ${remaining} pending` : ""}.`);
+    }
+    // Tool calls
+    const toolCalls = result.events.filter((e) => e.type === "tool-called");
+    if (toolCalls.length > 0) {
+        const toolNames = [...new Set(toolCalls.map((e) => e.toolName))];
+        sentences.push(`${toolCalls.length} tool call${toolCalls.length > 1 ? "s were" : " was"} made using ${toolNames.join(", ")}.`);
+    }
+    // Token usage
+    if (result.tokenUsage) {
+        const { inputTokens, outputTokens, totalTokens, model } = result.tokenUsage;
+        sentences.push(`Token usage: ${totalTokens.toLocaleString()} total (${inputTokens.toLocaleString()} input, ${outputTokens.toLocaleString()} output)${model ? ` via ${model}` : ""}.`);
+    }
+    // Trace spans
+    const traceSpans = result.events.filter((e) => e.type === "trace-span");
+    if (traceSpans.length > 0) {
+        const totalMs = traceSpans.reduce((sum, e) => sum + e.durationMs, 0);
+        sentences.push(`Execution spanned ${traceSpans.length} trace segment${traceSpans.length > 1 ? "s" : ""} with a combined duration of ${totalMs}ms.`);
+    }
+    // Approval requests
+    const approvals = result.events.filter((e) => e.type === "approval-requested");
+    if (approvals.length > 0) {
+        sentences.push(`${approvals.length} approval request${approvals.length > 1 ? "s were" : " was"} raised.`);
+    }
+    // Error details
+    if (result.error) {
+        sentences.push(`Error: ${result.error.message}`);
+        if (result.error.hint) {
+            sentences.push(`Hint: ${result.error.hint}`);
+        }
+    }
+    // Optional result summary
+    if (result.result !== undefined && profile.includeMessages) {
+        const resultStr = typeof result.result === "string"
+            ? result.result
+            : JSON.stringify(result.result);
+        const truncated = resultStr.length > 500 ? resultStr.slice(0, 500) + "…" : resultStr;
+        sentences.push(`Result: ${truncated}`);
+    }
+    const content = sentences.join("\n\n");
+    return {
+        format: "nlp",
+        content,
+        sourceResultHash: hashResult(result),
+        generatedAt: new Date().toISOString(),
+    };
+}

package/dist/cli/output/output-router.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Output router — selects the correct renderer based on OutputProfile.format.
+ */
+import type { CliExecutionResult, OutputProfile, RenderedOutput } from "../runtime/types.js";
+export declare function routeOutput(result: CliExecutionResult, profile: OutputProfile): RenderedOutput;

package/dist/cli/output/output-router.js

@@ -0,0 +1,33 @@
+import { renderJson, renderJsonl } from "./json-renderer.js";
+import { renderMarkdown } from "./markdown-renderer.js";
+import { renderNlp } from "./nlp-renderer.js";
+import { hashResult } from "./hash.js";
+export function routeOutput(result, profile) {
+    switch (profile.format) {
+        case "json":
+            return renderJson(result, profile);
+        case "jsonl":
+            return renderJsonl(result, profile);
+        case "markdown":
+            return renderMarkdown(result, profile);
+        case "nlp":
+            return renderNlp(result, profile);
+        case "silent": {
+            return {
+                format: "silent",
+                content: "",
+                sourceResultHash: hashResult(result),
+                generatedAt: new Date().toISOString(),
+            };
+        }
+        case "dashboard":
+            // Dashboard is a future rich-TUI format; fallback to NLP for now.
+            return renderNlp(result, profile);
+        default: {
+            // Exhaustive fallback — should never hit because TypeScript narrows.
+            const _exhaustive = profile.format;
+            void _exhaustive;
+            return renderNlp(result, profile);
+        }
+    }
+}

package/dist/cli/register-awareness-commands.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerAwarenessCommands(program: Command): void;

package/dist/cli/register-awareness-commands.js

@@ -0,0 +1,133 @@
+export function registerAwarenessCommands(program) {
+    const appshot = program.command("appshot").description("Capture and manage application screenshots");
+    appshot
+        .command("capture")
+        .description("Capture the active window or full screen")
+        .option("--active-window", "Capture the active window")
+        .option("--screen", "Capture the full screen")
+        .option("--goal <goalId>", "Associate with a goal")
+        .option("--run <runId>", "Associate with a run")
+        .option("--json", "Output JSON")
+        .action(async (options) => {
+        const { appshotCaptureCommand } = await import("../commands/appshot.js");
+        await appshotCaptureCommand(options);
+    });
+    appshot
+        .command("ask <question>")
+        .description("Capture an appshot and attach a question")
+        .option("--active-window", "Capture active window")
+        .option("--screen", "Capture full screen")
+        .option("--goal <goalId>", "Associate with a goal")
+        .option("--run <runId>", "Associate with a run")
+        .option("--json", "Output JSON")
+        .action(async (question, options) => {
+        const { appshotAskCommand } = await import("../commands/appshot.js");
+        await appshotAskCommand(question, options);
+    });
+    appshot
+        .command("dir")
+        .description("Print the appshot directory path")
+        .option("--json", "Output JSON")
+        .action(async (options) => {
+        const { appshotDirCommand } = await import("../commands/appshot.js");
+        await appshotDirCommand(options);
+    });
+    appshot
+        .command("list")
+        .description("List saved appshots")
+        .option("--json", "Output JSON")
+        .action(async (options) => {
+        const { appshotListCommand } = await import("../commands/appshot.js");
+        await appshotListCommand(options);
+    });
+    appshot
+        .command("clean")
+        .description("Remove appshots older than N days")
+        .option("--days <n>", "Age threshold in days", "7")
+        .option("--dry-run", "Show what would be deleted without removing")
+        .option("--json", "Output JSON")
+        .action(async (options) => {
+        const { appshotCleanCommand } = await import("../commands/appshot.js");
+        await appshotCleanCommand(options);
+    });
+    const browser = program
+        .command("browser")
+        .description("Browser feedback runtime — observe, inspect, and feedback on web pages");
+    browser
+        .command("open <url>")
+        .description("Open a URL and capture an observation")
+        .option("--headless", "Run in headless mode")
+        .option("--json", "Output JSON")
+        .action(async (url, options) => {
+        const { browserOpenCommand } = await import("../commands/browser.js");
+        await browserOpenCommand(url, options);
+    });
+    browser
+        .command("inspect")
+        .description("Re-observe the active browser session")
+        .option("--session <sessionId>", "Target session")
+        .option("--json", "Output JSON")
+        .action(async (options) => {
+        const { browserInspectCommand } = await import("../commands/browser.js");
+        await browserInspectCommand(options);
+    });
+    browser
+        .command("feedback <text>")
+        .description("Submit feedback for the active browser session")
+        .option("--session <sessionId>", "Target session")
+        .option("--json", "Output JSON")
+        .action(async (text, options) => {
+        const { browserFeedbackCommand } = await import("../commands/browser.js");
+        await browserFeedbackCommand(text, options);
+    });
+    browser
+        .command("repair <instruction>")
+        .description("Submit a repair instruction for the active browser session")
+        .option("--session <sessionId>", "Target session")
+        .option("--json", "Output JSON")
+        .action(async (instruction, options) => {
+        const { browserRepairCommand } = await import("../commands/browser.js");
+        await browserRepairCommand(instruction, options);
+    });
+    browser
+        .command("close")
+        .description("Close the active browser session")
+        .option("--json", "Output JSON")
+        .action(async (options) => {
+        const { browserCloseCommand } = await import("../commands/browser.js");
+        await browserCloseCommand(options);
+    });
+    browser
+        .command("dir")
+        .description("Print the browser session directory path")
+        .option("--json", "Output JSON")
+        .action(async (options) => {
+        const { browserDirCommand } = await import("../commands/browser.js");
+        await browserDirCommand(options);
+    });
+    const notice = program.command("notice").description("Project notices and awareness alerts");
+    notice
+        .command("list")
+        .description("List active notices")
+        .option("--json", "Output JSON")
+        .action(async (options) => {
+        const { noticeListCommand } = await import("../commands/notice.js");
+        await noticeListCommand(options);
+    });
+    notice
+        .command("act <notice-id>")
+        .description("Act on a notice")
+        .option("--json", "Output JSON")
+        .action(async (noticeId, options) => {
+        const { noticeActCommand } = await import("../commands/notice.js");
+        await noticeActCommand(noticeId, options);
+    });
+    notice
+        .command("explain <notice-id>")
+        .description("Explain a notice")
+        .option("--json", "Output JSON")
+        .action(async (noticeId, options) => {
+        const { noticeExplainCommand } = await import("../commands/notice.js");
+        await noticeExplainCommand(noticeId, options);
+    });
+}

package/dist/cli/register-basic-commands.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerBasicCommands(program: Command): void;