open-multi-agent-kit 0.78.0

package/dist/orchestration/log-streamer.js

@@ -0,0 +1,288 @@
+/**
+ * LogStreamer — 병렬 에이전트 로그 스트리밍 및 관리
+ *
+ * 여러 워커의 로그를 실시간으로 스트리밍, 필터링, 포맷팅합니다.
+ */
+import { createWriteStream } from "fs";
+import { mkdir } from "fs/promises";
+import { join } from "path";
+export class LogStreamer {
+    options;
+    logs = [];
+    streams = new Map();
+    eventHandlers = [];
+    consoleStream;
+    constructor(options = {}) {
+        this.options = {
+            logDir: options.logDir ?? ".omk/logs",
+            enableConsole: options.enableConsole ?? true,
+            enableFile: options.enableFile ?? true,
+            bufferSize: options.bufferSize ?? 1000,
+            format: options.format ?? "colored",
+            filter: options.filter ?? {},
+        };
+        this.consoleStream = process.stdout;
+    }
+    /**
+     * 초기화 (로그 디렉토리 생성)
+     */
+    async initialize(runId) {
+        if (this.options.enableFile && runId) {
+            const logPath = join(this.options.logDir, runId);
+            await mkdir(logPath, { recursive: true });
+        }
+    }
+    /**
+     * 워커 로그 핸들 생성
+     */
+    createWorkerHandle(workerId, runId) {
+        let fileStream;
+        if (this.options.enableFile) {
+            const logPath = runId
+                ? join(this.options.logDir, runId, `${workerId}.log`)
+                : join(this.options.logDir, `${workerId}.log`);
+            fileStream = createWriteStream(logPath, { flags: "a" });
+            this.streams.set(workerId, fileStream);
+        }
+        const handle = {
+            workerId,
+            onStdout: (line) => {
+                this.addEntry({
+                    timestamp: new Date().toISOString(),
+                    workerId,
+                    level: "stdout",
+                    message: line,
+                });
+            },
+            onStderr: (line) => {
+                this.addEntry({
+                    timestamp: new Date().toISOString(),
+                    workerId,
+                    level: "stderr",
+                    message: line,
+                });
+            },
+            log: (level, message, metadata) => {
+                this.addEntry({
+                    timestamp: new Date().toISOString(),
+                    workerId,
+                    level,
+                    message,
+                    metadata,
+                });
+            },
+            close: () => {
+                if (fileStream) {
+                    fileStream.end();
+                    this.streams.delete(workerId);
+                }
+            },
+        };
+        return handle;
+    }
+    /**
+     * 로그 엔트리 추가
+     */
+    addEntry(entry) {
+        // 필터 적용
+        if (!this.shouldLog(entry)) {
+            return;
+        }
+        // 버퍼 관리
+        this.logs.push(entry);
+        if (this.logs.length > this.options.bufferSize) {
+            this.logs.shift();
+        }
+        // 콘솔 출력
+        if (this.options.enableConsole) {
+            this.writeToConsole(entry);
+        }
+        // 파일 출력
+        if (this.options.enableFile) {
+            this.writeToFile(entry);
+        }
+        // 이벤트 핸들러 호출
+        for (const handler of this.eventHandlers) {
+            handler(entry);
+        }
+    }
+    /**
+     * 필터 체크
+     */
+    shouldLog(entry) {
+        const { filter } = this.options;
+        if (filter.workers && !filter.workers.includes(entry.workerId)) {
+            return false;
+        }
+        if (filter.levels && !filter.levels.includes(entry.level)) {
+            return false;
+        }
+        if (filter.patterns && filter.patterns.length > 0) {
+            const matches = filter.patterns.some((pattern) => pattern.test(entry.message));
+            if (!matches) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * 콘솔에 로그 출력
+     */
+    writeToConsole(entry) {
+        const formatted = this.formatEntry(entry);
+        this.consoleStream.write(formatted + "\n");
+    }
+    /**
+     * 파일에 로그 출력
+     */
+    writeToFile(entry) {
+        const stream = this.streams.get(entry.workerId);
+        if (stream) {
+            const formatted = this.formatEntry(entry, "json");
+            stream.write(formatted + "\n");
+        }
+    }
+    /**
+     * 로그 엔트리 포맷팅
+     */
+    formatEntry(entry, format) {
+        const useFormat = format ?? this.options.format;
+        if (useFormat === "json") {
+            return JSON.stringify(entry);
+        }
+        const timestamp = entry.timestamp.split("T")[1].replace("Z", "");
+        const prefix = `[${timestamp}] [${entry.workerId}]`;
+        if (useFormat === "colored") {
+            const colors = {
+                stdout: "\x1b[37m", // white
+                stderr: "\x1b[31m", // red
+                info: "\x1b[34m", // blue
+                warn: "\x1b[33m", // yellow
+                error: "\x1b[31m", // red
+            };
+            const reset = "\x1b[0m";
+            const color = colors[entry.level];
+            return `${color}${prefix} [${entry.level.toUpperCase()}]${reset} ${entry.message}`;
+        }
+        return `${prefix} [${entry.level.toUpperCase()}] ${entry.message}`;
+    }
+    /**
+     * 이벤트 핸들러 등록
+     */
+    onLog(handler) {
+        this.eventHandlers.push(handler);
+        return () => {
+            const index = this.eventHandlers.indexOf(handler);
+            if (index !== -1) {
+                this.eventHandlers.splice(index, 1);
+            }
+        };
+    }
+    /**
+     * 로그 조회
+     */
+    getLogs(workerId) {
+        if (workerId) {
+            return this.logs.filter((entry) => entry.workerId === workerId);
+        }
+        return [...this.logs];
+    }
+    /**
+     * 최근 로그 조회
+     */
+    getRecentLogs(count = 50, workerId) {
+        const logs = workerId ? this.getLogs(workerId) : this.logs;
+        return logs.slice(-count);
+    }
+    /**
+     * 로그 기록
+     */
+    log(level, message, metadata) {
+        this.addEntry({
+            timestamp: new Date().toISOString(),
+            workerId: "orchestrator",
+            level,
+            message,
+            metadata,
+        });
+    }
+    /**
+     * 워커 시작 로그
+     */
+    logWorkerStart(worker) {
+        this.addEntry({
+            timestamp: new Date().toISOString(),
+            workerId: worker.nodeId,
+            level: "info",
+            message: `Worker started (retry: ${worker.retryCount}/${worker.maxRetries})`,
+            metadata: { assignment: worker.assignment },
+        });
+    }
+    /**
+     * 워커 완료 로그
+     */
+    logWorkerComplete(worker, success) {
+        this.addEntry({
+            timestamp: new Date().toISOString(),
+            workerId: worker.nodeId,
+            level: success ? "info" : "error",
+            message: success
+                ? `Worker completed in ${worker.durationMs}ms`
+                : `Worker failed: ${worker.error ?? "Unknown error"}`,
+            metadata: {
+                success,
+                durationMs: worker.durationMs,
+                retryCount: worker.retryCount,
+            },
+        });
+    }
+    /**
+     * 이벤트 로그
+     */
+    logEvent(event) {
+        this.addEntry({
+            timestamp: event.timestamp,
+            workerId: event.nodeId ?? "orchestrator",
+            level: "info",
+            message: `Event: ${event.type}`,
+            metadata: event.data,
+        });
+    }
+    /**
+     * 모든 스트림 종료
+     */
+    async close() {
+        for (const [workerId, stream] of this.streams.entries()) {
+            await new Promise((resolve) => {
+                stream.end(() => resolve());
+            });
+            this.streams.delete(workerId);
+        }
+    }
+    /**
+     * 로그 요약 출력
+     */
+    formatSummary() {
+        const lines = [];
+        lines.push("📜 Log Summary");
+        lines.push("─".repeat(50));
+        lines.push(`Total Entries: ${this.logs.length}`);
+        const byLevel = this.logs.reduce((acc, entry) => {
+            acc[entry.level] = (acc[entry.level] || 0) + 1;
+            return acc;
+        }, {});
+        lines.push("By Level:");
+        for (const [level, count] of Object.entries(byLevel)) {
+            lines.push(`  ${level}: ${count}`);
+        }
+        const byWorker = this.logs.reduce((acc, entry) => {
+            acc[entry.workerId] = (acc[entry.workerId] || 0) + 1;
+            return acc;
+        }, {});
+        lines.push("\nBy Worker:");
+        for (const [workerId, count] of Object.entries(byWorker)) {
+            lines.push(`  ${workerId}: ${count} entries`);
+        }
+        return lines.join("\n");
+    }
+}

package/dist/orchestration/loop-artifacts.d.ts

@@ -0,0 +1,14 @@
+import type { InputEnvelope } from "../input/input-envelope.js";
+import type { LoopDecision, OrchestrationLoopState } from "./loop-state.js";
+export interface PersistLoopArtifactsOptions {
+    root: string;
+    runId?: string;
+    nextInputEnvelope?: InputEnvelope;
+}
+export interface PersistLoopArtifactsResult {
+    runDir: string;
+    statePath: string;
+    decisionsPath: string;
+    nextInputPath?: string;
+}
+export declare function persistLoopArtifacts(state: OrchestrationLoopState, decision: LoopDecision, options: PersistLoopArtifactsOptions): Promise<PersistLoopArtifactsResult>;

package/dist/orchestration/loop-artifacts.js

@@ -0,0 +1,20 @@
+import { appendFile, mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+export async function persistLoopArtifacts(state, decision, options) {
+    const runId = options.runId ?? state.runId;
+    const runDir = join(options.root, ".omk", "runs", runId);
+    await mkdir(runDir, { recursive: true });
+    const statePath = join(runDir, "loop-state.json");
+    const decisionsPath = join(runDir, "loop-decisions.jsonl");
+    const nextInputPath = options.nextInputEnvelope
+        ? join(runDir, "next-input-envelope.json")
+        : undefined;
+    await Promise.all([
+        writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`, "utf-8"),
+        appendFile(decisionsPath, `${JSON.stringify(decision)}\n`, "utf-8"),
+        nextInputPath && options.nextInputEnvelope
+            ? writeFile(nextInputPath, `${JSON.stringify(options.nextInputEnvelope, null, 2)}\n`, "utf-8")
+            : Promise.resolve(),
+    ]);
+    return { runDir, statePath, decisionsPath, nextInputPath };
+}

package/dist/orchestration/loop-controller.d.ts

@@ -0,0 +1,14 @@
+import type { DagLoopSnapshot, EvaluateLoopDecisionInput, LoopDecision, OrchestrationLoopState } from "./loop-state.js";
+export declare const DEFAULT_LOOP_MAX_ITERATIONS = 3;
+export declare const HARD_LOOP_MAX_ITERATIONS = 8;
+export declare function evaluateLoopDecision(input: EvaluateLoopDecisionInput): LoopDecision;
+export declare function createLoopState(input: {
+    runId: string;
+    inputId: string;
+    runState: EvaluateLoopDecisionInput["runState"];
+    decision: LoopDecision;
+    parentRunId?: string;
+    maxIterations?: number;
+    now?: () => Date;
+}): OrchestrationLoopState;
+export declare function snapshotRunState(runState: EvaluateLoopDecisionInput["runState"]): DagLoopSnapshot;

package/dist/orchestration/loop-controller.js

@@ -0,0 +1,311 @@
+import { createHash } from "node:crypto";
+export const DEFAULT_LOOP_MAX_ITERATIONS = 3;
+export const HARD_LOOP_MAX_ITERATIONS = 8;
+export function evaluateLoopDecision(input) {
+    const createdAt = (input.now ?? (() => new Date()))().toISOString();
+    const iteration = Math.max(1, input.iteration ?? input.runState.iterationCount ?? 1);
+    const maxIterations = resolveMaxIterations(input.maxIterations ?? input.runState.maxIterations);
+    const snapshot = snapshotRunState(input.runState);
+    const progress = detectProgress(input.previousSnapshot, snapshot);
+    const failedNodes = snapshot.nodeSets.failed;
+    const blockedNodes = snapshot.nodeSets.blocked;
+    const failedGates = collectFailedGates(input.runState.nodes);
+    const pendingNodes = [...snapshot.nodeSets.pending, ...snapshot.nodeSets.running];
+    const requiredEvidenceMissing = collectMissingRequiredEvidence(input.runState.nodes);
+    const risk = assessLoopRisk({
+        snapshot,
+        failedGates,
+        requiredEvidenceMissing,
+        noProgressCount: input.noProgressCount ?? 0,
+    });
+    const common = {
+        nodeSets: snapshot.nodeSets,
+        progress,
+        risk,
+        failedNodes,
+        blockedNodes,
+        pendingNodes,
+        failedGates,
+        requiredEvidenceMissing,
+        iteration,
+        createdAt,
+    };
+    if (iteration >= maxIterations &&
+        (failedNodes.length > 0 ||
+            blockedNodes.length > 0 ||
+            pendingNodes.length > 0 ||
+            requiredEvidenceMissing.length > 0 ||
+            risk.deadlock > 0)) {
+        return buildDecision(input, {
+            action: "block",
+            reason: "Maximum loop iterations reached before required evidence closed",
+            confidence: 0.9,
+            ...common,
+        });
+    }
+    if (input.requestedAction === "verify") {
+        return buildDecision(input, {
+            action: "verify-only",
+            reason: "Operator requested verification-only loop action",
+            confidence: 0.85,
+            ...common,
+        });
+    }
+    if (input.requestedAction === "replan" ||
+        failedNodes.length > 0 ||
+        blockedNodes.length > 0 ||
+        failedGates.length > 0) {
+        return buildDecision(input, {
+            action: "replan",
+            reason: failedNodes.length + blockedNodes.length > 0
+                ? `Run has failed or blocked nodes: ${[...failedNodes, ...blockedNodes].join(", ")}`
+                : "Operator requested replan or gate failures require a new plan",
+            confidence: 0.86,
+            ...common,
+        });
+    }
+    if (risk.deadlock > 0) {
+        return buildDecision(input, {
+            action: "replan",
+            reason: `Pending nodes have no runnable or running path: ${snapshot.nodeSets.pending.join(", ")}`,
+            confidence: 0.84,
+            ...common,
+        });
+    }
+    if (pendingNodes.length === 0 &&
+        failedNodes.length === 0 &&
+        blockedNodes.length === 0 &&
+        failedGates.length === 0 &&
+        requiredEvidenceMissing.length === 0) {
+        return buildDecision(input, {
+            action: "close",
+            reason: "All required nodes and evidence gates are closed",
+            confidence: 0.92,
+            failedNodes: [],
+            blockedNodes: [],
+            pendingNodes: [],
+            nodeSets: snapshot.nodeSets,
+            progress,
+            risk,
+            failedGates,
+            requiredEvidenceMissing,
+            iteration,
+            createdAt,
+        });
+    }
+    if (!progress.madeProgress && (input.noProgressCount ?? 0) >= 2) {
+        return buildDecision(input, {
+            action: "block",
+            reason: "No progress across repeated loop ticks",
+            confidence: 0.82,
+            ...common,
+        });
+    }
+    if (input.requestedAction === "continue" || pendingNodes.length > 0 || requiredEvidenceMissing.length > 0) {
+        return buildDecision(input, {
+            action: "continue",
+            reason: pendingNodes.length > 0
+                ? `Run still has active or pending nodes: ${pendingNodes.join(", ")}`
+                : "Required evidence is not yet recorded",
+            confidence: 0.8,
+            ...common,
+        });
+    }
+    return buildDecision(input, {
+        action: "block",
+        reason: "Loop state did not match a safe continuation or close condition",
+        confidence: 0.7,
+        ...common,
+    });
+}
+export function createLoopState(input) {
+    const now = (input.now ?? (() => new Date()))().toISOString();
+    return {
+        schemaVersion: 1,
+        runId: input.runId,
+        parentRunId: input.parentRunId,
+        inputId: input.inputId,
+        iteration: input.decision.iteration,
+        maxIterations: resolveMaxIterations(input.maxIterations ?? input.runState.maxIterations),
+        status: statusFromDecision(input.decision),
+        decisions: [input.decision],
+        stateSnapshot: {
+            runId: input.runState.runId,
+            iterationCount: input.runState.iterationCount,
+            maxIterations: input.runState.maxIterations,
+            completedAt: input.runState.completedAt,
+        },
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+export function snapshotRunState(runState) {
+    const nodeSets = createEmptyNodeSets();
+    const byId = new Map(runState.nodes.map((node) => [node.id, node]));
+    for (const node of runState.nodes) {
+        if (node.status in nodeSets)
+            nodeSets[node.status].push(node.id);
+    }
+    nodeSets.runnable = runState.nodes
+        .filter((node) => {
+        if (node.status !== "pending")
+            return false;
+        return node.dependsOn.every((dependencyId) => {
+            const dependency = byId.get(dependencyId);
+            return dependency?.status === "done" || dependency?.status === "skipped";
+        });
+    })
+        .map((node) => node.id)
+        .sort();
+    sortNodeSets(nodeSets);
+    const nodes = runState.nodes
+        .map((node) => ({
+        id: node.id,
+        status: node.status,
+        retries: node.retries,
+        maxRetries: node.maxRetries,
+        dependsOn: [...node.dependsOn].sort(),
+        requiredInputs: (node.inputs ?? [])
+            .filter((input) => input.required !== false)
+            .map((input) => input.from ?? input.ref)
+            .filter(Boolean)
+            .sort(),
+        requiredOutputs: (node.outputs ?? [])
+            .filter((output) => output.required !== false)
+            .map((output) => `${output.name}:${output.gate ?? "none"}`)
+            .sort(),
+        evidence: (node.evidence ?? [])
+            .map((evidence) => `${evidence.gate}:${evidence.passed ? "pass" : "fail"}`)
+            .sort(),
+    }))
+        .sort((a, b) => a.id.localeCompare(b.id));
+    const terminalCount = nodeSets.done.length +
+        nodeSets.skipped.length +
+        nodeSets.failed.length +
+        nodeSets.blocked.length;
+    const evidenceCount = nodes.reduce((count, node) => count + node.evidence.length, 0);
+    return {
+        hash: stableHash({ nodes }),
+        nodeSets,
+        terminalCount,
+        evidenceCount,
+        nodes,
+    };
+}
+function detectProgress(previous, current) {
+    if (!previous) {
+        return {
+            previousHash: "",
+            currentHash: current.hash,
+            changedNodes: [],
+            terminalDelta: 0,
+            runnableDelta: current.nodeSets.runnable.length,
+            evidenceDelta: current.evidenceCount,
+            madeProgress: true,
+        };
+    }
+    const previousStatuses = new Map(previous.nodes.map((node) => [node.id, node.status]));
+    const changedNodes = current.nodes
+        .filter((node) => previousStatuses.get(node.id) !== node.status)
+        .map((node) => node.id);
+    const terminalDelta = current.terminalCount - previous.terminalCount;
+    const runnableDelta = current.nodeSets.runnable.length - previous.nodeSets.runnable.length;
+    const evidenceDelta = current.evidenceCount - previous.evidenceCount;
+    return {
+        previousHash: previous.hash,
+        currentHash: current.hash,
+        changedNodes,
+        terminalDelta,
+        runnableDelta,
+        evidenceDelta,
+        madeProgress: previous.hash !== current.hash ||
+            terminalDelta > 0 ||
+            runnableDelta !== 0 ||
+            evidenceDelta > 0 ||
+            changedNodes.length > 0,
+    };
+}
+function assessLoopRisk(input) {
+    const noActiveWork = input.snapshot.nodeSets.running.length === 0 &&
+        input.snapshot.nodeSets.runnable.length === 0;
+    const pendingWithoutRunnable = noActiveWork && input.snapshot.nodeSets.pending.length > 0;
+    const retryExhausted = input.snapshot.nodes.some((node) => node.status === "failed" && node.retries >= node.maxRetries);
+    const blockedRequiredDependency = input.snapshot.nodeSets.blocked.length > 0 ||
+        (pendingWithoutRunnable && (input.snapshot.nodeSets.failed.length > 0 || input.snapshot.nodeSets.blocked.length > 0));
+    return {
+        deadlock: pendingWithoutRunnable ? 1 : 0,
+        livelock: input.noProgressCount >= 2 ? 1 : 0,
+        envPoisoning: 0,
+        retryExhaustion: retryExhausted ? 1 : 0,
+        blockedRequiredDependency: blockedRequiredDependency ? 1 : 0,
+    };
+}
+function buildDecision(input, decision) {
+    return {
+        schemaVersion: 1,
+        runId: input.runId,
+        inputId: input.inputId,
+        ...decision,
+    };
+}
+function statusFromDecision(decision) {
+    if (decision.action === "close")
+        return "closed";
+    if (decision.action === "block" || decision.action === "handoff")
+        return "blocked";
+    if (decision.action === "replan" &&
+        (decision.failedNodes.length > 0 ||
+            decision.blockedNodes.length > 0 ||
+            decision.failedGates.length > 0)) {
+        return "failed";
+    }
+    return "running";
+}
+function resolveMaxIterations(value) {
+    if (value === undefined || !Number.isFinite(value))
+        return DEFAULT_LOOP_MAX_ITERATIONS;
+    return Math.min(HARD_LOOP_MAX_ITERATIONS, Math.max(1, Math.trunc(value)));
+}
+function createEmptyNodeSets() {
+    return {
+        runnable: [],
+        running: [],
+        pending: [],
+        failed: [],
+        blocked: [],
+        done: [],
+        skipped: [],
+    };
+}
+function sortNodeSets(nodeSets) {
+    nodeSets.runnable.sort();
+    nodeSets.running.sort();
+    nodeSets.pending.sort();
+    nodeSets.failed.sort();
+    nodeSets.blocked.sort();
+    nodeSets.done.sort();
+    nodeSets.skipped.sort();
+}
+function stableHash(value) {
+    return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function collectFailedGates(nodes) {
+    return nodes.flatMap((node) => (node.evidence ?? [])
+        .filter((evidence) => evidence.passed === false)
+        .map((evidence) => `${node.id}:${evidence.gate}`));
+}
+function collectMissingRequiredEvidence(nodes) {
+    const missing = [];
+    for (const node of nodes) {
+        for (const output of node.outputs ?? []) {
+            if (output.required === false || !output.gate || output.gate === "none")
+                continue;
+            if (node.status !== "done")
+                continue;
+            const hasPassedEvidence = (node.evidence ?? []).some((evidence) => evidence.gate === output.gate && evidence.passed);
+            if (!hasPassedEvidence)
+                missing.push(`${node.id}:${output.gate}`);
+        }
+    }
+    return missing;
+}

package/dist/orchestration/loop-guard.d.ts

@@ -0,0 +1,28 @@
+export type LoopGuardAction = "new-run" | "continue" | "verify-only" | "stop";
+export interface LoopGuardDecision {
+    action: LoopGuardAction;
+    reason: "new-intent" | "explicit-continue" | "explicit-verification" | "duplicate-prompt" | "duplicate-confirmation-after-completed-run" | "completed-goal-no-new-intent" | "max-loop-guard";
+    confidence: number;
+    visibleMessage?: string;
+    checks?: Array<{
+        kind: "file-exists" | "grep" | "command";
+        target: string;
+        expected?: string;
+    }>;
+}
+export interface LoopGuardInput {
+    root: string;
+    rawPrompt: string;
+    sourceCommand?: string;
+    goalId?: string;
+    runId?: string;
+    previousPrompts?: Array<{
+        hash: string;
+        normalized: string;
+        at: string;
+    }>;
+}
+export declare function normalizePromptForLoopGuard(value: string): string;
+export declare function isVerificationPrompt(value: string): boolean;
+export declare function hashPrompt(value: string): string;
+export declare function evaluatePreOrchestrationGuard(input: LoopGuardInput): Promise<LoopGuardDecision>;