open-multi-agent-kit 0.78.0

package/dist/orchestration/diagnostics.js

@@ -0,0 +1,262 @@
+/**
+ * Diagnostic extraction helpers for evidence-gate failure analysis.
+ *
+ * Extracts structured failure information from command stdout/stderr,
+ * classifies the failure kind, and builds a human-readable diagnosis.
+ */
+import { redactSecrets as redactSecretText } from "../mcp/secret-scanner.js";
+const TAIL_LINES = 30;
+const MAX_DIAGNOSTIC_LEN = 2000;
+export function tailLines(text, n = TAIL_LINES) {
+    const lines = redactSecretText(text).redacted.split("\n");
+    const tail = lines.slice(-n).join("\n");
+    return tail.length > MAX_DIAGNOSTIC_LEN ? tail.slice(0, MAX_DIAGNOSTIC_LEN) : tail;
+}
+export function redactDiagnosticText(text) {
+    return redactSecretText(text).redacted;
+}
+export function classifyFailure(command, exitCode, stderr) {
+    const cmd = command ?? "";
+    const lc = stderr.toLowerCase();
+    // TypeScript build/type errors (check before generic build)
+    if (lc.includes("error ts") ||
+        (lc.includes("tsc") && lc.includes("error")) ||
+        /type\s+error/i.test(stderr) ||
+        /\bts\d{4}\b/.test(stderr) ||
+        cmd.includes("tsc") ||
+        cmd.includes("typecheck") ||
+        cmd.includes("type-check")) {
+        return "type_error";
+    }
+    // Build errors (webpack, vite, esbuild, rollup, next)
+    if (cmd.includes("build") ||
+        cmd.includes("compile") ||
+        lc.includes("build failed") ||
+        lc.includes("compilation error") ||
+        (lc.includes("module not found") && lc.includes("error"))) {
+        return "build_error";
+    }
+    // Test failures (jest, vitest, mocha, ava, tap)
+    if (cmd.includes("test") ||
+        cmd.includes("jest") ||
+        cmd.includes("vitest") ||
+        cmd.includes("mocha") ||
+        cmd.includes("ava") ||
+        lc.includes("test failed") ||
+        lc.includes("assertion") ||
+        lc.includes("expect(") ||
+        /\d+\s+failed/.test(stderr) ||
+        (lc.includes("snapshot") && lc.includes("mismatch"))) {
+        return "test_failure";
+    }
+    // Lint failures (eslint, biome, oxlint)
+    if (cmd.includes("lint") ||
+        cmd.includes("eslint") ||
+        cmd.includes("biome") ||
+        lc.includes("eslint") ||
+        lc.includes("biome") ||
+        (/\d+\s+(error|warning)/i.test(stderr) && lc.includes("lint"))) {
+        return "lint_failure";
+    }
+    // Missing file/module
+    if (lc.includes("enoent") ||
+        lc.includes("no such file") ||
+        lc.includes("cannot find module") ||
+        lc.includes("module not found") ||
+        lc.includes("file not found")) {
+        return "missing_file";
+    }
+    // Policy violations
+    if (lc.includes("policy") ||
+        lc.includes("forbidden") ||
+        lc.includes("blocked") ||
+        lc.includes("not allowed") ||
+        lc.includes("permission denied")) {
+        return "policy_violation";
+    }
+    // Non-zero exit with no other signal
+    if (exitCode !== undefined && exitCode !== 0) {
+        return "ambiguous";
+    }
+    return "ambiguous";
+}
+export function extractTsError(stderr) {
+    // Match: src/file.ts:42:17 - error TS2322: Type 'undefined' is not assignable...
+    const tsPattern = /^(.+?)\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.+)$/m;
+    const tsMatch = stderr.match(tsPattern);
+    if (tsMatch) {
+        const [, file, line, col, code, msg] = tsMatch;
+        return {
+            primaryError: `${code}: ${msg?.trim()}`,
+            location: `${file}:${line}:${col}`,
+            likelyCause: inferTsCause(code ?? "", msg ?? ""),
+            requiredFix: suggestTsFix(code ?? "", msg ?? ""),
+        };
+    }
+    // Alternative: src/file.ts:42:17 - error: Type 'undefined' is not assignable...
+    const altPattern = /^(.+?):(\d+):(\d+):\s+error:\s+(.+)$/m;
+    const altMatch = stderr.match(altPattern);
+    if (altMatch) {
+        const [, file, line, col, msg] = altMatch;
+        return {
+            primaryError: msg?.trim() ?? "",
+            location: `${file}:${line}:${col}`,
+            likelyCause: inferTsCause("", msg ?? ""),
+            requiredFix: suggestTsFix("", msg ?? ""),
+        };
+    }
+    return null;
+}
+export function extractTestError(stderr, stdout) {
+    const combined = stderr + "\n" + stdout;
+    // FAIL path/to/test.ts
+    const failPattern = /FAIL\s+(\S+\.\w+(?:\.\w+)?)/i;
+    const failMatch = combined.match(failPattern);
+    // ● Test suite > test name
+    const testPattern = /●\s+(.+?)$/m;
+    const testMatch = combined.match(testPattern);
+    // expect(received).toBe(expected)
+    const expectPattern = /Expected:\s*(.+?)\nReceived:\s*(.+?)(?:\n|$)/;
+    const expectMatch = combined.match(expectPattern);
+    // Assertion error
+    const assertPattern = /AssertionError:\s*(.+?)(?:\n|$)/i;
+    const assertMatch = combined.match(assertPattern);
+    const file = failMatch?.[1] ?? "";
+    const testName = testMatch?.[1] ?? "";
+    const assertion = expectMatch
+        ? `Expected ${expectMatch[1]?.trim()}, received ${expectMatch[2]?.trim()}`
+        : assertMatch?.[1]?.trim() ?? "";
+    if (!file && !testName && !assertion)
+        return null;
+    return {
+        primaryError: assertion || "Test assertion failed",
+        location: file || testName || "unknown",
+        likelyCause: assertion
+            ? "Logic mismatch between expected and actual behavior"
+            : "Test setup or implementation changed expected behavior",
+        requiredFix: assertion
+            ? `Fix implementation or update expected value: ${assertion.slice(0, 120)}`
+            : "Review test assertions and recent code changes",
+    };
+}
+export function extractLintError(stderr) {
+    // path/file.ts:10:5 error message eslint/rule-name
+    const lintPattern = /^(.+?):(\d+):(\d+)\s+(error|warning)\s+(.+?)\s+(\S+)$/m;
+    const lintMatch = stderr.match(lintPattern);
+    if (lintMatch) {
+        const [, file, line, col, severity, msg, rule] = lintMatch;
+        return {
+            primaryError: `${severity}: ${msg?.trim()} (${rule})`,
+            location: `${file}:${line}:${col}`,
+            likelyCause: `Lint rule '${rule}' violation`,
+            requiredFix: `Fix '${rule}' violation: ${msg?.trim()}`,
+        };
+    }
+    return null;
+}
+export function extractGenericError(stderr) {
+    const lines = stderr.split("\n").filter((l) => l.trim().length > 0);
+    // Find first line with 'error' or 'Error'
+    const errorLine = lines.find((l) => /error/i.test(l)) ?? lines[lines.length - 1] ?? "";
+    return {
+        primaryError: errorLine.trim().slice(0, 200),
+        location: "unknown",
+        likelyCause: "See stderr output for details",
+        requiredFix: "Review error output and fix the reported issue",
+    };
+}
+export function inferTsCause(code, msg) {
+    const lm = msg.toLowerCase();
+    if (code === "TS2322" || lm.includes("not assignable")) {
+        if (lm.includes("undefined"))
+            return "A value that can be undefined is used where a concrete type is required";
+        if (lm.includes("null"))
+            return "A nullable value is used without null check";
+        return "Type mismatch between declaration and usage";
+    }
+    if (code === "TS2307" || lm.includes("cannot find module"))
+        return "Module path is incorrect or dependency is not installed";
+    if (code === "TS2339" || lm.includes("does not exist on type"))
+        return "Property access on wrong type or missing type declaration";
+    if (code === "TS2345" || lm.includes("not assignable to parameter"))
+        return "Argument type does not match function parameter type";
+    if (code === "TS2554" || lm.includes("expected.*arguments"))
+        return "Wrong number of arguments passed to function";
+    if (code === "TS7006")
+        return "Implicit 'any' — add explicit type annotation";
+    if (code === "TS7053")
+        return "Index access on object without index signature";
+    if (lm.includes("import"))
+        return "Import path or named export mismatch";
+    return "Type error — check the reported type mismatch";
+}
+export function suggestTsFix(code, msg) {
+    const lm = msg.toLowerCase();
+    if (code === "TS2322" && lm.includes("undefined"))
+        return "Add explicit guard, default value, or non-null assertion before assignment";
+    if (code === "TS2322" && lm.includes("null"))
+        return "Add null check or use optional chaining before assignment";
+    if (code === "TS2307")
+        return "Verify import path, check package.json, and ensure dependency is installed";
+    if (code === "TS2339")
+        return "Add property to type definition or use type assertion";
+    if (code === "TS2345")
+        return "Cast argument to expected type or update function signature";
+    if (code === "TS2554")
+        return "Add missing arguments or make parameters optional";
+    if (code === "TS7006")
+        return "Add explicit type annotation to the parameter";
+    if (code === "TS7053")
+        return "Add index signature to type or use Record<string, unknown>";
+    return "Fix the type error reported at the indicated location";
+}
+export function buildDiagnosis(kind, extraction) {
+    const parts = [];
+    switch (kind) {
+        case "type_error":
+            parts.push("TypeScript type check failed.");
+            break;
+        case "build_error":
+            parts.push("Build failed.");
+            break;
+        case "test_failure":
+            parts.push("Test execution failed.");
+            break;
+        case "lint_failure":
+            parts.push("Lint check failed.");
+            break;
+        case "missing_file":
+            parts.push("Required file missing.");
+            break;
+        case "policy_violation":
+            parts.push("Policy violation detected.");
+            break;
+        default:
+            parts.push("Command failed.");
+    }
+    if (extraction.location !== "unknown")
+        parts.push(`Location: ${extraction.location}`);
+    parts.push(`Error: ${extraction.primaryError}`);
+    parts.push(`Likely cause: ${extraction.likelyCause}`);
+    parts.push(`Fix: ${extraction.requiredFix}`);
+    return parts.join("\n");
+}
+export function compressDiagnostic(command, exitCode, stdout, stderr) {
+    const kind = classifyFailure(command, exitCode, stderr);
+    let extraction;
+    switch (kind) {
+        case "type_error":
+            extraction = extractTsError(stderr) ?? extractGenericError(stderr);
+            break;
+        case "test_failure":
+            extraction = extractTestError(stderr, stdout) ?? extractGenericError(stderr);
+            break;
+        case "lint_failure":
+            extraction = extractLintError(stderr) ?? extractGenericError(stderr);
+            break;
+        default:
+            extraction = extractGenericError(stderr);
+    }
+    const diagnosis = buildDiagnosis(kind, extraction);
+    return { failureKind: kind, diagnosis };
+}

package/dist/orchestration/enhanced-modes.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Enhanced Orchestration Modes — think, mcp, skills, variant
+ *
+ * 단일 모델 DAG subagents 알고리즘 고도화:
+ *  - think:  CoT/추론 트레이싱 (thinking traces)
+ *  - mcp:    Model Context Protocol 서버 라이브 바인딩
+ *  - skills: 스킬 자동 할당 + 사용 증거 추적
+ *  - variant: 동일 작업에 여러 variant 실행 → 최적 결과 선택
+ */
+import type { DagNode, DagNodeRouting } from "./dag.js";
+export type EnhancedMode = "think" | "mcp" | "skills" | "variant";
+export declare const ALL_ENHANCED_MODES: readonly EnhancedMode[];
+export interface EnhancedModeConfig {
+    /** 활성화된 모드 목록 */
+    modes: readonly EnhancedMode[];
+    /** variant 모드일 때 실행할 variant 수 (기본 3) */
+    variantCount: number;
+    /** variant 선택 전략 */
+    variantStrategy: "majority-vote" | "best-score" | "first-pass" | "ensemble";
+    /** thinking trace verbosity */
+    thinkingLevel: "brief" | "normal" | "verbose";
+    /** MCP 서버 목록 (빈 배열이면 discovery 자동) */
+    mcpServers: readonly string[];
+    /** Skills 강제 할당 (빈 배열이면 auto-assign) */
+    forcedSkills: readonly string[];
+    /** Hooks 강제 할당 (빈 배열이면 auto-assign) */
+    forcedHooks: readonly string[];
+}
+export declare const DEFAULT_ENHANCED_CONFIG: EnhancedModeConfig;
+export declare const FULL_ENHANCED_CONFIG: EnhancedModeConfig;
+export interface ThinkingTrace {
+    nodeId: string;
+    runId: string;
+    variantIndex?: number;
+    timestamp: string;
+    content: string;
+    step: number;
+}
+export interface ThinkingSession {
+    nodeId: string;
+    runId: string;
+    variantIndex: number;
+    traces: ThinkingTrace[];
+    startedAt: string;
+    completedAt?: string;
+}
+export declare function createThinkingSession(nodeId: string, runId: string, variantIndex?: number): ThinkingSession;
+export declare function addThinkingTrace(session: ThinkingSession, content: string): ThinkingTrace;
+export interface McpServerBinding {
+    serverName: string;
+    transport: "stdio" | "streamable-http";
+    command?: string;
+    args?: string[];
+    url?: string;
+    capabilities: string[];
+    status: "connected" | "disconnected" | "error";
+    lastActivityAt?: string;
+}
+export declare function buildMcpBindingsForNode(node: DagNode, availableServers: readonly McpServerBinding[]): McpServerBinding[];
+export interface SkillEvidence {
+    skillName: string;
+    nodeId: string;
+    runId: string;
+    used: boolean;
+    evidenceRef?: string;
+    evidenceGate?: string;
+    assignedAt: string;
+}
+export declare function createSkillEvidence(skillName: string, nodeId: string, runId: string): SkillEvidence;
+export interface NodeVariant {
+    index: number;
+    node: DagNode;
+    /** variant-specific routing override */
+    routingOverride: Partial<DagNodeRouting>;
+    priority: number;
+    assignedModel?: string;
+}
+export interface VariantResult {
+    variant: NodeVariant;
+    success: boolean;
+    score: number;
+    stdout: string;
+    stderr: string;
+    thinkingSession?: ThinkingSession;
+    skillEvidences: SkillEvidence[];
+    metadata?: Record<string, unknown>;
+}
+export interface VariantSelection {
+    selected: VariantResult;
+    allResults: VariantResult[];
+    strategy: EnhancedModeConfig["variantStrategy"];
+    rationale: string;
+}
+export declare function createNodeVariants(node: DagNode, count: number, modeConfig: EnhancedModeConfig): NodeVariant[];
+export declare function selectBestVariant(results: VariantResult[], strategy: EnhancedModeConfig["variantStrategy"]): VariantSelection;
+export interface ModeRoutingInjection {
+    /** think 모드 추론 프롬프트 확장 */
+    reasoningPrompt?: string;
+    /** think 모드 생각할 시간 (ms) */
+    thinkingBudgetMs?: number;
+    /** MCP 서버 목록 */
+    mcpServers: string[];
+    /** 스킬 목록 */
+    skills: string[];
+    /** 훅 목록 */
+    hooks: string[];
+    /** 툴 목록 */
+    tools: string[];
+    /** MCP 필수 여부 */
+    requiresMcp: boolean;
+    /** 툴 콜링 필수 여부 */
+    requiresToolCalling: boolean;
+    /** Evidence 필수 여부 */
+    evidenceRequired: boolean;
+}
+export declare function buildModeRoutingInjection(node: DagNode, modeConfig: EnhancedModeConfig, nodeSkills: string[], nodeMcpServers: string[], nodeHooks: string[], nodeTools: string[]): ModeRoutingInjection;

package/dist/orchestration/enhanced-modes.js

@@ -0,0 +1,231 @@
+/**
+ * Enhanced Orchestration Modes — think, mcp, skills, variant
+ *
+ * 단일 모델 DAG subagents 알고리즘 고도화:
+ *  - think:  CoT/추론 트레이싱 (thinking traces)
+ *  - mcp:    Model Context Protocol 서버 라이브 바인딩
+ *  - skills: 스킬 자동 할당 + 사용 증거 추적
+ *  - variant: 동일 작업에 여러 variant 실행 → 최적 결과 선택
+ */
+export const ALL_ENHANCED_MODES = [
+    "think", "mcp", "skills", "variant",
+];
+export const DEFAULT_ENHANCED_CONFIG = {
+    modes: ["think", "mcp", "skills"],
+    variantCount: 3,
+    variantStrategy: "best-score",
+    thinkingLevel: "normal",
+    mcpServers: [],
+    forcedSkills: [],
+    forcedHooks: [],
+};
+export const FULL_ENHANCED_CONFIG = {
+    modes: ["think", "mcp", "skills", "variant"],
+    variantCount: 3,
+    variantStrategy: "ensemble",
+    thinkingLevel: "verbose",
+    mcpServers: [],
+    forcedSkills: [],
+    forcedHooks: [],
+};
+export function createThinkingSession(nodeId, runId, variantIndex = 0) {
+    return {
+        nodeId,
+        runId,
+        variantIndex,
+        traces: [],
+        startedAt: new Date().toISOString(),
+    };
+}
+export function addThinkingTrace(session, content) {
+    const trace = {
+        nodeId: session.nodeId,
+        runId: session.runId,
+        variantIndex: session.variantIndex,
+        timestamp: new Date().toISOString(),
+        content,
+        step: session.traces.length + 1,
+    };
+    session.traces.push(trace);
+    return trace;
+}
+export function buildMcpBindingsForNode(node, availableServers) {
+    const wanted = node.routing?.mcpServers ?? [];
+    if (wanted.length === 0)
+        return [];
+    return wanted
+        .map((name) => availableServers.find((s) => s.serverName === name))
+        .filter((s) => s !== undefined);
+}
+export function createSkillEvidence(skillName, nodeId, runId) {
+    return {
+        skillName,
+        nodeId,
+        runId,
+        used: false,
+        assignedAt: new Date().toISOString(),
+    };
+}
+export function createNodeVariants(node, count, modeConfig) {
+    if (!modeConfig.modes.includes("variant") || count <= 1) {
+        return [
+            {
+                index: 0,
+                node,
+                routingOverride: {},
+                priority: node.priority ?? 0,
+            },
+        ];
+    }
+    return Array.from({ length: count }, (_, i) => ({
+        index: i,
+        node: { ...node, id: `${node.id}-v${i}` },
+        routingOverride: {
+            ...(i > 0
+                ? {
+                    providerModel: variantModelHint(node, i),
+                    contextBudget: "normal",
+                }
+                : {}),
+        },
+        priority: (node.priority ?? 0) + (count - i),
+        assignedModel: variantModelHint(node, i),
+    }));
+}
+function variantModelHint(node, index) {
+    const baseModel = node.routing?.providerModel ?? node.routing?.assignedModel;
+    if (!baseModel || index === 0)
+        return baseModel;
+    // variant 1, 2 에 대해 다른 temperature/model hint
+    const hints = [
+        baseModel,
+        `${baseModel}-high`,
+        `${baseModel}-creative`,
+    ];
+    return hints[index] ?? baseModel;
+}
+export function selectBestVariant(results, strategy) {
+    if (results.length === 0) {
+        throw new Error("No variant results to select from");
+    }
+    const successful = results.filter((r) => r.success);
+    const candidates = successful.length > 0 ? successful : results;
+    switch (strategy) {
+        case "majority-vote": {
+            // 점수가 가장 많이 동의된 variant 선택
+            const sorted = [...candidates].sort((a, b) => b.score - a.score);
+            return {
+                selected: sorted[0],
+                allResults: results,
+                strategy,
+                rationale: `Majority vote selected variant ${sorted[0].variant.index} with score ${sorted[0].score} out of ${results.length} variants (${successful.length} successful)`,
+            };
+        }
+        case "best-score":
+        default: {
+            const best = candidates.reduce((best, cur) => cur.score > best.score ? cur : best);
+            return {
+                selected: best,
+                allResults: results,
+                strategy,
+                rationale: `Best-score selected variant ${best.variant.index} with score ${best.score}`,
+            };
+        }
+        case "first-pass": {
+            const first = candidates[0];
+            return {
+                selected: first,
+                allResults: results,
+                strategy,
+                rationale: `First-pass selected variant ${first.variant.index}`,
+            };
+        }
+        case "ensemble": {
+            // Ensemble: 모든 결과의 점수를 평균화하여 가장 안정적인 variant 선택
+            if (candidates.length <= 1) {
+                return {
+                    selected: candidates[0],
+                    allResults: results,
+                    strategy,
+                    rationale: `Ensemble with single candidate (${results.length} total, ${successful.length} successful)`,
+                };
+            }
+            const scored = candidates.map((r) => {
+                const avgScore = candidates.reduce((sum, c) => sum + c.score, 0) / candidates.length;
+                const stability = 1 - Math.abs(r.score - avgScore) / Math.max(avgScore, 1);
+                return { ...r, ensembleScore: r.score * 0.6 + stability * 0.4 };
+            });
+            const best = scored.reduce((best, cur) => cur.ensembleScore >
+                best.ensembleScore
+                ? cur
+                : best);
+            return {
+                selected: best,
+                allResults: results,
+                strategy,
+                rationale: `Ensemble selected variant ${best.variant.index} (ensemble score ${best.ensembleScore.toFixed(2)} from ${candidates.length} candidates)`,
+            };
+        }
+    }
+}
+export function buildModeRoutingInjection(node, modeConfig, nodeSkills, nodeMcpServers, nodeHooks, nodeTools) {
+    const hasThink = modeConfig.modes.includes("think");
+    const hasMcp = modeConfig.modes.includes("mcp");
+    const hasSkills = modeConfig.modes.includes("skills");
+    return {
+        reasoningPrompt: hasThink
+            ? buildReasoningPrompt(node, modeConfig.thinkingLevel)
+            : undefined,
+        thinkingBudgetMs: hasThink ? resolveThinkingBudgetMs(node) : undefined,
+        mcpServers: hasMcp && nodeMcpServers.length > 0
+            ? nodeMcpServers
+            : hasMcp
+                ? [...modeConfig.mcpServers]
+                : nodeMcpServers,
+        skills: hasSkills ? nodeSkills : [],
+        hooks: hasSkills ? nodeHooks : [],
+        tools: hasSkills ? nodeTools : [],
+        requiresMcp: hasMcp,
+        requiresToolCalling: hasMcp || hasSkills,
+        evidenceRequired: hasSkills || hasThink,
+    };
+}
+function buildReasoningPrompt(node, level) {
+    const base = `You are an expert ${node.role} agent. Think step-by-step before acting.`;
+    switch (level) {
+        case "verbose":
+            return `${base}
+1. ANALYZE: Understand the task deeply — identify constraints, edge cases, and dependencies.
+2. PLAN: Outline your approach with clear steps and decision points.
+3. REASON: For each step, explain why you chose this approach over alternatives.
+4. EXECUTE: Carry out the plan, checking intermediate results.
+5. VERIFY: Confirm the output satisfies the requirements. Flag any remaining concerns.`;
+        case "normal":
+        default:
+            return `${base}
+1. Understand the task and its constraints.
+2. Plan your approach before acting.
+3. Execute step-by-step, verifying each step.
+4. Confirm the final output meets requirements.`;
+        case "brief":
+            return `${base} Think through your approach before executing.`;
+    }
+}
+function resolveThinkingBudgetMs(node) {
+    // role 기반 thinking budget
+    const budgets = {
+        planner: 30000,
+        architect: 30000,
+        security: 25000,
+        reviewer: 20000,
+        qa: 20000,
+        tester: 20000,
+        coder: 15000,
+        debugger: 15000,
+        researcher: 20000,
+        explorer: 15000,
+        integrator: 10000,
+        aggregator: 15000,
+    };
+    return budgets[node.role] ?? 10000;
+}