@mcoda/codali 0.1.134 → 0.1.135-codali.2

package/dist/cli/RunCommand.js

@@ -1,11 +1,13 @@
 import { randomUUID } from "node:crypto";
-import { spawnSync } from "node:child_process";
+import { runProcess } from "../tools/shell/AsyncProcess.js";
 import { createWriteStream, existsSync } from "node:fs";
 import { readFile, mkdir } from "node:fs/promises";
 import path from "node:path";
 import { createInterface } from "node:readline/promises";
 import process from "node:process";
 import { loadConfig } from "../config/ConfigLoader.js";
+import { loadOrchestrationConfig } from "../config/OrchestrationConfig.js";
+import { ConfiguredModelScope } from "../providers/ConfiguredModelScope.js";
 import { createProvider } from "../providers/ProviderRegistry.js";
 import { OpenAiCompatibleProvider } from "../providers/OpenAiCompatibleProvider.js";
 import { OllamaRemoteProvider } from "../providers/OllamaRemoteProvider.js";
@@ -277,6 +279,20 @@ export const parseArgs = (argv) => {
             i += 1;
             continue;
         }
+        if (arg === "--orchestration-config") {
+            if (!next || next.startsWith("--"))
+                throw new Error("--orchestration-config requires a file path");
+            parsed.orchestrationConfig = next;
+            i += 1;
+            continue;
+        }
+        if (arg === "--effort") {
+            if (!["low", "medium", "high", "max"].includes(next ?? ""))
+                throw new Error("--effort requires low|medium|high|max");
+            parsed.effort = next;
+            i += 1;
+            continue;
+        }
         if (arg === "--config" && next) {
             parsed.configPath = next;
             i += 1;
@@ -627,7 +643,7 @@ const createStreamState = (flushEveryMs, outputStream) => {
         },
     };
 };
-const createPatchValidator = (workspaceRoot, allowShell, shellAllowlist) => {
+const createPatchValidator = (workspaceRoot, allowShell, shellAllowlist, scope) => {
     if (!allowShell)
         return undefined;
     const allowlist = new Set(shellAllowlist ?? []);
@@ -639,16 +655,8 @@ const createPatchValidator = (workspaceRoot, allowShell, shellAllowlist) => {
         if (!allowlist.has("node")) {
             return;
         }
-        const result = spawnSync("node", ["--check", filePath], {
-            cwd: workspaceRoot,
-            encoding: "utf8",
-        });
-        if (result.error) {
-            throw result.error;
-        }
-        if (result.status !== 0) {
-            throw new Error(result.stderr?.toString() || "node --check failed");
-        }
+        scope?.reserveTool();
+        await runProcess(process.execPath, ["--check", filePath], { workspaceRoot, signal: scope?.signal, shellTimeoutMs: 30000 });
     };
 };
 const isPhaseProvider = (value) => value === "librarian" ||
@@ -1154,8 +1162,35 @@ const registerBuiltins = () => {
 };
 export class RunCommand {
     static async run(argv) {
-        registerBuiltins();
         const parsed = parseArgs(argv);
+        const file = parsed.orchestrationConfig ?? process.env.CODALI_ORCHESTRATION_CONFIG;
+        if (!file) {
+            if (parsed.effort)
+                throw new Error("Legacy run requires --orchestration-config to select an effort budget");
+            return this.runParsed(parsed);
+        }
+        if ([parsed.agent, parsed.agentId, parsed.agentSlug, parsed.agentLibrarian, parsed.agentArchitect, parsed.agentBuilder,
+            parsed.agentCritic, parsed.agentInterpreter, parsed.provider, parsed.model, parsed.baseUrl, parsed.apiKey,
+            parsed.interpreterProvider, parsed.interpreterModel].some(value => value !== undefined))
+            throw new Error("Configured run cannot accept legacy model/provider/agent overrides; edit role bindings in the orchestration file");
+        const resolved = await loadOrchestrationConfig(file);
+        const abort = new AbortController();
+        const stop = () => abort.abort(new Error("Configured run cancelled"));
+        const scope = new ConfiguredModelScope(resolved, { effort: parsed.effort, signal: abort.signal });
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+        try {
+            await this.runParsed(parsed, { resolved, scope });
+        }
+        finally {
+            scope.close();
+            process.removeListener("SIGINT", stop);
+            process.removeListener("SIGTERM", stop);
+        }
+    }
+    static async runParsed(parsed, orchestration) {
+        registerBuiltins();
+        const scope = orchestration?.scope;
         const resolvedWorkspaceRoot = resolveWorkspaceRoot(process.cwd(), parsed.workspaceRoot);
         const agentRef = parsed.agent ?? parsed.agentId ?? parsed.agentSlug;
         const resolvedAgent = agentRef
@@ -1372,6 +1407,23 @@ export class RunCommand {
             configPath: parsed.configPath,
             cwd: resolvedWorkspaceRoot,
         });
+        if (scope) {
+            const limits = scope.budget();
+            config.limits = { ...config.limits, maxSteps: Math.min(config.limits.maxSteps, limits.maxSteps),
+                maxToolCalls: Math.min(config.limits.maxToolCalls, limits.maxToolCalls),
+                maxTokens: Math.min(config.limits.maxTokens ?? limits.maxOutputTokens, limits.maxOutputTokens),
+                timeoutMs: Math.min(config.limits.timeoutMs, limits.timeoutMs) };
+            config.routing = {};
+            // The legacy configuration still controls workflow/validation; model identity comes only from bindings.
+            config.provider = "configured";
+            config.model = scope.models("lead")[0].model.catalogId;
+            for (const binding of config.smart ? ["router", "architect", "worker"] : ["lead"])
+                scope.models(binding);
+            if (config.localContext.enabled && config.localContext.summarize.enabled)
+                scope.models("summarizer");
+            if (config.builder.mode === "freeform" || config.builder.fallbackToInterpreter)
+                scope.models("repair");
+        }
         if (config.deepInvestigation?.enabled && !config.smart) {
             throw new Error("Deep investigation requires --smart. Enable smart mode or disable deep investigation.");
         }
@@ -1420,7 +1472,7 @@ export class RunCommand {
         const outputLogPath = path.join(path.dirname(logger.logPath), `${runId}.output.log`);
         await mkdir(path.dirname(outputLogPath), { recursive: true });
         const outputStream = createWriteStream(outputLogPath, { flags: "a" });
-        const unregisterSignals = lock.registerSignalHandlers({
+        const unregisterSignals = scope ? () => { } : lock.registerSignalHandlers({
             onSignal: async (signal) => {
                 try {
                     await logger.log("run_cancelled", {
@@ -1625,6 +1677,9 @@ export class RunCommand {
             registerIfEnabled(createSearchTool());
             registerIfEnabled(createShellTool());
             const docdexClient = new DocdexClient({
+                signal: () => scope?.signal,
+                beforeRequest: scope ? () => scope.reserveTool() : undefined,
+                localSearchOnly: Boolean(scope),
                 baseUrl: config.docdex.baseUrl,
                 repoId: config.docdex.repoId,
                 repoRoot: config.docdex.repoRoot ?? config.workspaceRoot,
@@ -1633,6 +1688,8 @@ export class RunCommand {
             for (const tool of createDocdexTools(docdexClient))
                 registerIfEnabled(tool);
             const toolContext = {
+                signal: scope?.signal,
+                beforeTool: scope && config.smart ? async () => scope.reserveTool() : undefined,
                 workspaceRoot: config.workspaceRoot,
                 recordTouchedFile: (filePath) => runContext.recordTouchedFile(filePath),
                 allowOutsideWorkspace: config.tools.allowOutsideWorkspace,
@@ -1641,11 +1698,25 @@ export class RunCommand {
                 shellAllowlist: config.tools.shellAllowlist,
             };
             const streamState = createStreamState(config.streaming.flushEveryMs, outputStream);
+            const scopedProvider = (binding) => {
+                const provider = scope.provider(binding);
+                return { ...provider, generate: async (request) => {
+                        try {
+                            const response = await provider.generate(request);
+                            await logger.log("configured_model_route", { ...response.route, usage: scope.snapshot() });
+                            return response;
+                        }
+                        catch (error) {
+                            await logger.log("configured_model_failure", { binding, configHash: scope.configHash, usage: scope.snapshot() });
+                            throw error;
+                        }
+                    } };
+            };
             if (config.smart) {
                 const hasRoutingAgent = Object.values(config.routing ?? {}).some((phase) => Boolean(phase?.agent));
                 const hasExplicitProvider = Boolean(parsed.provider || parsed.model || parsed.baseUrl || parsed.apiKey);
-                const shouldForceAgentDefaults = !agentRef && !hasRoutingAgent && !hasExplicitProvider;
-                const shouldSelectAgents = config.provider !== "stub";
+                const shouldForceAgentDefaults = !scope && !agentRef && !hasRoutingAgent && !hasExplicitProvider;
+                const shouldSelectAgents = !scope && config.provider !== "stub";
                 const emptySelection = (phase) => ({
                     phase,
                     capabilities: [],
@@ -1751,6 +1822,14 @@ export class RunCommand {
                     });
                 }
                 const buildDefaultsForPhase = (phase) => {
+                    if (scope) {
+                        const binding = { librarian: "router", architect: "architect", builder: "worker", critic: "lead", interpreter: "repair" }[phase];
+                        // An unused interpreter does not require an enabled repair binding.
+                        const required = phase !== "interpreter" || config.builder.mode === "freeform" || config.builder.fallbackToInterpreter;
+                        const model = scope.models(required ? binding : "lead")[0].model;
+                        config.localContext.modelTokenLimits = { ...config.localContext.modelTokenLimits, [model.catalogId]: model.contextWindow };
+                        return { provider: `configured:${binding}`, config: { model: model.catalogId, timeoutMs: config.limits.timeoutMs } };
+                    }
                     const selected = phaseSelections[phase].resolved;
                     return selected
                         ? {
@@ -1799,9 +1878,9 @@ export class RunCommand {
                     provider: criticRoute.provider,
                     model: criticRoute.config.model,
                 };
-                const librarianProvider = createProvider(librarianRoute.provider, librarianRoute.config);
-                const architectProvider = createProvider(architectRoute.provider, architectRoute.config);
-                const builderProvider = createProvider(builderRoute.provider, builderRoute.config);
+                const librarianProvider = scope ? scopedProvider("router") : createProvider(librarianRoute.provider, librarianRoute.config);
+                const architectProvider = scope ? scopedProvider("architect") : createProvider(architectRoute.provider, architectRoute.config);
+                const builderProvider = scope ? scopedProvider("worker") : createProvider(builderRoute.provider, builderRoute.config);
                 const profileAgentId = config.agentId ??
                     config.agentSlug ??
                     phaseSelections.architect.resolved?.agent.id ??
@@ -1842,7 +1921,7 @@ export class RunCommand {
                             model: config.localContext.summarize.model,
                         };
                     }
-                    const summarizerProvider = createProvider(summarizerProviderName, summarizerConfig);
+                    const summarizerProvider = scope ? scopedProvider("summarizer") : createProvider(summarizerProviderName, summarizerConfig);
                     summarizer = new ContextSummarizer(summarizerProvider, {
                         maxTokens: config.localContext.summarize.targetTokens,
                         temperature: summarizerTemperature,
@@ -1937,7 +2016,7 @@ export class RunCommand {
                     onEvent: streamState.onEvent,
                 });
                 const builderResponseFormat = builderRoute.responseFormat ?? (config.builder.mode === "patch_json" ? { type: "json" } : undefined);
-                const patchValidator = createPatchValidator(config.workspaceRoot, config.tools.allowShell ?? false, config.tools.shellAllowlist ?? []);
+                const patchValidator = createPatchValidator(config.workspaceRoot, config.tools.allowShell ?? false, config.tools.shellAllowlist ?? [], scope);
                 const needsPatchApplier = config.builder.mode === "patch_json" || config.builder.mode === "freeform" || config.builder.mode === "tool_calls";
                 const patchApplier = needsPatchApplier
                     ? new PatchApplier({
@@ -1954,7 +2033,7 @@ export class RunCommand {
                     ? resolveInterpreterRoute(config, phaseRoutes)
                     : undefined;
                 const interpreterProvider = interpreterRoute
-                    ? createProvider(interpreterRoute.provider, {
+                    ? scope ? scopedProvider("repair") : createProvider(interpreterRoute.provider, {
                         ...interpreterRoute.config,
                         timeoutMs: config.interpreter.timeoutMs ??
                             interpreterRoute.config.timeoutMs ??
@@ -2003,6 +2082,7 @@ export class RunCommand {
                     model: builderRoute.config.model,
                 });
                 const validator = new ValidationRunner({
+                    signal: scope?.signal,
                     allowShell: config.tools.allowShell ?? false,
                     shellAllowlist: config.tools.shellAllowlist ?? [],
                     workspaceRoot: config.workspaceRoot,
@@ -2206,13 +2286,15 @@ export class RunCommand {
                     minimumVerificationChecks: workflowProfile?.verificationMinimumChecks,
                     enforceVerificationHighConfidence: workflowProfile?.verificationEnforceHighConfidence,
                     onEvent: streamState.onEvent,
-                    onPhaseProviderFailure: recoverPhaseProvider,
+                    onPhaseProviderFailure: scope ? undefined : recoverPhaseProvider,
                 });
                 const result = await pipeline.run(workflowTaskInput);
+                scope?.signal.throwIfAborted();
                 for (const file of result.builderResult.touchedFiles ?? []) {
                     runContext.recordTouchedFile(file);
                 }
                 smartRuntimeSummary = {
+                    orchestration: scope ? { configHash: scope.configHash, usage: scope.snapshot(), toolCalls: scope.toolsUsed } : undefined,
                     attempts: result.attempts,
                     maxRetries: config.limits.maxRetries,
                     maxContextRefreshes: config.context.maxContextRefreshes,
@@ -2292,8 +2374,10 @@ export class RunCommand {
                         throw new Error("Run cancelled due to cost limit");
                     }
                 }
-                const provider = createProvider(config.provider, buildDefaultProviderConfig(config));
+                const provider = scope ? undefined : createProvider(config.provider, buildDefaultProviderConfig(config));
                 const result = await runCodaliTask({
+                    orchestration: orchestration ? { ...orchestration, effort: scope.effort } : undefined,
+                    signal: scope?.signal,
                     task: workflowTaskInput,
                     workspace: { root: config.workspaceRoot },
                     provider: {
@@ -2356,6 +2440,8 @@ export class RunCommand {
                 finalMessageContent = result.finalMessage;
                 usage = result.usage;
                 toolCallsExecuted = result.toolCallsExecuted;
+                if (result.orchestration)
+                    await logger.log("configured_runtime_usage", result.orchestration);
             }
             streamState.flush();
             if (streamState.didStream()) {

package/dist/cli/TerminalCommand.d.ts

@@ -0,0 +1,35 @@
+import { type EffortLevel, type ResolvedOrchestrationConfig } from "../config/OrchestrationConfig.js";
+import { type PermissionProfile } from "../permissions/PermissionGate.js";
+import { type ProjectTaskAuthority } from "@mcoda/shared";
+import { type ManagedRuntimeIdentity } from "../docdex/ManagedRuntime.js";
+interface Arguments {
+    command: string;
+    prompt: string;
+    workspaceRoot: string;
+    config?: string;
+    docdexBinary?: string;
+    projectTask?: string;
+    effort: EffortLevel;
+    permissions: PermissionProfile;
+    json: boolean;
+    plain: boolean;
+    stdin: boolean;
+    allowWeb?: boolean;
+    allowMemory?: boolean;
+    allowMedia?: boolean;
+    allowNetwork?: boolean;
+}
+export interface TerminalHost {
+    projectTaskAuthority?: ProjectTaskAuthority;
+}
+export declare const parseTerminalArguments: (argv: string[]) => Arguments;
+export declare const setupTerminalConfig: (destination: string, options?: {
+    prepareRuntime?: () => Promise<ManagedRuntimeIdentity>;
+}) => Promise<ResolvedOrchestrationConfig>;
+export declare const terminalDoctor: (configPath?: string) => Promise<Record<string, unknown>>;
+export declare class TerminalCommand {
+    static run(argv: string[], host?: TerminalHost): Promise<void>;
+    private static execute;
+}
+export {};
+//# sourceMappingURL=TerminalCommand.d.ts.map

package/dist/cli/TerminalCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TerminalCommand.d.ts","sourceRoot":"","sources":["../../src/cli/TerminalCommand.ts"],"names":[],"mappings":"AAKA,OAAO,EAA2E,KAAK,WAAW,EAA4B,KAAK,2BAA2B,EAAE,MAAM,kCAAkC,CAAC;AAEzM,OAAO,EAAkB,KAAK,iBAAiB,EAAyB,MAAM,kCAAkC,CAAC;AAMjH,OAAO,EAAkC,KAAK,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAI1F,OAAO,EAA2D,KAAK,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAOnI,UAAU,SAAS;IAAG,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,WAAW,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAC;CAAE;AAC1U,MAAM,WAAW,YAAY;IAAG,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAAE;AAC9E,eAAO,MAAM,sBAAsB,GAAI,MAAM,MAAM,EAAE,KAAG,SAmBvD,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAU,aAAa,MAAM,EAAE,UAAS;IAAE,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,sBAAsB,CAAC,CAAA;CAAO,KAAG,OAAO,CAAC,2BAA2B,CAqD5K,CAAC;AAOF,eAAO,MAAM,cAAc,GAAU,aAAa,MAAM,KAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAuBzF,CAAC;AAEF,qBAAa,eAAe;WACb,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,GAAE,YAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;mBAUnD,OAAO;CAiI7B"}