@mcoda/codali 0.1.66

package/dist/agents/AgentProtocol.js

@@ -0,0 +1,365 @@
+const parseQuotedValue = (value) => {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith("\"") && trimmed.endsWith("\"")) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+};
+const parseYamlKeyValue = (line) => {
+    const idx = line.indexOf(":");
+    if (idx === -1)
+        return null;
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim();
+    if (!key)
+        return null;
+    return { key, value };
+};
+const parseOptionalNumber = (value) => {
+    if (!value)
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+};
+const parseOptionalBoolean = (value) => {
+    if (value === undefined)
+        return undefined;
+    return value.trim().toLowerCase() === "true";
+};
+const parseOptionalStringList = (value) => {
+    if (!value)
+        return undefined;
+    const normalized = value.trim().replace(/^\[/, "").replace(/\]$/, "");
+    const parsed = normalized
+        .split(",")
+        .map((entry) => parseQuotedValue(entry.trim()))
+        .filter(Boolean);
+    return parsed.length ? parsed : undefined;
+};
+const coerceNeed = (need) => {
+    const type = need.type?.trim();
+    if (!type) {
+        throw new Error("Agent request need missing type");
+    }
+    if (type === "docdex.search") {
+        const query = need.query?.trim();
+        if (!query)
+            throw new Error("docdex.search requires query");
+        const limit = parseOptionalNumber(need.limit);
+        return { type, query, limit };
+    }
+    if (type === "docdex.open") {
+        const path = need.path?.trim();
+        if (!path)
+            throw new Error("docdex.open requires path");
+        const start_line = parseOptionalNumber(need.start_line);
+        const end_line = parseOptionalNumber(need.end_line);
+        const head = parseOptionalNumber(need.head);
+        const clamp = parseOptionalBoolean(need.clamp);
+        return { type, path, start_line, end_line, head, clamp };
+    }
+    if (type === "docdex.snippet") {
+        const doc_id = need.doc_id?.trim();
+        if (!doc_id)
+            throw new Error("docdex.snippet requires doc_id");
+        const window = parseOptionalNumber(need.window);
+        return { type, doc_id, window };
+    }
+    if (type === "docdex.symbols") {
+        const file = need.file?.trim();
+        if (!file)
+            throw new Error("docdex.symbols requires file");
+        return { type, file };
+    }
+    if (type === "docdex.ast") {
+        const file = need.file?.trim();
+        if (!file)
+            throw new Error("docdex.ast requires file");
+        const max_nodes = parseOptionalNumber(need.max_nodes);
+        return { type, file, max_nodes };
+    }
+    if (type === "docdex.web") {
+        const query = need.query?.trim();
+        if (!query)
+            throw new Error("docdex.web requires query");
+        const force_web = parseOptionalBoolean(need.force_web);
+        return { type, query, force_web };
+    }
+    if (type === "docdex.impact") {
+        const file = need.file?.trim();
+        if (!file)
+            throw new Error("docdex.impact requires file");
+        return { type, file };
+    }
+    if (type === "docdex.impact_diagnostics") {
+        const file = need.file?.trim();
+        const limit = parseOptionalNumber(need.limit);
+        const offset = parseOptionalNumber(need.offset);
+        return { type, file: file || undefined, limit, offset };
+    }
+    if (type === "docdex.tree") {
+        const path = need.path?.trim();
+        const max_depth = parseOptionalNumber(need.max_depth);
+        const dirs_only = parseOptionalBoolean(need.dirs_only);
+        const include_hidden = parseOptionalBoolean(need.include_hidden);
+        return { type, path: path || undefined, max_depth, dirs_only, include_hidden };
+    }
+    if (type === "docdex.dag_export") {
+        const session_id = need.session_id?.trim();
+        const formatValue = need.format?.trim();
+        const format = formatValue && ["json", "text", "dot"].includes(formatValue)
+            ? formatValue
+            : undefined;
+        if (formatValue && !format) {
+            throw new Error("docdex.dag_export format must be json, text, or dot");
+        }
+        const max_nodes = parseOptionalNumber(need.max_nodes);
+        return { type, session_id: session_id || undefined, format, max_nodes };
+    }
+    if (type === "file.read") {
+        const path = need.path?.trim();
+        if (!path)
+            throw new Error("file.read requires path");
+        return { type, path };
+    }
+    if (type === "file.list") {
+        const root = need.root?.trim();
+        if (!root)
+            throw new Error("file.list requires root");
+        const pattern = need.pattern?.trim();
+        return { type, root, pattern: pattern || undefined };
+    }
+    if (type === "file.diff") {
+        const rawPaths = need.paths?.trim();
+        const paths = rawPaths
+            ? rawPaths
+                .split(",")
+                .map((entry) => entry.trim())
+                .filter(Boolean)
+            : undefined;
+        return { type, paths };
+    }
+    if (type === "agent.delegate") {
+        const goal = need.goal?.trim();
+        if (!goal)
+            throw new Error("agent.delegate requires goal");
+        const roleValue = need.role?.trim();
+        const role = roleValue && ["explorer", "reviewer", "worker", "verifier", "custom"].includes(roleValue)
+            ? roleValue
+            : undefined;
+        if (roleValue && !role) {
+            throw new Error("agent.delegate role must be explorer, reviewer, worker, verifier, or custom");
+        }
+        return {
+            type,
+            role,
+            goal,
+            tools: parseOptionalStringList(need.tools),
+            allowed_paths: parseOptionalStringList(need.allowed_paths),
+            write_paths: parseOptionalStringList(need.write_paths),
+            read_only: parseOptionalBoolean(need.read_only),
+            max_steps: parseOptionalNumber(need.max_steps),
+            max_tool_calls: parseOptionalNumber(need.max_tool_calls),
+            timeout_ms: parseOptionalNumber(need.timeout_ms),
+        };
+    }
+    throw new Error(`Unsupported need type: ${type}`);
+};
+export const parseAgentRequest = (input, options = {}) => {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        throw new Error("Agent request is empty");
+    }
+    if (trimmed.startsWith("{")) {
+        const parsed = JSON.parse(trimmed);
+        if (!parsed.request_id && !options.defaultRequestId)
+            throw new Error("Agent request missing request_id");
+        if (!parsed.needs || !Array.isArray(parsed.needs) || parsed.needs.length === 0) {
+            throw new Error("Agent request needs must be a non-empty array");
+        }
+        return {
+            version: "v1",
+            role: parsed.role ?? "unknown",
+            request_id: parsed.request_id ?? options.defaultRequestId,
+            needs: parsed.needs,
+            context: parsed.context,
+        };
+    }
+    const lines = trimmed.split(/\r?\n/);
+    const header = lines.shift()?.trim();
+    if (!header || !/^AGENT_REQUEST\s+v1$/i.test(header)) {
+        throw new Error("Agent request missing AGENT_REQUEST v1 header");
+    }
+    let role = "unknown";
+    let request_id = "";
+    const needs = [];
+    let contextSummary;
+    let mode = "none";
+    let currentNeed = null;
+    for (const rawLine of lines) {
+        const line = rawLine.trimEnd();
+        if (!line.trim())
+            continue;
+        const trimmedLine = line.trim();
+        const isTopLevel = !/^\s/.test(rawLine);
+        if (trimmedLine.startsWith("needs:")) {
+            mode = "needs";
+            continue;
+        }
+        if (trimmedLine.startsWith("context:")) {
+            if (currentNeed) {
+                needs.push(coerceNeed(currentNeed));
+                currentNeed = null;
+            }
+            mode = "context";
+            continue;
+        }
+        if (isTopLevel) {
+            const kv = parseYamlKeyValue(trimmedLine);
+            if (kv && (kv.key === "role" || kv.key === "request_id")) {
+                if (currentNeed) {
+                    needs.push(coerceNeed(currentNeed));
+                    currentNeed = null;
+                }
+                if (kv.key === "role")
+                    role = parseQuotedValue(kv.value);
+                if (kv.key === "request_id")
+                    request_id = parseQuotedValue(kv.value);
+                continue;
+            }
+        }
+        if (mode === "needs") {
+            if (trimmedLine.startsWith("-")) {
+                if (currentNeed) {
+                    needs.push(coerceNeed(currentNeed));
+                }
+                currentNeed = {};
+                const rest = line.replace(/^\s*-\s*/, "");
+                if (rest) {
+                    const kv = parseYamlKeyValue(rest);
+                    if (kv) {
+                        currentNeed[kv.key] = parseQuotedValue(kv.value);
+                    }
+                }
+                continue;
+            }
+            if (currentNeed) {
+                const kv = parseYamlKeyValue(trimmedLine);
+                if (kv) {
+                    currentNeed[kv.key] = parseQuotedValue(kv.value);
+                }
+                continue;
+            }
+        }
+        if (mode === "context") {
+            const kv = parseYamlKeyValue(trimmedLine);
+            if (kv && kv.key === "summary") {
+                contextSummary = parseQuotedValue(kv.value);
+            }
+            continue;
+        }
+        const kv = parseYamlKeyValue(trimmedLine);
+        if (!kv)
+            continue;
+        if (kv.key === "role")
+            role = parseQuotedValue(kv.value);
+        if (kv.key === "request_id")
+            request_id = parseQuotedValue(kv.value);
+    }
+    if (currentNeed) {
+        needs.push(coerceNeed(currentNeed));
+    }
+    if (!request_id) {
+        if (!options.defaultRequestId)
+            throw new Error("Agent request missing request_id");
+        request_id = options.defaultRequestId;
+    }
+    if (needs.length === 0)
+        throw new Error("Agent request needs must be a non-empty array");
+    return {
+        version: "v1",
+        role,
+        request_id,
+        needs,
+        context: contextSummary ? { summary: contextSummary } : undefined,
+    };
+};
+export const normalizeAgentRequest = (request) => request.needs.map((need) => {
+    if (need.type === "docdex.search") {
+        return { tool: "docdex.search", params: { query: need.query, limit: need.limit } };
+    }
+    if (need.type === "docdex.open") {
+        return {
+            tool: "docdex.open",
+            params: {
+                path: need.path,
+                start_line: need.start_line,
+                end_line: need.end_line,
+                head: need.head,
+                clamp: need.clamp,
+            },
+        };
+    }
+    if (need.type === "docdex.snippet") {
+        return { tool: "docdex.snippet", params: { doc_id: need.doc_id, window: need.window } };
+    }
+    if (need.type === "docdex.symbols") {
+        return { tool: "docdex.symbols", params: { file: need.file } };
+    }
+    if (need.type === "docdex.ast") {
+        return { tool: "docdex.ast", params: { file: need.file, max_nodes: need.max_nodes } };
+    }
+    if (need.type === "docdex.web") {
+        return { tool: "docdex.web", params: { query: need.query, force_web: need.force_web } };
+    }
+    if (need.type === "docdex.impact") {
+        return { tool: "docdex.impact", params: { file: need.file } };
+    }
+    if (need.type === "docdex.impact_diagnostics") {
+        return {
+            tool: "docdex.impact_diagnostics",
+            params: { file: need.file, limit: need.limit, offset: need.offset },
+        };
+    }
+    if (need.type === "docdex.tree") {
+        return {
+            tool: "docdex.tree",
+            params: {
+                path: need.path,
+                max_depth: need.max_depth,
+                dirs_only: need.dirs_only,
+                include_hidden: need.include_hidden,
+            },
+        };
+    }
+    if (need.type === "docdex.dag_export") {
+        return {
+            tool: "docdex.dag_export",
+            params: { session_id: need.session_id, format: need.format, max_nodes: need.max_nodes },
+        };
+    }
+    if (need.type === "file.list") {
+        return { tool: "file.list", params: { root: need.root, pattern: need.pattern } };
+    }
+    if (need.type === "file.diff") {
+        return { tool: "file.diff", params: { paths: need.paths } };
+    }
+    if (need.type === "agent.delegate") {
+        return {
+            tool: "agent.delegate",
+            params: {
+                role: need.role ?? "explorer",
+                goal: need.goal,
+                tools: need.tools,
+                allowed_paths: need.allowed_paths,
+                write_paths: need.write_paths,
+                read_only: need.read_only,
+                max_steps: need.max_steps,
+                max_tool_calls: need.max_tool_calls,
+                timeout_ms: need.timeout_ms,
+            },
+        };
+    }
+    return { tool: "file.read", params: { path: need.path } };
+});

package/dist/agents/AgentResolver.d.ts

@@ -0,0 +1,23 @@
+import { GlobalRepository } from "@mcoda/db";
+import { type Agent } from "@mcoda/shared";
+export interface AgentResolutionOverrides {
+    provider?: string;
+    model?: string;
+    baseUrl?: string;
+    apiKey?: string;
+}
+export interface ResolvedAgentConfig {
+    agent: Agent;
+    provider: string;
+    model: string;
+    baseUrl?: string;
+    apiKey?: string;
+    requiresApiKey: boolean;
+}
+export declare const resolveProviderFromAdapter: (adapter: string, explicitProvider?: string) => {
+    provider: string;
+    requiresApiKey: boolean;
+};
+export declare const resolveAgentConfigFromRecord: (agent: Agent, repo: GlobalRepository, overrides?: AgentResolutionOverrides) => Promise<ResolvedAgentConfig>;
+export declare const resolveAgentConfig: (agentRef: string, overrides?: AgentResolutionOverrides) => Promise<ResolvedAgentConfig>;
+//# sourceMappingURL=AgentResolver.d.ts.map

package/dist/agents/AgentResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentResolver.d.ts","sourceRoot":"","sources":["../../src/agents/AgentResolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAgB,KAAK,KAAK,EAAE,MAAM,eAAe,CAAC;AAEzD,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,OAAO,CAAC;CACzB;AAoBD,eAAO,MAAM,0BAA0B,GACrC,SAAS,MAAM,EACf,mBAAmB,MAAM,KACxB;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,OAAO,CAAA;CAwB7C,CAAC;AAEF,eAAO,MAAM,4BAA4B,GACvC,OAAO,KAAK,EACZ,MAAM,gBAAgB,EACtB,YAAW,wBAA6B,KACvC,OAAO,CAAC,mBAAmB,CAsC7B,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,UAAU,MAAM,EAChB,YAAW,wBAA6B,KACvC,OAAO,CAAC,mBAAmB,CAY7B,CAAC"}

package/dist/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/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/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"}