@mcoda/mswarm 0.1.57 → 0.1.61

package/dist/vendor/codali/agents/AgentResolver.js

@@ -0,0 +1,77 @@
+import { GlobalRepository } from "@mcoda/db";
+import { CryptoHelper } from "@mcoda/shared";
+const PROVIDERS_REQUIRING_API_KEY = new Set(["openai-compatible"]);
+const PROVIDERS_REQUIRING_BASE_URL = new Set(["ollama-remote"]);
+const SESSION_AUTH_ADAPTERS = new Set(["codex-cli", "openai-cli", "gemini-cli"]);
+const UNSUPPORTED_CODALI_ADAPTERS = new Set(["gemini-cli", "zhipu-api"]);
+const resolveString = (value) => {
+    return typeof value === "string" && value.trim() ? value : undefined;
+};
+const resolveBaseUrl = (agent) => {
+    const config = (agent.config ?? {});
+    return (resolveString(config.baseUrl) ??
+        resolveString(config.endpoint) ??
+        resolveString(config.apiBaseUrl));
+};
+export const resolveProviderFromAdapter = (adapter, explicitProvider) => {
+    if (explicitProvider) {
+        const requiresApiKey = PROVIDERS_REQUIRING_API_KEY.has(explicitProvider) &&
+            !SESSION_AUTH_ADAPTERS.has(adapter);
+        return { provider: explicitProvider, requiresApiKey };
+    }
+    if (UNSUPPORTED_CODALI_ADAPTERS.has(adapter)) {
+        throw new Error(`CODALI_UNSUPPORTED_ADAPTER: ${adapter} is not supported; configure a codali provider explicitly or choose a different agent.`);
+    }
+    if (adapter === "openai-api") {
+        return { provider: "openai-compatible", requiresApiKey: true };
+    }
+    if (["openai-cli", "codex-cli"].includes(adapter)) {
+        return { provider: "codex-cli", requiresApiKey: false };
+    }
+    if (["ollama-remote", "ollama-cli", "local-model"].includes(adapter)) {
+        return { provider: "ollama-remote", requiresApiKey: false };
+    }
+    throw new Error(`CODALI_UNSUPPORTED_ADAPTER: ${adapter} is not supported; configure a codali provider explicitly or choose a different agent.`);
+};
+export const resolveAgentConfigFromRecord = async (agent, repo, overrides = {}) => {
+    const { provider, requiresApiKey } = resolveProviderFromAdapter(agent.adapter, overrides.provider);
+    if (provider === "openai-compatible" && agent.openaiCompatible === false) {
+        const label = agent.slug ?? agent.id;
+        throw new Error(`Agent ${label} is not marked openai-compatible; update the agent metadata or choose a different provider.`);
+    }
+    const model = overrides.model ?? agent.defaultModel;
+    if (!model) {
+        const label = agent.slug ?? agent.id;
+        throw new Error(`Agent ${label} has no default model`);
+    }
+    const baseUrl = overrides.baseUrl ?? resolveBaseUrl(agent);
+    if (PROVIDERS_REQUIRING_BASE_URL.has(provider) && !baseUrl) {
+        const label = agent.slug ?? agent.id;
+        throw new Error(`Agent ${label} is missing a baseUrl for provider ${provider}; update the agent config.`);
+    }
+    let apiKey = overrides.apiKey;
+    if (!apiKey && requiresApiKey) {
+        const secret = await repo.getAgentAuthSecret(agent.id);
+        if (secret?.encryptedSecret) {
+            apiKey = await CryptoHelper.decryptSecret(secret.encryptedSecret);
+        }
+    }
+    if (requiresApiKey && !apiKey) {
+        const label = agent.slug ?? agent.id;
+        throw new Error(`AUTH_REQUIRED: API key missing for agent ${label}; run \"mcoda agent auth set ${label}\".`);
+    }
+    return { agent, provider, model, baseUrl, apiKey, requiresApiKey };
+};
+export const resolveAgentConfig = async (agentRef, overrides = {}) => {
+    const repo = await GlobalRepository.create();
+    try {
+        const agent = (await repo.getAgentById(agentRef)) ?? (await repo.getAgentBySlug(agentRef));
+        if (!agent) {
+            throw new Error(`Agent ${agentRef} not found`);
+        }
+        return await resolveAgentConfigFromRecord(agent, repo, overrides);
+    }
+    finally {
+        await repo.close();
+    }
+};

package/dist/vendor/codali/agents/PhaseAgentSelector.d.ts

@@ -0,0 +1,23 @@
+import type { Agent } from "@mcoda/shared";
+import type { PipelinePhase } from "../cognitive/ProviderRouting.js";
+import type { BuilderConfig } from "../config/Config.js";
+import { type ResolvedAgentConfig } from "./AgentResolver.js";
+export type PhaseAgentSource = "override" | "auto" | "fallback" | "none";
+export interface PhaseAgentSelection {
+    phase: PipelinePhase;
+    agent?: Agent;
+    capabilities: string[];
+    resolved?: ResolvedAgentConfig;
+    source: PhaseAgentSource;
+    score?: number;
+    reason?: string;
+}
+export interface PhaseAgentSelectionOptions {
+    overrides: Partial<Record<PipelinePhase, string>>;
+    builderMode: BuilderConfig["mode"];
+    fallbackAgent?: ResolvedAgentConfig;
+    allowCloudModels?: boolean;
+    excludeAgentIds?: Partial<Record<PipelinePhase, string[]>>;
+}
+export declare const selectPhaseAgents: (options: PhaseAgentSelectionOptions) => Promise<Record<PipelinePhase, PhaseAgentSelection>>;
+//# sourceMappingURL=PhaseAgentSelector.d.ts.map

package/dist/vendor/codali/agents/PhaseAgentSelector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhaseAgentSelector.d.ts","sourceRoot":"","sources":["../../src/agents/PhaseAgentSelector.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,MAAM,GAAG,UAAU,GAAG,MAAM,CAAC;AAEzE,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,mBAAmB,CAAC;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,0BAA0B;IACzC,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,CAAC;IAClD,WAAW,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACnC,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,eAAe,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;CAC5D;AAuLD,eAAO,MAAM,iBAAiB,GAC5B,SAAS,0BAA0B,KAClC,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,mBAAmB,CAAC,CA6IpD,CAAC"}

package/dist/vendor/codali/agents/PhaseAgentSelector.js

@@ -0,0 +1,287 @@
+import { GlobalRepository } from "@mcoda/db";
+import { resolveAgentConfigFromRecord, } from "./AgentResolver.js";
+const PHASE_CAPABILITIES = {
+    librarian: ["docdex_query", "summarization", "keyword_extraction", "log_analysis"],
+    architect: ["plan", "system_architecture", "architectural_design", "deep_reasoning"],
+    builder: ["code_write", "complex_refactoring", "migration_assist", "debugging"],
+    critic: ["code_review", "pull_request_review", "final_code_review", "standard_compliance"],
+    interpreter: ["code_review", "pull_request_review", "final_code_review", "standard_compliance"],
+};
+const PHASE_REQUIRED_CAPS = {
+    librarian: ["docdex_query", "summarization", "keyword_extraction", "log_analysis"],
+    architect: ["plan", "system_architecture", "architectural_design", "deep_reasoning"],
+    builder: ["code_write", "simple_refactor", "iterative_coding", "migration_assist"],
+    critic: ["code_review", "pull_request_review", "final_code_review", "standard_compliance"],
+    interpreter: ["code_review", "pull_request_review", "final_code_review", "standard_compliance"],
+};
+const PHASE_BEST_USAGE = {
+    librarian: ["lightweight_tasks", "log_analysis", "summarization", "doc_generation"],
+    architect: ["system_architecture", "architectural_design", "deep_reasoning", "plan"],
+    builder: ["code_write", "coding_light", "iterative_coding", "rapid_prototyping"],
+    critic: ["code_review", "code_review_secondary", "production_verification"],
+    interpreter: ["code_review", "code_review_secondary", "production_verification"],
+};
+const STRUCTURED_OUTPUT_CAPABILITIES = [
+    "strict_instruction_following",
+    "json_formatting",
+    "schema_adherence",
+    "structured_output",
+];
+const PATCH_JSON_EXECUTION_CAPABILITIES = [
+    "iterative_coding",
+    "simple_refactor",
+];
+const PATCH_JSON_RELIABILITY_CAPABILITIES = [
+    "iterative_coding",
+    "strict_instruction_following",
+    "json_formatting",
+    "schema_adherence",
+    "structured_output",
+    "test_fixing",
+];
+const ADAPTERS_REQUIRING_AUTH = new Set([
+    "openai-api",
+    "zhipu-api",
+    "gemini-cli",
+    "codex-cli",
+]);
+const countMatches = (capabilities, required) => required.filter((cap) => capabilities.includes(cap)).length;
+const isManagedMswarmCloudAgent = (agent) => {
+    const config = agent.config;
+    if (!config || typeof config !== "object" || Array.isArray(config)) {
+        return false;
+    }
+    const managed = config.mswarmCloud;
+    return Boolean(managed &&
+        typeof managed === "object" &&
+        !Array.isArray(managed) &&
+        managed.managed === true);
+};
+const isCloudModel = (agent) => {
+    if (isManagedMswarmCloudAgent(agent)) {
+        return true;
+    }
+    return Boolean(agent.defaultModel?.toLowerCase().includes(":cloud"));
+};
+const normalizeAdapter = (adapter) => (adapter ?? "").trim().toLowerCase();
+const requiresConfiguredAuth = (agent) => ADAPTERS_REQUIRING_AUTH.has(normalizeAdapter(agent.adapter));
+const adjustScoreForReadiness = (score, agent, readiness) => {
+    let adjusted = score;
+    if (readiness.healthStatus === "degraded")
+        adjusted -= 25;
+    if (requiresConfiguredAuth(agent) && readiness.authConfigured === false)
+        adjusted -= 80;
+    return adjusted;
+};
+const scoreAgent = (phase, agent, capabilities, builderMode) => {
+    if (builderMode === "tool_calls" && phase === "builder" && agent.supportsTools === false) {
+        return Number.NEGATIVE_INFINITY;
+    }
+    const rating = agent.rating ?? 0;
+    const reasoning = agent.reasoningRating ?? rating;
+    const cost = agent.costPerMillion ?? 0;
+    const maxComplexity = agent.maxComplexity ?? 0;
+    const capHits = countMatches(capabilities, PHASE_CAPABILITIES[phase]);
+    const requiredHits = countMatches(capabilities, PHASE_REQUIRED_CAPS[phase]);
+    const structuredHits = countMatches(capabilities, STRUCTURED_OUTPUT_CAPABILITIES);
+    const patchExecutionHits = countMatches(capabilities, PATCH_JSON_EXECUTION_CAPABILITIES);
+    const patchReliabilityHits = countMatches(capabilities, PATCH_JSON_RELIABILITY_CAPABILITIES);
+    const hasIterativeCoding = capabilities.includes("iterative_coding");
+    const hasToolRunner = capabilities.includes("tool_runner");
+    const usageBoost = agent.bestUsage && PHASE_BEST_USAGE[phase].includes(agent.bestUsage) ? 2 : 0;
+    const patchJsonBuilder = phase === "builder" && builderMode === "patch_json";
+    let score = 0;
+    if (phase === "architect" || phase === "critic" || phase === "interpreter") {
+        score += reasoning * 3 + rating * 2;
+    }
+    else if (phase === "builder") {
+        score += rating * 2 + reasoning;
+    }
+    else {
+        score += rating + reasoning * 0.5;
+    }
+    score += capHits * 4;
+    if (capHits === 0)
+        score -= 3;
+    score += requiredHits * 2;
+    if (patchJsonBuilder)
+        score += requiredHits * 3;
+    score += usageBoost;
+    if (patchJsonBuilder) {
+        score += structuredHits * 14;
+        score += patchExecutionHits * 4;
+        score += patchReliabilityHits * 3;
+        if (structuredHits === 0)
+            score -= 24;
+        if (patchExecutionHits === 0)
+            score -= 8;
+        if (!hasIterativeCoding)
+            score -= 8;
+        else
+            score += 8;
+        if (requiredHits === 0)
+            score -= 12;
+        if (agent.supportsTools === false)
+            score -= 14;
+        else
+            score += 3;
+        if (hasToolRunner)
+            score += 2;
+    }
+    const prefersStructuredBuilder = patchJsonBuilder && structuredHits > 0;
+    const costPenalty = phase === "builder"
+        ? prefersStructuredBuilder ? 1.5 : patchJsonBuilder ? 2 : 5
+        : phase === "librarian" ? 4 : phase === "architect" ? 1.5 : 1;
+    if (phase === "builder") {
+        score -= cost * costPenalty;
+        score -= maxComplexity * 0.5;
+    }
+    else if (phase === "librarian") {
+        score -= cost * costPenalty;
+        score -= maxComplexity;
+    }
+    else {
+        score -= cost * costPenalty;
+    }
+    return score;
+};
+const resolveOverrideAgent = async (repo, agentRef) => {
+    const agent = (await repo.getAgentById(agentRef)) ?? (await repo.getAgentBySlug(agentRef));
+    if (!agent) {
+        throw new Error(`Agent ${agentRef} not found`);
+    }
+    const capabilities = await repo.getAgentCapabilities(agent.id);
+    const resolved = await resolveAgentConfigFromRecord(agent, repo);
+    return { agent, capabilities, resolved };
+};
+export const selectPhaseAgents = async (options) => {
+    const repo = await GlobalRepository.create();
+    try {
+        const agents = await repo.listAgents();
+        const capCache = new Map();
+        const readinessCache = new Map();
+        const getCaps = async (agent) => {
+            const cached = capCache.get(agent.id);
+            if (cached)
+                return cached;
+            const caps = await repo.getAgentCapabilities(agent.id);
+            capCache.set(agent.id, caps);
+            return caps;
+        };
+        const getReadiness = async (agent) => {
+            const cached = readinessCache.get(agent.id);
+            if (cached)
+                return cached;
+            const [auth, health] = await Promise.all([
+                repo.getAgentAuthMetadata(agent.id),
+                repo.getAgentHealth(agent.id),
+            ]);
+            const readiness = {
+                authConfigured: auth.configured,
+                healthStatus: health?.status,
+            };
+            readinessCache.set(agent.id, readiness);
+            return readiness;
+        };
+        const buildSelection = async (phase) => {
+            const excludedIds = new Set(options.excludeAgentIds?.[phase] ?? []);
+            const overrideRef = options.overrides[phase];
+            if (overrideRef) {
+                const resolvedOverride = await resolveOverrideAgent(repo, overrideRef);
+                return {
+                    phase,
+                    agent: resolvedOverride.agent,
+                    capabilities: resolvedOverride.capabilities,
+                    resolved: resolvedOverride.resolved,
+                    source: "override",
+                    reason: "routing.agent override",
+                };
+            }
+            const scored = [];
+            const patchJsonBuilder = phase === "builder" && options.builderMode === "patch_json";
+            for (const agent of agents) {
+                if (excludedIds.has(agent.id))
+                    continue;
+                if (!agent.defaultModel)
+                    continue;
+                if (!options.allowCloudModels && isCloudModel(agent))
+                    continue;
+                const readiness = await getReadiness(agent);
+                if (readiness.healthStatus === "unreachable")
+                    continue;
+                const caps = await getCaps(agent);
+                const requiredHits = countMatches(caps, PHASE_REQUIRED_CAPS[phase]);
+                const structuredHits = countMatches(caps, STRUCTURED_OUTPUT_CAPABILITIES);
+                const patchExecutionHits = countMatches(caps, PATCH_JSON_EXECUTION_CAPABILITIES);
+                const score = adjustScoreForReadiness(scoreAgent(phase, agent, caps, options.builderMode), agent, readiness);
+                if (!Number.isFinite(score))
+                    continue;
+                scored.push({
+                    agent,
+                    caps,
+                    score,
+                    requiredHits,
+                    structuredHits,
+                    patchExecutionHits,
+                });
+            }
+            const hasRequired = scored.some((candidate) => candidate.requiredHits > 0);
+            let candidates = hasRequired
+                ? scored.filter((candidate) => candidate.requiredHits > 0)
+                : scored;
+            if (patchJsonBuilder) {
+                const structuredCandidates = candidates.filter((candidate) => candidate.structuredHits > 0);
+                if (structuredCandidates.length > 0) {
+                    candidates = structuredCandidates;
+                }
+                else {
+                    const patchExecutionCandidates = candidates.filter((candidate) => candidate.patchExecutionHits > 0);
+                    if (patchExecutionCandidates.length > 0) {
+                        candidates = patchExecutionCandidates;
+                    }
+                }
+            }
+            candidates.sort((a, b) => b.score - a.score);
+            for (const candidate of candidates) {
+                try {
+                    const resolved = await resolveAgentConfigFromRecord(candidate.agent, repo);
+                    return {
+                        phase,
+                        agent: candidate.agent,
+                        capabilities: candidate.caps,
+                        resolved,
+                        source: "auto",
+                        score: candidate.score,
+                        reason: "scored capability match",
+                    };
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (options.fallbackAgent) {
+                const fallbackCaps = await getCaps(options.fallbackAgent.agent);
+                return {
+                    phase,
+                    agent: options.fallbackAgent.agent,
+                    capabilities: fallbackCaps,
+                    resolved: options.fallbackAgent,
+                    source: "fallback",
+                    reason: "auto selection failed",
+                };
+            }
+            return { phase, capabilities: [], source: "none", reason: "no eligible agents" };
+        };
+        const result = {
+            librarian: await buildSelection("librarian"),
+            architect: await buildSelection("architect"),
+            builder: await buildSelection("builder"),
+            critic: await buildSelection("critic"),
+            interpreter: await buildSelection("interpreter"),
+        };
+        return result;
+    }
+    finally {
+        await repo.close();
+    }
+};

package/dist/vendor/codali/cli/EvalCommand.d.ts

@@ -0,0 +1,37 @@
+export declare const EVAL_EXIT_CODES: {
+    readonly usage_error: 2;
+    readonly suite_validation_error: 3;
+    readonly run_failure: 4;
+    readonly gate_failure: 5;
+};
+type EvalExitCode = (typeof EVAL_EXIT_CODES)[keyof typeof EVAL_EXIT_CODES];
+export declare class EvalCommandError extends Error {
+    readonly exitCode: EvalExitCode;
+    constructor(message: string, exitCode: EvalExitCode);
+}
+export interface ParsedEvalArgs {
+    suite_path?: string;
+    output: "text" | "json";
+    baseline_path?: string;
+    report_dir?: string;
+    workspace_root?: string;
+    config_path?: string;
+    provider?: string;
+    model?: string;
+    api_key?: string;
+    base_url?: string;
+    agent?: string;
+    agent_id?: string;
+    agent_slug?: string;
+    workflow_profile?: string;
+    smart?: boolean;
+    no_deep_investigation?: boolean;
+    help?: boolean;
+}
+export declare const parseEvalArgs: (argv: string[]) => ParsedEvalArgs;
+export declare class EvalCommand {
+    static helpText(): string;
+    static run(argv: string[]): Promise<void>;
+}
+export {};
+//# sourceMappingURL=EvalCommand.d.ts.map

package/dist/vendor/codali/cli/EvalCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EvalCommand.d.ts","sourceRoot":"","sources":["../../src/cli/EvalCommand.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,eAAe;;;;;CAKlB,CAAC;AAEX,KAAK,YAAY,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,OAAO,eAAe,CAAC,CAAC;AAE3E,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;gBAEpB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY;CAKpD;AAED,MAAM,WAAW,cAAc;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AA+BD,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,EAAE,KAAG,cAkG9C,CAAC;AA2DF,qBAAa,WAAW;IACtB,MAAM,CAAC,QAAQ,IAAI,MAAM;WAIZ,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAqJhD"}