akm-cli 0.9.0-rc.0 → 0.9.0-rc.13

package/dist/commands/improve/improve-strategies.js

@@ -0,0 +1,135 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import catchup from "../../assets/improve-strategies/catchup.json" with { type: "json" };
+import consolidate from "../../assets/improve-strategies/consolidate.json" with { type: "json" };
+import defaultStrategy from "../../assets/improve-strategies/default.json" with { type: "json" };
+import frequent from "../../assets/improve-strategies/frequent.json" with { type: "json" };
+import graphRefresh from "../../assets/improve-strategies/graph-refresh.json" with { type: "json" };
+import memoryFocus from "../../assets/improve-strategies/memory-focus.json" with { type: "json" };
+import proactiveMaintenance from "../../assets/improve-strategies/proactive-maintenance.json" with { type: "json" };
+import quick from "../../assets/improve-strategies/quick.json" with { type: "json" };
+import reflectDistill from "../../assets/improve-strategies/reflect-distill.json" with { type: "json" };
+import thorough from "../../assets/improve-strategies/thorough.json" with { type: "json" };
+import { parseRefInput } from "../../core/asset/resolve-ref.js";
+import { deepMergeConfig } from "../../core/config/deep-merge.js";
+import { BUILTIN_IMPROVE_STRATEGY_NAMES, IMPROVE_PROCESS_ENGINE_CAPABILITIES, } from "../../core/config/engine-semantics.js";
+import { ConfigError } from "../../core/errors.js";
+import { resolveImproveProcessRunner, resolveTriageJudgmentRunner, } from "../../integrations/agent/runner.js";
+import { applyAutonomyGate } from "./autonomy-gate.js";
+export const DEFAULT_ALLOWED_TYPES = {
+    reflect: ["agent", "command", "knowledge", "lesson", "memory", "skill", "workflow"],
+    distill: ["memory"],
+    consolidate: ["memory"],
+};
+/** Resolve process enablement from the selected strategy, the sole improve authority. */
+export function resolveProcessEnabled(processName, strategy) {
+    const processes = strategy.processes;
+    return processes?.[processName]?.enabled === true;
+}
+export function shouldSkipRef(ref, processName, strategy) {
+    const process = strategy.processes?.[processName];
+    if (process?.enabled === false)
+        return { skip: true, reason: "process-disabled" };
+    const parsed = parseRefInput(ref);
+    const allowed = process?.allowedTypes ?? DEFAULT_ALLOWED_TYPES[processName];
+    if (!allowed.includes(parsed.type))
+        return { skip: true, reason: "type-filter" };
+    return { skip: false, reason: "" };
+}
+export function isStrategyFilteredForAllPasses(ref, strategy) {
+    return shouldSkipRef(ref, "reflect", strategy).skip && shouldSkipRef(ref, "distill", strategy).skip;
+}
+const BUILTIN_STRATEGIES = {
+    default: defaultStrategy,
+    quick: quick,
+    thorough: thorough,
+    "memory-focus": memoryFocus,
+    "graph-refresh": graphRefresh,
+    frequent: frequent,
+    consolidate: consolidate,
+    catchup: catchup,
+    "reflect-distill": reflectDistill,
+    "proactive-maintenance": proactiveMaintenance,
+};
+if (BUILTIN_IMPROVE_STRATEGY_NAMES.some((name) => !(name in BUILTIN_STRATEGIES))) {
+    throw new Error("Built-in improve strategy names are out of sync with their assets");
+}
+export function resolveImproveStrategy(name, config) {
+    const selectedName = name ?? config.defaults?.improveStrategy ?? "default";
+    const userStrategies = config.improve?.strategies ?? {};
+    if (!(selectedName in BUILTIN_STRATEGIES) && !userStrategies[selectedName]) {
+        const valid = [...new Set([...Object.keys(BUILTIN_STRATEGIES), ...Object.keys(userStrategies)])].sort();
+        throw new ConfigError(`Improve strategy "${selectedName}" not found. Valid strategies: ${valid.join(", ")}.`, "UNKNOWN_IMPROVE_STRATEGY");
+    }
+    const selectedStrategy = BUILTIN_STRATEGIES[selectedName] ?? {};
+    const baseStrategy = deepMergeConfig(BUILTIN_STRATEGIES.default, selectedStrategy);
+    const resolved = deepMergeConfig(baseStrategy, (userStrategies[selectedName] ?? {}));
+    return { name: selectedName, config: resolved };
+}
+function cloneAndFreeze(value) {
+    const clone = structuredClone(value);
+    const freeze = (item) => {
+        if (typeof item !== "object" || item === null || Object.isFrozen(item))
+            return;
+        for (const child of Object.values(item))
+            freeze(child);
+        Object.freeze(item);
+    };
+    freeze(clone);
+    return clone;
+}
+/** Resolve every enabled process structurally before improve emits signals or performs I/O. */
+export function resolveImprovePlan(name, config, options = {}) {
+    const selected = resolveImproveStrategy(name, config);
+    // D8 — gate autonomy BEFORE the plan is built, so every downstream consumer
+    // (process enablement, LLM preflight, triage judgment) sees one already-safe
+    // strategy rather than each having to re-ask whether autonomy is allowed.
+    const { config: gatedStrategyConfig, gated } = applyAutonomyGate(selected.config, config);
+    const strategy = { name: selected.name, config: gatedStrategyConfig };
+    return { ...buildImprovePlan(strategy, config, options), autonomyGated: gated };
+}
+function buildImprovePlan(strategy, config, options) {
+    const processes = {};
+    for (const processName of Object.keys(IMPROVE_PROCESS_ENGINE_CAPABILITIES)) {
+        const processConfig = cloneAndFreeze(strategy.config.processes?.[processName] ?? {});
+        const enabled = processConfig.enabled === true;
+        let runner = null;
+        if (IMPROVE_PROCESS_ENGINE_CAPABILITIES[processName] !== "llm" || !enabled) {
+            processes[processName] = Object.freeze({ enabled, config: processConfig, runner });
+            continue;
+        }
+        // Validation itself is structural and always runs. Only its optional repair
+        // step needs a model, so disabling repair must not create an LLM preflight.
+        if (processName !== "validation" || options.repairValidationFailures !== false) {
+            runner = resolveImproveProcessRunner(strategy.config, processName, config);
+        }
+        if (!runner && !(processName === "validation" && options.repairValidationFailures === false)) {
+            throw new ConfigError(`Enabled improve process "${processName}" requires an LLM engine. Set defaults.llmEngine or improve.strategies.${strategy.name}.processes.${processName}.engine.`, "LLM_NOT_CONFIGURED");
+        }
+        if (runner)
+            runner = cloneAndFreeze(runner);
+        processes[processName] = Object.freeze({ enabled, config: processConfig, runner });
+    }
+    const triage = strategy.config.processes?.triage;
+    const judgmentOptedIn = triage !== undefined && Object.hasOwn(triage, "judgment");
+    const triageJudgment = processes.triage.enabled && judgmentOptedIn
+        ? resolveTriageJudgmentRunner(triage.judgment, config, triage, strategy.config)
+        : null;
+    if (processes.triage.enabled && judgmentOptedIn && !triageJudgment) {
+        throw new ConfigError(`Enabled improve triage judgment requires an engine. Set defaults.llmEngine or improve.strategies.${strategy.name}.processes.triage.judgment.engine.`, "LLM_NOT_CONFIGURED");
+    }
+    const frozenProcesses = Object.freeze(processes);
+    const frozenStrategy = Object.freeze({
+        name: strategy.name,
+        config: cloneAndFreeze({
+            ...strategy.config,
+            processes: Object.fromEntries(Object.entries(frozenProcesses).map(([name, process]) => [name, process.config])),
+        }),
+    });
+    return Object.freeze({
+        strategy: frozenStrategy,
+        processes: frozenProcesses,
+        triageJudgment: triageJudgment ? cloneAndFreeze(triageJudgment) : null,
+    });
+}