open-multi-agent-kit 0.80.2 → 0.80.4

package/dist/util/json-envelope.d.ts

@@ -1,15 +0,0 @@
-import type { OmkCommandStatus, OmkError, OmkJsonEnvelope, OmkWarning } from "../contracts/index.js";
-export type CreateOmkJsonEnvelopeOptions<TData> = {
-    command: string;
-    status: OmkCommandStatus;
-    data: TData;
-    ok?: boolean;
-    commit?: string;
-    runId?: string;
-    traceId?: string;
-    warnings?: OmkWarning[];
-    errors?: OmkError[];
-    provider?: string;
-    durationMs: number;
-};
-export declare function createOmkJsonEnvelope<TData>(options: CreateOmkJsonEnvelopeOptions<TData>): OmkJsonEnvelope<TData>;

package/dist/util/json-envelope.js

@@ -1,28 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { OMK_CONTRACT_VERSION, OMK_RUNTIME_VERSION, } from "../version.js";
-import { getOmkVersionSync } from "./version.js";
-export function createOmkJsonEnvelope(options) {
-    const ok = options.ok ?? options.status === "passed";
-    return {
-        ok,
-        schemaVersion: OMK_CONTRACT_VERSION,
-        command: options.command,
-        omkVersion: getOmkVersionSync(),
-        runtimeVersion: OMK_RUNTIME_VERSION,
-        ...(options.commit ? { commit: options.commit } : {}),
-        ...(options.runId ? { runId: options.runId } : {}),
-        traceId: options.traceId ?? randomUUID(),
-        status: options.status,
-        data: options.data,
-        warnings: options.warnings ?? [],
-        errors: options.errors ?? [],
-        metadata: {
-            cwd: process.cwd(),
-            platform: process.platform,
-            nodeVersion: process.version,
-            ...(options.provider ? { provider: options.provider } : {}),
-            durationMs: options.durationMs,
-            timestamp: new Date().toISOString(),
-        },
-    };
-}

package/dist/util/mcp-preflight.d.ts

@@ -1,26 +0,0 @@
-export type RuntimeMcpPreflightMode = "warn-skip" | "strict" | "off";
-export type RuntimeMcpPreflightFailureReason = "timeout" | "exit" | "missing-env" | "http-fail" | "stdio-fail";
-export type RuntimeMcpPreflightEntryStatus = "ok" | "failed" | "skipped";
-export interface RuntimeMcpPreflightOptions {
-    timeoutMs: number;
-    concurrency: number;
-}
-export interface RuntimeMcpPreflightEntry {
-    name: string;
-    status: RuntimeMcpPreflightEntryStatus;
-    reason?: RuntimeMcpPreflightFailureReason | "not-npm-family" | "no-package-spec";
-    detail?: string;
-    packageSpec?: string;
-}
-export interface RuntimeMcpPreflightResult {
-    failed: Set<string>;
-    details: Map<string, {
-        reason: RuntimeMcpPreflightFailureReason;
-        detail: string;
-    }>;
-    entries: RuntimeMcpPreflightEntry[];
-}
-export declare function resolveRuntimeMcpPreflightMode(env?: Record<string, string | undefined>): RuntimeMcpPreflightMode;
-export declare function resolveRuntimeMcpPreflightOptions(env?: Record<string, string | undefined>): RuntimeMcpPreflightOptions & {
-    mode: RuntimeMcpPreflightMode;
-};

package/dist/util/mcp-preflight.js

@@ -1,29 +0,0 @@
-export function resolveRuntimeMcpPreflightMode(env = process.env) {
-    const raw = env.OMK_MCP_PREFLIGHT?.trim();
-    if (!raw)
-        return "warn-skip";
-    if (raw === "strict" || raw === "warn-skip")
-        return raw;
-    return "off";
-}
-function resolvePreflightTimeout(env = process.env) {
-    const raw = env.OMK_MCP_PREFLIGHT_TIMEOUT_MS;
-    if (!raw)
-        return 5000;
-    const n = Number.parseInt(raw, 10);
-    return Number.isFinite(n) && n > 0 ? n : 5000;
-}
-function resolvePreflightConcurrency(env = process.env) {
-    const raw = env.OMK_MCP_PREFLIGHT_CONCURRENCY;
-    if (!raw)
-        return 3;
-    const n = Number.parseInt(raw, 10);
-    return Number.isFinite(n) && n > 0 ? n : 3;
-}
-export function resolveRuntimeMcpPreflightOptions(env = process.env) {
-    return {
-        mode: resolveRuntimeMcpPreflightMode(env),
-        timeoutMs: resolvePreflightTimeout(env),
-        concurrency: resolvePreflightConcurrency(env),
-    };
-}

package/dist/util/mode-preset.d.ts

@@ -1,29 +0,0 @@
-/**
- * Mode-preset system for open-multi-agent-kit.
- *
- * Three tabs/modes:
- *   - agent   : interactive orchestrator (execution choice → plan → execute/review)
- *   - plan    : plan-only mode — generates enriched prompt & plan, waits for user approval
- *   - chat    : chat-only mode — GPT-like conversation without code modification
- */
-export type OmkMode = "agent" | "plan" | "chat" | "debugging" | "review";
-export interface ModePreset {
-    name: OmkMode;
-    label: string;
-    description: string;
-    icon: string;
-    behavior: {
-        autoExecute: boolean;
-        planOnly: boolean;
-        chatOnly: boolean;
-        requireApproval: boolean;
-        useDag: boolean;
-    };
-    /** Default CLI command launched when this mode is selected from the TTY selector. */
-    launchCommand: "chat" | "parallel" | "menu" | "review" | "doctor";
-}
-export declare function getModePresets(): ModePreset[];
-export declare function getModePreset(mode: OmkMode): ModePreset | undefined;
-export declare function isValidMode(mode: string): mode is OmkMode;
-export declare function getCurrentMode(): Promise<OmkMode>;
-export declare function setCurrentMode(mode: OmkMode): Promise<void>;

package/dist/util/mode-preset.js

@@ -1,222 +0,0 @@
-/**
- * Mode-preset system for open-multi-agent-kit.
- *
- * Three tabs/modes:
- *   - agent   : interactive orchestrator (execution choice → plan → execute/review)
- *   - plan    : plan-only mode — generates enriched prompt & plan, waits for user approval
- *   - chat    : chat-only mode — GPT-like conversation without code modification
- */
-import { readFile, writeFile } from "fs/promises";
-import { join } from "path";
-import { getProjectRoot } from "./fs.js";
-const PRESETS = [
-    {
-        name: "agent",
-        label: "Agent Orchestrator",
-        description: "Interactive orchestrator: asks parallel vs one-by-one, then coordinates plan/run/review",
-        icon: "🤖",
-        behavior: {
-            autoExecute: true,
-            planOnly: false,
-            chatOnly: false,
-            requireApproval: false,
-            useDag: true,
-        },
-        launchCommand: "chat",
-    },
-    {
-        name: "plan",
-        label: "Plan",
-        description: "Plan-only mode: generates plan and enriched prompt, waits for your approval before executing",
-        icon: "📐",
-        behavior: {
-            autoExecute: false,
-            planOnly: true,
-            chatOnly: false,
-            requireApproval: true,
-            useDag: false,
-        },
-        launchCommand: "menu",
-    },
-    {
-        name: "chat",
-        label: "Chat",
-        description: "Chat-only mode: conversation about the project without code modification",
-        icon: "💬",
-        behavior: {
-            autoExecute: false,
-            planOnly: false,
-            chatOnly: true,
-            requireApproval: false,
-            useDag: false,
-        },
-        launchCommand: "chat",
-    },
-    {
-        name: "debugging",
-        label: "Debug",
-        description: "Debugging mode: focused on bug reproduction, root-cause analysis, and minimal fixes",
-        icon: "🐛",
-        behavior: {
-            autoExecute: true,
-            planOnly: false,
-            chatOnly: false,
-            requireApproval: false,
-            useDag: true,
-        },
-        launchCommand: "chat",
-    },
-    {
-        name: "review",
-        label: "Review",
-        description: "Review mode: focused on code audit, security scan, and quality assessment",
-        icon: "🔍",
-        behavior: {
-            autoExecute: true,
-            planOnly: false,
-            chatOnly: false,
-            requireApproval: false,
-            useDag: true,
-        },
-        launchCommand: "chat",
-    },
-];
-const MODE_CONFIG_KEY = "mode.preset";
-export function getModePresets() {
-    return PRESETS;
-}
-export function getModePreset(mode) {
-    return PRESETS.find((p) => p.name === mode);
-}
-export function isValidMode(mode) {
-    if (mode === "default")
-        return true; // backward compatibility
-    return PRESETS.some((p) => p.name === mode);
-}
-export async function getCurrentMode() {
-    const envMode = process.env.OMK_MODE;
-    if (envMode) {
-        if (envMode === "default")
-            return "agent"; // backward compatibility
-        if (isValidMode(envMode))
-            return envMode;
-    }
-    const config = await readSimpleToml(join(getProjectRoot(), ".omk", "config.toml"));
-    const cfg = config[MODE_CONFIG_KEY];
-    if (cfg) {
-        if (cfg === "default")
-            return "agent"; // backward compatibility
-        if (isValidMode(cfg))
-            return cfg;
-    }
-    return "agent";
-}
-export async function setCurrentMode(mode) {
-    const root = getProjectRoot();
-    const configPath = join(root, ".omk", "config.toml");
-    let content = "";
-    try {
-        content = await readFile(configPath, "utf-8");
-    }
-    catch {
-        // config.toml does not exist yet
-    }
-    const newContent = upsertConfigValue(content, "mode", "preset", mode);
-    await writeFile(configPath, newContent, "utf-8");
-}
-/** Read a simple TOML file into a flat record. */
-async function readSimpleToml(path) {
-    try {
-        const content = await readFile(path, "utf-8");
-        return parseSimpleToml(content);
-    }
-    catch {
-        return {};
-    }
-}
-function parseSimpleToml(content) {
-    const result = {};
-    let section = "";
-    for (const rawLine of content.split(/\r?\n/)) {
-        const line = stripComment(rawLine).trim();
-        if (!line)
-            continue;
-        const sectionMatch = line.match(/^\[([^\]]+)]$/);
-        if (sectionMatch) {
-            section = sectionMatch[1].trim();
-            continue;
-        }
-        const kv = line.match(/^([A-Za-z0-9_.-]+)\s*=\s*(.+)$/);
-        if (!kv)
-            continue;
-        const key = section ? `${section}.${kv[1].trim()}` : kv[1].trim();
-        result[key] = normalizeTomlValue(kv[2].trim());
-    }
-    return result;
-}
-function stripComment(line) {
-    // naive: remove everything after first unquoted #
-    let inString = false;
-    let quoteChar = "";
-    for (let i = 0; i < line.length; i++) {
-        const ch = line[i];
-        if (!inString && (ch === '"' || ch === "'")) {
-            inString = true;
-            quoteChar = ch;
-        }
-        else if (inString && ch === quoteChar && line[i - 1] !== "\\") {
-            inString = false;
-        }
-        else if (!inString && ch === "#") {
-            return line.slice(0, i);
-        }
-    }
-    return line;
-}
-function normalizeTomlValue(value) {
-    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
-        return value.slice(1, -1);
-    }
-    return value;
-}
-function upsertConfigValue(content, section, key, value) {
-    const sectionHeader = `[${section}]`;
-    const lineToSet = `${key} = "${value}"`;
-    // If file is empty, just write the section
-    if (!content.trim()) {
-        return `${sectionHeader}\n${lineToSet}\n`;
-    }
-    const lines = content.split(/\r?\n/);
-    const sectionIdx = lines.findIndex((l) => l.trim() === sectionHeader);
-    if (sectionIdx === -1) {
-        // Section does not exist — append at the end
-        return content.trimEnd() + "\n\n" + sectionHeader + "\n" + lineToSet + "\n";
-    }
-    // Section exists — look for existing key
-    let keyIdx = -1;
-    for (let i = sectionIdx + 1; i < lines.length; i++) {
-        const trimmed = lines[i].trim();
-        if (trimmed.startsWith("["))
-            break; // next section
-        const kv = trimmed.match(new RegExp(`^${key}\\s*=`));
-        if (kv) {
-            keyIdx = i;
-            break;
-        }
-    }
-    if (keyIdx !== -1) {
-        lines[keyIdx] = lineToSet;
-    }
-    else {
-        // Insert at the end of the section (before next section or end)
-        let insertIdx = lines.length;
-        for (let i = sectionIdx + 1; i < lines.length; i++) {
-            if (lines[i].trim().startsWith("[")) {
-                insertIdx = i;
-                break;
-            }
-        }
-        lines.splice(insertIdx, 0, lineToSet);
-    }
-    return lines.join("\n") + "\n";
-}

package/dist/util/mode-selector.d.ts

@@ -1,6 +0,0 @@
-/**
- * TTY raw-mode mode selector.
- * Shows a live-updating mode badge and cycles presets with Tab key.
- */
-import { type OmkMode } from "./mode-preset.js";
-export declare function promptModeCycle(): Promise<OmkMode>;

package/dist/util/mode-selector.js

@@ -1,74 +0,0 @@
-/**
- * TTY raw-mode mode selector.
- * Shows a live-updating mode badge and cycles presets with Tab key.
- */
-import { getCurrentMode, setCurrentMode, getModePresets } from "./mode-preset.js";
-import { style } from "./theme.js";
-import { enableRawTerminalInput, restoreTerminalInputState } from "./terminal-input.js";
-const MODES = ["agent", "plan", "chat", "debugging", "review"];
-export async function promptModeCycle() {
-    const current = await getCurrentMode();
-    let idx = MODES.indexOf(current);
-    if (idx === -1)
-        idx = 0;
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
-        return current;
-    }
-    const preset = () => getModePresets().find((p) => p.name === MODES[idx]);
-    const renderBadge = () => {
-        const p = preset();
-        const badge = p ? `${p.icon} ${style.mintBold(p.label)}` : MODES[idx];
-        const hint = style.gray("[Tab] next  [Shift+Tab] prev  [Enter] start  [Ctrl+C] exit");
-        // Clear current line and rewrite
-        process.stdout.write(`\r\x1B[K  Mode: ${badge}  ${hint}  `);
-    };
-    process.stdout.write("\n");
-    renderBadge();
-    return new Promise((resolve, reject) => {
-        const stdin = process.stdin;
-        const terminalInputState = enableRawTerminalInput(stdin);
-        let cleaned = false;
-        let cleanup = () => undefined;
-        const onData = (data) => {
-            const key = typeof data === "string" ? data : data.toString("utf8");
-            if (key === "\t") {
-                idx = (idx + 1) % MODES.length;
-                renderBadge();
-                return;
-            }
-            // Shift+Tab (ESC [ Z) — reverse cycle
-            if (key === "\x1b[Z") {
-                idx = (idx - 1 + MODES.length) % MODES.length;
-                renderBadge();
-                return;
-            }
-            if (key === "\r" || key === "\n") {
-                cleanup();
-                process.stdout.write("\n");
-                const selected = MODES[idx];
-                if (selected !== current) {
-                    setCurrentMode(selected)
-                        .then(() => resolve(selected))
-                        .catch(reject);
-                }
-                else {
-                    resolve(selected);
-                }
-                return;
-            }
-            if (key === "\u0003" || key === "q" || key === "Q") {
-                cleanup();
-                process.stdout.write("\n");
-                process.exit(0);
-            }
-        };
-        cleanup = () => {
-            if (cleaned)
-                return;
-            cleaned = true;
-            stdin.off("data", onData);
-            restoreTerminalInputState(stdin, terminalInputState);
-        };
-        stdin.on("data", onData);
-    });
-}

package/dist/util/output-buffer.d.ts

@@ -1,12 +0,0 @@
-export declare class CappedOutputBuffer {
-    private readonly maxBytes;
-    private readonly label;
-    private chunks;
-    private bytes;
-    private omittedBytes;
-    private truncated;
-    constructor(maxBytes: number, label?: string);
-    append(value: unknown): void;
-    toString(): string;
-}
-export declare function formatBytes(bytes: number): string;

package/dist/util/output-buffer.js

@@ -1,59 +0,0 @@
-export class CappedOutputBuffer {
-    maxBytes;
-    label;
-    chunks = [];
-    bytes = 0;
-    omittedBytes = 0;
-    truncated = false;
-    constructor(maxBytes, label = "output") {
-        this.maxBytes = maxBytes;
-        this.label = label;
-    }
-    append(value) {
-        const text = String(value ?? "");
-        if (!text)
-            return;
-        const input = Buffer.from(text, "utf8");
-        if (this.maxBytes <= 0) {
-            this.truncated = true;
-            this.omittedBytes += input.byteLength;
-            return;
-        }
-        const remaining = this.maxBytes - this.bytes;
-        if (remaining <= 0) {
-            this.truncated = true;
-            this.omittedBytes += input.byteLength;
-            return;
-        }
-        if (input.byteLength <= remaining) {
-            this.chunks.push(text);
-            this.bytes += input.byteLength;
-            return;
-        }
-        this.chunks.push(input.subarray(0, remaining).toString("utf8"));
-        this.bytes = this.maxBytes;
-        this.omittedBytes += input.byteLength - remaining;
-        this.truncated = true;
-    }
-    toString() {
-        const output = this.chunks.join("");
-        if (!this.truncated)
-            return output;
-        const marker = `\n[omk: ${this.label} truncated at ${formatBytes(this.maxBytes)}; omitted at least ${formatBytes(this.omittedBytes)}]\n`;
-        return `${output}${marker}`;
-    }
-}
-export function formatBytes(bytes) {
-    if (!Number.isFinite(bytes) || bytes < 0)
-        return "unknown";
-    if (bytes < 1024)
-        return `${bytes} B`;
-    const kib = bytes / 1024;
-    if (kib < 1024)
-        return `${kib.toFixed(1)} KiB`;
-    const mib = kib / 1024;
-    if (mib < 1024)
-        return `${mib.toFixed(1)} MiB`;
-    const gib = mib / 1024;
-    return `${gib.toFixed(1)} GiB`;
-}

package/dist/util/process-tree.d.ts

@@ -1,18 +0,0 @@
-export interface ProcessTreeTarget {
-    pid?: number;
-    exitCode?: number | null;
-    signalCode?: NodeJS.Signals | null;
-    kill(signal?: NodeJS.Signals | number): boolean;
-    once(event: "exit" | "close" | "error", listener: (...args: unknown[]) => void): unknown;
-}
-export interface TerminateProcessTreeOptions {
-    graceMs?: number;
-    waitMs?: number;
-    signal?: NodeJS.Signals;
-    forceSignal?: NodeJS.Signals;
-}
-export declare function shouldUseProcessGroup(): boolean;
-export declare function managedChildProcessOptions(): {
-    detached: boolean;
-};
-export declare function terminateProcessTree(target: ProcessTreeTarget, options?: TerminateProcessTreeOptions): Promise<void>;

package/dist/util/process-tree.js

@@ -1,102 +0,0 @@
-import { spawn } from "node:child_process";
-const DEFAULT_GRACE_MS = 1_000;
-const DEFAULT_WAIT_MS = 6_000;
-export function shouldUseProcessGroup() {
-    return process.platform !== "win32";
-}
-export function managedChildProcessOptions() {
-    return { detached: shouldUseProcessGroup() };
-}
-function hasExited(target) {
-    return target.exitCode !== null && target.exitCode !== undefined
-        || target.signalCode !== null && target.signalCode !== undefined;
-}
-function delay(ms) {
-    return new Promise((resolve) => {
-        const timer = setTimeout(resolve, ms);
-        timer.unref?.();
-    });
-}
-function waitForExit(target) {
-    if (hasExited(target))
-        return Promise.resolve();
-    return new Promise((resolve) => {
-        let settled = false;
-        const done = () => {
-            if (settled)
-                return;
-            settled = true;
-            resolve();
-        };
-        target.once("exit", done);
-        target.once("close", done);
-        target.once("error", done);
-    });
-}
-function killWindowsTree(pid, force) {
-    const args = ["/PID", String(pid), "/T"];
-    if (force)
-        args.push("/F");
-    const taskkill = spawn("taskkill", args, { stdio: "ignore", windowsHide: true });
-    taskkill.unref();
-}
-function sendProcessTreeSignal(target, signal, force = false) {
-    const pid = target.pid;
-    if (!pid || pid <= 0)
-        return;
-    if (process.platform === "win32") {
-        try {
-            if (!force)
-                target.kill(signal);
-        }
-        catch {
-            // fall through to taskkill fallback
-        }
-        if (force)
-            killWindowsTree(pid, true);
-        return;
-    }
-    try {
-        process.kill(-pid, signal);
-        return;
-    }
-    catch {
-        // Fall back to the root child when it is not a process-group leader.
-    }
-    try {
-        target.kill(signal);
-    }
-    catch {
-        // ignore missing/already-exited processes
-    }
-}
-export async function terminateProcessTree(target, options = {}) {
-    if (!target.pid)
-        return;
-    if (hasExited(target) && !shouldUseProcessGroup())
-        return;
-    const graceMs = Math.max(0, options.graceMs ?? DEFAULT_GRACE_MS);
-    const waitMs = Math.max(graceMs, options.waitMs ?? DEFAULT_WAIT_MS);
-    const signal = options.signal ?? "SIGTERM";
-    const forceSignal = options.forceSignal ?? "SIGKILL";
-    const exited = waitForExit(target);
-    sendProcessTreeSignal(target, signal, false);
-    let forceSent = false;
-    const sendForce = () => {
-        if (forceSent)
-            return;
-        forceSent = true;
-        sendProcessTreeSignal(target, forceSignal, true);
-    };
-    const forceTimer = setTimeout(sendForce, graceMs);
-    forceTimer.unref?.();
-    await Promise.race([
-        exited.then(() => {
-            if (shouldUseProcessGroup())
-                sendForce();
-        }),
-        delay(graceMs).then(sendForce),
-    ]);
-    clearTimeout(forceTimer);
-    await Promise.race([exited, delay(waitMs)]);
-}

package/dist/util/project-root.d.ts

@@ -1,27 +0,0 @@
-export type ProjectRootSource = "env" | "default-env" | "default-config" | "strong-marker" | "home-git-fallback" | "git" | "cwd";
-export interface ProjectRootResolution {
-    root: string;
-    source: ProjectRootSource;
-    cwd: string;
-    home: string;
-    gitRoot?: string;
-    marker?: string;
-    configuredDefaultProjectRoot?: string;
-    defaultProjectRootError?: string;
-    isHomeRoot: boolean;
-    homeIsGitRepo: boolean;
-    warning?: string;
-    recommendation?: string;
-}
-export interface ResolveProjectRootOptions {
-    cwd?: string;
-    env?: NodeJS.ProcessEnv;
-    home?: string;
-    allowHomeGitRoot?: boolean;
-}
-export declare function resolveProjectRoot(options?: ResolveProjectRootOptions): ProjectRootResolution;
-export declare function resolveProjectRootAsync(options?: ResolveProjectRootOptions): Promise<ProjectRootResolution>;
-export declare function getProjectRoot(): string;
-export declare function getProjectRootAsync(): Promise<string>;
-export declare function getProjectRootDiagnostics(): ProjectRootResolution;
-export declare function displayProjectRootPath(path: string | undefined, home?: string): string | null;