agentweaver 0.1.14 → 0.1.16

package/dist/runtime/design-review-input-contract.js

@@ -0,0 +1,113 @@
+import { existsSync } from "node:fs";
+import { designFile, designJsonFile, instantTaskInputJsonFile, jiraAttachmentsContextFile, jiraAttachmentsManifestFile, jiraTaskFile, latestArtifactIteration, planFile, planJsonFile, planningAnswersJsonFile, qaFile, qaJsonFile, taskContextJsonFile, requireArtifacts, } from "../artifacts.js";
+import { validateStructuredArtifacts } from "../structured-artifacts.js";
+import { resolveLatestCompletedPlanningIteration } from "./planning-bundle.js";
+const OPTIONAL_INPUT_NOT_PROVIDED = "not provided";
+function requiredPlanningArtifactPaths(taskKey, iteration) {
+    return {
+        designFile: designFile(taskKey, iteration),
+        designJsonFile: designJsonFile(taskKey, iteration),
+        planFile: planFile(taskKey, iteration),
+        planJsonFile: planJsonFile(taskKey, iteration),
+    };
+}
+function resolveOptionalPromptFile(filePath) {
+    if (!existsSync(filePath)) {
+        return {
+            present: false,
+            path: null,
+            promptValue: OPTIONAL_INPUT_NOT_PROVIDED,
+        };
+    }
+    return {
+        present: true,
+        path: filePath,
+        promptValue: filePath,
+    };
+}
+function resolveOptionalValidatedStructuredFile(filePath, schemaId, message) {
+    const resolved = resolveOptionalPromptFile(filePath);
+    if (!resolved.present) {
+        return resolved;
+    }
+    validateStructuredArtifacts([{ path: filePath, schemaId }], message);
+    return resolved;
+}
+function resolveOptionalQaPair(taskKey, iteration) {
+    const markdownPath = qaFile(taskKey, iteration);
+    const jsonPath = qaJsonFile(taskKey, iteration);
+    const markdownExists = existsSync(markdownPath);
+    const jsonExists = existsSync(jsonPath);
+    if (!markdownExists && !jsonExists) {
+        return {
+            hasQaArtifacts: false,
+            qaFilePath: null,
+            qaJsonFilePath: null,
+            qaFile: OPTIONAL_INPUT_NOT_PROVIDED,
+            qaJsonFile: OPTIONAL_INPUT_NOT_PROVIDED,
+        };
+    }
+    if (!markdownExists || !jsonExists) {
+        requireArtifacts([markdownPath, jsonPath], "Design-review accepts QA artifacts only as a complete markdown/JSON pair for the selected planning iteration.");
+    }
+    validateStructuredArtifacts([{ path: jsonPath, schemaId: "qa-plan/v1" }], "Design-review QA structured artifact is invalid.");
+    return {
+        hasQaArtifacts: true,
+        qaFilePath: markdownPath,
+        qaJsonFilePath: jsonPath,
+        qaFile: markdownPath,
+        qaJsonFile: jsonPath,
+    };
+}
+/**
+ * Resolves the full design-review input contract from artifacts already present in the task scope.
+ * Required planning artifacts must come from one completed planning iteration. Optional contextual
+ * inputs are exposed as stable prompt values and explicit presence flags so the flow can remain
+ * deterministic when some context is absent.
+ */
+export function resolveDesignReviewInputContract(taskKey) {
+    const planningIteration = resolveLatestCompletedPlanningIteration(taskKey, {
+        requireQa: false,
+        missingMessage: "Design-review requires design and plan markdown/JSON artifacts from the latest completed planning run.",
+    });
+    const requiredArtifacts = requiredPlanningArtifactPaths(taskKey, planningIteration);
+    requireArtifacts(Object.values(requiredArtifacts), "Design-review requires design and plan markdown/JSON artifacts from the latest completed planning run.");
+    validateStructuredArtifacts([
+        { path: requiredArtifacts.designJsonFile, schemaId: "implementation-design/v1" },
+        { path: requiredArtifacts.planJsonFile, schemaId: "implementation-plan/v1" },
+    ], "Design-review required planning structured artifacts are invalid.");
+    const qaArtifacts = resolveOptionalQaPair(taskKey, planningIteration);
+    const jiraTask = resolveOptionalPromptFile(jiraTaskFile(taskKey));
+    const jiraAttachmentsManifest = resolveOptionalPromptFile(jiraAttachmentsManifestFile(taskKey));
+    const jiraAttachmentsContext = resolveOptionalPromptFile(jiraAttachmentsContextFile(taskKey));
+    const planningAnswers = resolveOptionalValidatedStructuredFile(planningAnswersJsonFile(taskKey), "user-input/v1", "Design-review planning answers structured artifact is invalid.");
+    const taskContextIteration = latestArtifactIteration(taskKey, "task-context", "json");
+    const taskContext = taskContextIteration === null
+        ? { present: false, path: null, promptValue: OPTIONAL_INPUT_NOT_PROVIDED }
+        : resolveOptionalValidatedStructuredFile(taskContextJsonFile(taskKey, taskContextIteration), "task-context/v1", "Design-review task-context structured artifact is invalid.");
+    const taskInput = resolveOptionalValidatedStructuredFile(instantTaskInputJsonFile(taskKey), "user-input/v1", "Design-review instant-task input structured artifact is invalid.");
+    return {
+        planningIteration,
+        ...requiredArtifacts,
+        ...qaArtifacts,
+        hasJiraTaskFile: jiraTask.present,
+        jiraTaskFilePath: jiraTask.path,
+        jiraTaskFile: jiraTask.promptValue,
+        hasJiraAttachmentsManifestFile: jiraAttachmentsManifest.present,
+        jiraAttachmentsManifestFilePath: jiraAttachmentsManifest.path,
+        jiraAttachmentsManifestFile: jiraAttachmentsManifest.promptValue,
+        hasJiraAttachmentsContextFile: jiraAttachmentsContext.present,
+        jiraAttachmentsContextFilePath: jiraAttachmentsContext.path,
+        jiraAttachmentsContextFile: jiraAttachmentsContext.promptValue,
+        hasPlanningAnswersJsonFile: planningAnswers.present,
+        planningAnswersJsonFilePath: planningAnswers.path,
+        planningAnswersJsonFile: planningAnswers.promptValue,
+        hasTaskContextJsonFile: taskContext.present,
+        taskContextJsonFilePath: taskContext.path,
+        taskContextJsonFile: taskContext.promptValue,
+        hasTaskInputJsonFile: taskInput.present,
+        taskInputJsonFilePath: taskInput.path,
+        taskInputJsonFile: taskInput.promptValue,
+    };
+}
+export { OPTIONAL_INPUT_NOT_PROVIDED };

package/dist/runtime/env-loader.js

@@ -35,6 +35,9 @@ function globalConfigDir() {
 function ensureGlobalConfigDir() {
     mkdirSync(globalConfigDir(), { recursive: true });
 }
+export function agentweaverConfigDir() {
+    return globalConfigDir();
+}
 export function loadTieredEnv(projectDir) {
     ensureGlobalConfigDir();
     const shellEnvKeys = new Set(Object.keys(process.env));

package/dist/runtime/execution-routing-store.js

@@ -0,0 +1,134 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { TaskRunnerError } from "../errors.js";
+import { resolveStoredExecutionRoutingSnapshot } from "./execution-routing.js";
+import { agentweaverConfigDir } from "./env-loader.js";
+const EXECUTION_ROUTING_STORE_VERSION = 1;
+function storePath() {
+    return path.join(agentweaverConfigDir(), "execution-routing.json");
+}
+function nowIso8601() {
+    return new Date().toISOString();
+}
+function emptyStore() {
+    return {
+        version: EXECUTION_ROUTING_STORE_VERSION,
+        namedPresets: {},
+        flowDefaults: {},
+        lastUsedByFlow: {},
+    };
+}
+function validateSelectedPreset(value, pathLabel) {
+    if (!value || typeof value !== "object") {
+        throw new TaskRunnerError(`Invalid execution routing store entry at ${pathLabel}.selectedPreset.`);
+    }
+    const candidate = value;
+    if (typeof candidate.kind !== "string" || typeof candidate.label !== "string") {
+        throw new TaskRunnerError(`Invalid execution routing store entry at ${pathLabel}.selectedPreset.`);
+    }
+    if (candidate.kind === "built-in" || candidate.kind === "named") {
+        if (typeof candidate.presetId !== "string" || candidate.presetId.trim().length === 0) {
+            throw new TaskRunnerError(`Invalid execution routing store entry at ${pathLabel}.selectedPreset.presetId.`);
+        }
+        return {
+            kind: candidate.kind,
+            presetId: candidate.presetId,
+            label: candidate.label,
+        };
+    }
+    if (candidate.kind === "flow-default" || candidate.kind === "last-used" || candidate.kind === "custom") {
+        return {
+            kind: candidate.kind,
+            label: candidate.label,
+        };
+    }
+    throw new TaskRunnerError(`Invalid execution routing store entry at ${pathLabel}.selectedPreset.kind.`);
+}
+function validateRoutingEntry(value, pathLabel) {
+    if (!value || typeof value !== "object") {
+        throw new TaskRunnerError(`Invalid execution routing store entry at ${pathLabel}.`);
+    }
+    const candidate = value;
+    if (typeof candidate.updatedAt !== "string") {
+        throw new TaskRunnerError(`Invalid execution routing store entry at ${pathLabel}.updatedAt.`);
+    }
+    return {
+        routing: resolveStoredExecutionRoutingSnapshot(candidate.routing),
+        selectedPreset: validateSelectedPreset(candidate.selectedPreset, pathLabel),
+        updatedAt: candidate.updatedAt,
+    };
+}
+function validateEntryMap(value, pathLabel) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new TaskRunnerError(`Invalid execution routing store section '${pathLabel}'.`);
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, validateRoutingEntry(entry, `${pathLabel}.${key}`)]));
+}
+function validateStore(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new TaskRunnerError("Execution routing store must be a JSON object.");
+    }
+    const candidate = raw;
+    if (candidate.version !== EXECUTION_ROUTING_STORE_VERSION) {
+        throw new TaskRunnerError(`Unsupported execution routing store version: ${String(candidate.version ?? "unknown")}.`);
+    }
+    return {
+        version: EXECUTION_ROUTING_STORE_VERSION,
+        namedPresets: validateEntryMap(candidate.namedPresets ?? {}, "namedPresets"),
+        flowDefaults: validateEntryMap(candidate.flowDefaults ?? {}, "flowDefaults"),
+        lastUsedByFlow: validateEntryMap(candidate.lastUsedByFlow ?? {}, "lastUsedByFlow"),
+    };
+}
+export function loadExecutionRoutingStore() {
+    const filePath = storePath();
+    if (!existsSync(filePath)) {
+        return emptyStore();
+    }
+    try {
+        return validateStore(JSON.parse(readFileSync(filePath, "utf8")));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new TaskRunnerError(`Failed to load execution routing store ${filePath}: ${message}. Delete or repair the file and try again.`);
+    }
+}
+export function saveExecutionRoutingStore(store) {
+    const filePath = storePath();
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    const tempFilePath = `${filePath}.tmp`;
+    writeFileSync(`${tempFilePath}`, `${JSON.stringify(store, null, 2)}\n`, "utf8");
+    renameSync(tempFilePath, filePath);
+}
+function withUpdatedAt(entry) {
+    return {
+        ...entry,
+        updatedAt: nowIso8601(),
+    };
+}
+export function saveNamedExecutionPreset(name, routing, selectedPreset) {
+    const store = loadExecutionRoutingStore();
+    store.namedPresets[name] = withUpdatedAt({ routing, selectedPreset });
+    saveExecutionRoutingStore(store);
+}
+export function saveFlowDefaultExecutionRouting(flowKey, routing, selectedPreset) {
+    const store = loadExecutionRoutingStore();
+    store.flowDefaults[flowKey] = withUpdatedAt({ routing, selectedPreset });
+    saveExecutionRoutingStore(store);
+}
+export function saveLastUsedExecutionRouting(flowKey, routing, selectedPreset) {
+    const store = loadExecutionRoutingStore();
+    store.lastUsedByFlow[flowKey] = withUpdatedAt({ routing, selectedPreset });
+    saveExecutionRoutingStore(store);
+}
+export function getNamedExecutionPresets() {
+    return loadExecutionRoutingStore().namedPresets;
+}
+export function getFlowDefaultExecutionRouting(flowKey) {
+    return loadExecutionRoutingStore().flowDefaults[flowKey] ?? null;
+}
+export function getLastUsedExecutionRouting(flowKey) {
+    return loadExecutionRoutingStore().lastUsedByFlow[flowKey] ?? null;
+}
+export function executionRoutingStoreFile() {
+    return storePath();
+}

package/dist/runtime/execution-routing.js

@@ -0,0 +1,227 @@
+import { createHash } from "node:crypto";
+import { TaskRunnerError } from "../errors.js";
+import { ALLOWED_MODELS_BY_EXECUTOR, DEFAULT_LAUNCH_PROFILE, defaultModelForExecutor, isAllowedModelForExecutor, resolveLaunchProfile, } from "../pipeline/launch-profile-config.js";
+import { BUILT_IN_EXECUTION_PRESET_IDS, EXECUTION_ROUTING_GROUPS, } from "../pipeline/execution-routing-config.js";
+export const BUILT_IN_EXECUTION_PRESETS = {
+    balanced: {
+        id: "balanced",
+        label: "Balanced",
+        description: "Use Codex for planning and review, OpenCode for implementation-style loops.",
+        defaultRoute: { executor: "opencode", model: "default" },
+        groupOverrides: {
+            planning: { executor: "codex", model: "gpt-5.4" },
+            "design-review": { executor: "codex", model: "gpt-5.4" },
+            review: { executor: "codex", model: "gpt-5.4" },
+        },
+    },
+    "quality-first": {
+        id: "quality-first",
+        label: "Quality-first",
+        description: "Run all routing groups on Codex GPT-5.4.",
+        defaultRoute: { executor: "codex", model: "gpt-5.4" },
+    },
+    "cheap-first": {
+        id: "cheap-first",
+        label: "Cheap-first",
+        description: "Prefer lower-cost models while preserving valid executor and model pairs.",
+        defaultRoute: { executor: "opencode", model: "opencode/minimax-m2.5-free" },
+        groupOverrides: {
+            planning: { executor: "codex", model: "gpt-5.4-mini" },
+            "design-review": { executor: "codex", model: "gpt-5.4-mini" },
+            review: { executor: "codex", model: "gpt-5.4-mini" },
+        },
+    },
+    "codex-only": {
+        id: "codex-only",
+        label: "Codex-only",
+        description: "Run all routing groups on Codex with the default Codex model.",
+        defaultRoute: { executor: "codex", model: "default" },
+    },
+    "opencode-only": {
+        id: "opencode-only",
+        label: "OpenCode-only",
+        description: "Run all routing groups on OpenCode with the default OpenCode model.",
+        defaultRoute: { executor: "opencode", model: "default" },
+    },
+};
+function stableRoutingPayload(routing) {
+    return JSON.stringify({
+        defaultRoute: {
+            executor: routing.defaultRoute.executor,
+            model: routing.defaultRoute.model,
+        },
+        groups: Object.fromEntries(EXECUTION_ROUTING_GROUPS.map((group) => [
+            group,
+            {
+                executor: routing.groups[group].executor,
+                model: routing.groups[group].model,
+            },
+        ])),
+    });
+}
+export function executionRoutingFingerprint(routing) {
+    return createHash("sha256").update(stableRoutingPayload({ ...routing, fingerprint: "" })).digest("hex");
+}
+export function validateExecutionRoute(executor, model) {
+    const allowedModels = ALLOWED_MODELS_BY_EXECUTOR[executor];
+    if (!allowedModels) {
+        throw new TaskRunnerError(`Unsupported llm executor '${executor}'.`);
+    }
+    if (!allowedModels.includes(model)) {
+        throw new TaskRunnerError(`Model '${model}' is not allowed for executor '${executor}'.`);
+    }
+}
+export function toExecutionRouteSelection(route) {
+    return {
+        executor: route.executor,
+        model: route.model,
+    };
+}
+export function resolveExecutionRoute(selection, fallback) {
+    const launchProfile = resolveLaunchProfile({
+        executor: selection.executor,
+        model: selection.model,
+    }, fallback);
+    validateExecutionRoute(launchProfile.executor, launchProfile.model);
+    return launchProfile;
+}
+export function resolveExecutionRouting(options) {
+    const fallbackDefaultRoute = options.fallbackDefaultRoute ?? DEFAULT_LAUNCH_PROFILE;
+    const preset = options.presetId ? BUILT_IN_EXECUTION_PRESETS[options.presetId] : null;
+    const defaultRouteSelection = options.defaultRoute ?? preset?.defaultRoute ?? toExecutionRouteSelection(fallbackDefaultRoute);
+    const defaultRoute = resolveExecutionRoute(defaultRouteSelection, fallbackDefaultRoute);
+    const groups = Object.fromEntries(EXECUTION_ROUTING_GROUPS.map((group) => {
+        const override = options.currentRunOverrides?.[group]
+            ?? options.presetOverrides?.[group]
+            ?? preset?.groupOverrides?.[group]
+            ?? { executor: "default", model: "default" };
+        return [group, resolveExecutionRoute(override, defaultRoute)];
+    }));
+    const fingerprint = executionRoutingFingerprint({
+        defaultRoute,
+        groups,
+    });
+    return {
+        defaultRoute,
+        groups,
+        fingerprint,
+    };
+}
+export function routingGroupLabel(group) {
+    switch (group) {
+        case "planning":
+            return "Planning";
+        case "design-review":
+            return "Design review";
+        case "implementation":
+            return "Implementation";
+        case "review":
+            return "Review";
+        case "repair-loop":
+            return "Repair loop";
+        case "local-fix-loop":
+            return "Local fix loop";
+        default:
+            return group;
+    }
+}
+export function describeExecutionRouting(routing, groups = EXECUTION_ROUTING_GROUPS) {
+    const lines = [`Default: ${routing.defaultRoute.executor} / ${routing.defaultRoute.model}`];
+    for (const group of groups) {
+        const route = routing.groups[group];
+        lines.push(`${routingGroupLabel(group)}: ${route.executor} / ${route.model}`);
+    }
+    return lines.join("\n");
+}
+export function executorsForRoutingGroups(routing, groups) {
+    const requiredExecutors = [];
+    for (const group of groups) {
+        const executor = routing.groups[group].executor;
+        if (!requiredExecutors.includes(executor)) {
+            requiredExecutors.push(executor);
+        }
+    }
+    return requiredExecutors;
+}
+export function normalizeEditableExecutionRouting(routes) {
+    const normalizedRoutes = {};
+    const validationErrors = [];
+    for (const group of EXECUTION_ROUTING_GROUPS) {
+        const route = routes[group];
+        if (isAllowedModelForExecutor(route.executor, route.model)) {
+            normalizedRoutes[group] = { ...route };
+            continue;
+        }
+        normalizedRoutes[group] = {
+            executor: route.executor,
+            model: defaultModelForExecutor(route.executor),
+        };
+        validationErrors.push(`${routingGroupLabel(group)} model '${route.model}' is not allowed for executor '${route.executor}'. Select a ${route.executor} model.`);
+    }
+    return {
+        routes: normalizedRoutes,
+        validationErrors,
+    };
+}
+export function builtInExecutionPresetList() {
+    return BUILT_IN_EXECUTION_PRESET_IDS.map((id) => BUILT_IN_EXECUTION_PRESETS[id]);
+}
+export function selectedExecutionPresetLabel(selection) {
+    return selection.label;
+}
+export function cloneResolvedExecutionRouting(routing) {
+    return {
+        defaultRoute: { ...routing.defaultRoute },
+        groups: Object.fromEntries(EXECUTION_ROUTING_GROUPS.map((group) => [group, { ...routing.groups[group] }])),
+        fingerprint: routing.fingerprint,
+    };
+}
+export function defaultExecutionRouting() {
+    return resolveExecutionRouting({
+        defaultRoute: {
+            executor: DEFAULT_LAUNCH_PROFILE.executor,
+            model: DEFAULT_LAUNCH_PROFILE.model,
+        },
+    });
+}
+export function resolveStoredExecutionRoutingSnapshot(routing) {
+    validateExecutionRoute(routing.defaultRoute.executor, routing.defaultRoute.model);
+    for (const group of EXECUTION_ROUTING_GROUPS) {
+        validateExecutionRoute(routing.groups[group].executor, routing.groups[group].model);
+    }
+    const fingerprint = executionRoutingFingerprint({
+        defaultRoute: routing.defaultRoute,
+        groups: routing.groups,
+    });
+    return {
+        defaultRoute: {
+            ...routing.defaultRoute,
+            selectedExecutor: routing.defaultRoute.selectedExecutor ?? routing.defaultRoute.executor,
+            selectedModel: routing.defaultRoute.selectedModel ?? routing.defaultRoute.model,
+            fingerprint: routing.defaultRoute.fingerprint ?? `${routing.defaultRoute.executor}::${routing.defaultRoute.model}`,
+        },
+        groups: Object.fromEntries(EXECUTION_ROUTING_GROUPS.map((group) => {
+            const route = routing.groups[group];
+            return [group, {
+                    ...route,
+                    selectedExecutor: route.selectedExecutor ?? route.executor,
+                    selectedModel: route.selectedModel ?? route.model,
+                    fingerprint: route.fingerprint ?? `${route.executor}::${route.model}`,
+                }];
+        })),
+        fingerprint,
+    };
+}
+export function singleLaunchProfileExecutionRouting(launchProfile) {
+    return resolveExecutionRouting({
+        defaultRoute: toExecutionRouteSelection(launchProfile),
+        currentRunOverrides: Object.fromEntries(EXECUTION_ROUTING_GROUPS.map((group) => [group, toExecutionRouteSelection(launchProfile)])),
+    });
+}
+export function modelOptionsForExecutor(executor) {
+    const defaultModel = defaultModelForExecutor(executor);
+    return ALLOWED_MODELS_BY_EXECUTOR[executor].map((model) => ({
+        value: model,
+        label: model === defaultModel ? `${model} [default]` : model,
+    }));
+}