@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/settings-manager.js

@@ -4,6 +4,7 @@ import { dirname, join } from "path";
 import lockfile from "proper-lockfile";
 import { CONFIG_DIR_NAME, getAgentDir } from "../config.js";
 import { normalizePath, resolvePath } from "../utils/paths.js";
+import { stripBom } from "../utils/text.js";
 import { DEFAULT_HTTP_IDLE_TIMEOUT_MS, parseHttpIdleTimeoutMs } from "./http-dispatcher.js";
 function isMergeableObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -37,6 +38,13 @@ function parseTimeoutSetting(value, settingName) {
     }
     return undefined;
 }
+function toSettingsError(scope, error, path) {
+    return {
+        scope,
+        ...(path ? { path } : {}),
+        error: error instanceof Error ? error : new Error(String(error)),
+    };
+}
 export class FileSettingsStorage {
     globalSettingsPath;
     projectSettingsPath;
@@ -130,7 +138,8 @@ export class SettingsManager {
     projectSettingsLoadError = null; // Track if project settings file had parse errors
     writeQueue = Promise.resolve();
     errors;
-    constructor(storage, initialGlobal, initialProject, globalLoadError = null, projectLoadError = null, initialErrors = [], projectTrusted = true) {
+    settingsPaths;
+    constructor(storage, initialGlobal, initialProject, globalLoadError = null, projectLoadError = null, initialErrors = [], projectTrusted = true, settingsPaths = {}) {
         this.storage = storage;
         this.globalSettings = initialGlobal;
         this.projectSettings = initialProject;
@@ -138,26 +147,36 @@ export class SettingsManager {
         this.globalSettingsLoadError = globalLoadError;
         this.projectSettingsLoadError = projectLoadError;
         this.errors = [...initialErrors];
+        this.settingsPaths = settingsPaths;
         this.settings = deepMergeSettings(this.globalSettings, this.projectSettings);
     }
     /** Create a SettingsManager that loads from files */
     static create(cwd, agentDir = getAgentDir(), options = {}) {
-        const storage = new FileSettingsStorage(cwd, agentDir);
-        return SettingsManager.fromStorage(storage, options);
+        const resolvedCwd = resolvePath(cwd);
+        const resolvedAgentDir = resolvePath(agentDir);
+        const storage = new FileSettingsStorage(resolvedCwd, resolvedAgentDir);
+        return SettingsManager.fromStorageWithPaths(storage, options, {
+            global: join(resolvedAgentDir, "settings.json"),
+            project: join(resolvedCwd, CONFIG_DIR_NAME, "settings.json"),
+        });
     }
     /** Create a SettingsManager from an arbitrary storage backend */
     static fromStorage(storage, options = {}) {
+        return SettingsManager.fromStorageWithPaths(storage, options);
+    }
+    /** Create a manager while retaining optional file paths for reported storage errors. */
+    static fromStorageWithPaths(storage, options, settingsPaths = {}) {
         const projectTrusted = options.projectTrusted ?? true;
         const globalLoad = SettingsManager.tryLoadFromStorage(storage, "global");
         const projectLoad = SettingsManager.tryLoadFromStorage(storage, "project", projectTrusted);
         const initialErrors = [];
         if (globalLoad.error) {
-            initialErrors.push({ scope: "global", error: globalLoad.error });
+            initialErrors.push(toSettingsError("global", globalLoad.error, settingsPaths.global));
         }
         if (projectLoad.error) {
-            initialErrors.push({ scope: "project", error: projectLoad.error });
+            initialErrors.push(toSettingsError("project", projectLoad.error, settingsPaths.project));
         }
-        return new SettingsManager(storage, globalLoad.settings, projectLoad.settings, globalLoad.error, projectLoad.error, initialErrors, projectTrusted);
+        return new SettingsManager(storage, globalLoad.settings, projectLoad.settings, globalLoad.error, projectLoad.error, initialErrors, projectTrusted, settingsPaths);
     }
     /** Create an in-memory SettingsManager (no file I/O) */
     static inMemory(settings = {}, options = {}) {
@@ -178,7 +197,7 @@ export class SettingsManager {
         if (!content) {
             return {};
         }
-        const settings = JSON.parse(content);
+        const settings = JSON.parse(stripBom(content));
         return SettingsManager.migrateSettings(settings);
     }
     static tryLoadFromStorage(storage, scope, projectTrusted = true) {
@@ -323,8 +342,7 @@ export class SettingsManager {
         }
     }
     recordError(scope, error) {
-        const normalizedError = error instanceof Error ? error : new Error(String(error));
-        this.errors.push({ scope, error: normalizedError });
+        this.errors.push(toSettingsError(scope, error, this.settingsPaths[scope]));
     }
     clearModifiedScope(scope) {
         if (scope === "global") {
@@ -358,7 +376,7 @@ export class SettingsManager {
     persistScopedSettings(scope, snapshotSettings, modifiedFields, modifiedNestedFields) {
         this.storage.withLock(scope, (current) => {
             const currentFileSettings = current
-                ? SettingsManager.migrateSettings(JSON.parse(current))
+                ? SettingsManager.migrateSettings(JSON.parse(stripBom(current)))
                 : {};
             const mergedSettings = { ...currentFileSettings };
             for (const field of modifiedFields) {
@@ -495,6 +513,30 @@ export class SettingsManager {
         this.markModified("defaultThinkingLevel");
         this.save();
     }
+    getModelThinkingLevel(provider, modelId) {
+        return this.settings.modelThinkingLevels?.[`${provider}/${modelId}`];
+    }
+    getAllModelThinkingLevels() {
+        return { ...(this.settings.modelThinkingLevels ?? {}) };
+    }
+    setModelThinkingLevel(provider, modelId, level) {
+        if (!this.globalSettings.modelThinkingLevels) {
+            this.globalSettings.modelThinkingLevels = {};
+        }
+        this.globalSettings.modelThinkingLevels[`${provider}/${modelId}`] = level;
+        this.markModified("modelThinkingLevels");
+        this.save();
+    }
+    removeModelThinkingLevel(provider, modelId) {
+        if (!this.globalSettings.modelThinkingLevels)
+            return;
+        delete this.globalSettings.modelThinkingLevels[`${provider}/${modelId}`];
+        if (Object.keys(this.globalSettings.modelThinkingLevels).length === 0) {
+            delete this.globalSettings.modelThinkingLevels;
+        }
+        this.markModified("modelThinkingLevels");
+        this.save();
+    }
     getTransport() {
         return this.settings.transport ?? "auto";
     }
@@ -835,6 +877,19 @@ export class SettingsManager {
     getProjectMemoryEnabled() {
         return this.settings.projectMemory ?? true;
     }
+    /** Servidores MCP declarados por el usuario (`mcpServers` en settings). */
+    getMcpServers() {
+        return this.settings.mcpServers;
+    }
+    /**
+     * Optimizador de caché de prompt (activo por defecto). Reordena el prefijo
+     * estable y rellena las claves de caché; ver core/prompt-cache/.
+     */
+    getPromptCacheEnabled() {
+        if (process.env.ADA_NO_PROMPT_CACHE)
+            return false;
+        return this.settings.promptCache ?? true;
+    }
     setProjectMemoryEnabled(enabled) {
         this.globalSettings.projectMemory = enabled;
         this.markModified("projectMemory");
@@ -915,6 +970,192 @@ export class SettingsManager {
             failureInjectMaxEntries: 5,
         };
     }
+    // ─── Ada Intelligence Engine config (§16.2) ───
+    /** Config completa del Ada Intelligence Engine (bloques con defaults). */
+    /**
+     * Configuración del engine con los defaults ya aplicados.
+     *
+     * El tipo de retorno se INFIERE a propósito. La anotación anterior era
+     * `Record<string, unknown>` por bloque, que tiraba toda la forma: quien
+     * llamaba veía `cfg.workflows.budget` como `unknown` y tenía que castear
+     * para leer un valor que este mismo método acababa de construir. Un tipo
+     * que obliga a castear no está documentando nada.
+     */
+    getEngineConfig() {
+        const w = (this.globalSettings.workflows ?? {});
+        const g = (this.globalSettings.goalEngine ?? {});
+        const h = (this.globalSettings.hooks ?? {});
+        const p = (this.globalSettings.permissions ?? {});
+        const gr = (this.globalSettings.graph ?? {});
+        const cc = (this.globalSettings.computerUse ?? {});
+        const ad = (this.globalSettings.advisor ?? {});
+        return {
+            workflows: {
+                enabled: w.enabled ?? true,
+                concurrency: clamp(w.concurrency ?? 4, 1, 16),
+                maxAgentsPerRun: clamp(w.maxAgentsPerRun ?? 100, 1, 1000),
+                budget: {
+                    perRun: { tokens: w.budget?.perRun?.tokens ?? 200000, usd: w.budget?.perRun?.usd ?? 2.0 },
+                    perAgent: { tokens: w.budget?.perAgent?.tokens ?? 50000 },
+                    perPhase: w.budget?.perPhase ?? null,
+                },
+                timeouts: {
+                    agentMs: w.timeouts?.agentMs ?? 1_800_000,
+                    scriptMs: w.timeouts?.scriptMs ?? 300_000,
+                    drainMs: w.timeouts?.drainMs ?? 30_000,
+                },
+                judge: {
+                    model: w.judge?.model ?? "auto",
+                    crossModel: w.judge?.crossModel ?? true,
+                    cheapForIntermediate: w.judge?.cheapForIntermediate ?? true,
+                },
+                models: {
+                    cheap: w.models?.cheap ?? null,
+                    main: w.models?.main ?? null,
+                    judge: w.models?.judge ?? null,
+                    cheapCandidates: Array.isArray(w.models?.cheapCandidates)
+                        ? w.models.cheapCandidates.filter((c) => typeof c === "string" && c.includes("/"))
+                        : [],
+                    cheapThinking: w.models?.cheapThinking ?? null,
+                    mainThinking: w.models?.mainThinking ?? null,
+                    judgeThinking: w.models?.judgeThinking ?? null,
+                },
+                autoResume: w.autoResume ?? true,
+                web: { searchProvider: w.web?.searchProvider ?? "auto", fetch: "ssrf-hardened" },
+            },
+            goalEngine: {
+                enabled: g.enabled ?? true,
+                maxTurns: clamp(g.maxTurns ?? 25, 1, 200),
+                repeatDetector: clamp(g.repeatDetector ?? 3, 1, 10),
+                stopFile: g.stopFile ?? "~/.ada-stop",
+                budgetTokens: clamp(g.budgetTokens ?? 100000, 0, 10_000_000),
+                autopilot: g.autopilot ?? false,
+                allowShipThrough: g.allowShipThrough ?? false,
+                askBefore: g.askBefore ?? ["publish", "delete-data", "spend-money"],
+                workTier: g.workTier === "cheap" ? "cheap" : "main",
+                // P5: modo plan-only (default off).
+                planOnly: g.planOnly === true,
+            },
+            hooks: {
+                enabled: h.enabled ?? true,
+                failClosedHeadless: h.failClosedHeadless ?? true,
+                events: h.events ?? {},
+            },
+            permissions: {
+                level: p.level ?? "auto",
+                destructiveGuards: p.destructiveGuards ?? true,
+                envGuards: p.envGuards ?? true,
+                // `denied` viaja o el `deny` del usuario no existe.
+                //
+                // Este objeto es lo ÚNICO que ve la política: `agent-session` le pasa
+                // `getEngineConfig()` a `RegistroDeSesion.antesDeLlamada`, que llama a
+                // `leerDenegadas(config)`. Sin esta línea ese campo se caía aquí y
+                // `leerDenegadas` devolvía `[]` SIEMPRE: la regla que `politica.ts`
+                // documenta como no negociable —«denegado incluso en yolo», por
+                // delante del modo— no denegaba nada, y sus pruebas seguían en verde
+                // porque le pasan `denegadas` a mano a `decidir()`. Medido: con
+                // `permissions.denied: ["web_fetch"]` en settings.json, `bash` y
+                // `web_fetch` se permitían igual.
+                denied: p.denied,
+            },
+            graph: {
+                enabled: gr.enabled ?? true,
+                minConfidence: clamp(gr.minConfidence ?? 0.6, 0, 1),
+                gates: gr.gates ?? true,
+            },
+            computerUse: {
+                enabled: cc.enabled ?? false,
+                backend: cc.backend ?? "local",
+                browser: cc.browser ?? true,
+            },
+            // El advisor viene ENCENDIDO. Un observador que hay que descubrir y
+            // activar no lo activa nadie, y el turno en el que habría servido ya
+            // pasó. El coste se acota por otro lado: mira cada N turnos, con el
+            // modelo barato, y la guarda de emisión impide que hable por hablar.
+            advisor: {
+                enabled: ad.enabled ?? true,
+                cadaCuantosTurnos: clamp(ad.cadaCuantosTurnos ?? 2, 1, 20),
+            },
+        };
+    }
+    getWorkflowsEnabled() {
+        return (this.globalSettings.workflows?.enabled ?? true) === true;
+    }
+    setWorkflowsEnabled(v) {
+        this.globalSettings.workflows = { ...(this.globalSettings.workflows ?? {}), enabled: v };
+        this.markModified("workflows");
+        this.save();
+    }
+    /** Modo del optimizador autónomo de prompts (default: auto = activado). */
+    getPromptOptimizerMode() {
+        const m = this.globalSettings.promptOptimizer;
+        return m === "off" || m === "clarify" ? m : "auto";
+    }
+    setPromptOptimizerMode(mode) {
+        this.globalSettings.promptOptimizer = mode;
+        this.markModified("promptOptimizer");
+        this.save();
+    }
+    getGoalEngineEnabled() {
+        return (this.globalSettings.goalEngine?.enabled ?? true) === true;
+    }
+    setGoalEngineConfig(patch) {
+        this.globalSettings.goalEngine = { ...(this.globalSettings.goalEngine ?? {}), ...patch };
+        this.markModified("goalEngine");
+        this.save();
+    }
+    /** P5: modo plan-only — el goal no lanza workflows hasta aprobación explícita. */
+    getPlanOnlyEnabled() {
+        return (this.globalSettings.goalEngine?.planOnly ?? false) === true;
+    }
+    setPlanOnlyEnabled(v) {
+        this.setGoalEngineConfig({ planOnly: v });
+    }
+    getPermissionsLevel() {
+        const l = this.globalSettings.permissions?.level;
+        return l === "yolo" || l === "manual" ? l : "auto";
+    }
+    setPermissionsLevel(level) {
+        this.globalSettings.permissions = { ...(this.globalSettings.permissions ?? {}), level };
+        this.markModified("permissions");
+        this.save();
+    }
+    getGoalWorkTier() {
+        const tier = this.getEngineConfig().goalEngine.workTier;
+        return tier === "cheap" ? "cheap" : "main";
+    }
+    setGoalWorkTier(tier) {
+        this.updateEngineBlock("goalEngine", { workTier: tier });
+    }
+    getGoalMaxTurns() {
+        return Number(this.getEngineConfig().goalEngine.maxTurns) || 25;
+    }
+    setGoalMaxTurns(turns) {
+        this.updateEngineBlock("goalEngine", { maxTurns: Math.min(Math.max(turns, 1), 200) });
+    }
+    getGoalRepeatTolerance() {
+        return Number(this.getEngineConfig().goalEngine.repeatDetector) || 3;
+    }
+    setGoalRepeatTolerance(tolerance) {
+        this.updateEngineBlock("goalEngine", { repeatDetector: Math.min(Math.max(tolerance, 1), 10) });
+    }
+    getGraphEnabled() {
+        return this.getEngineConfig().graph.enabled === true;
+    }
+    setGoalEngineEnabled(enabled) {
+        this.updateEngineBlock("goalEngine", { enabled });
+    }
+    /**
+     * Update atómico de un bloque del engine (§16.2) con merge superficial.
+     * block: "workflows" | "goalEngine" | "hooks" | "permissions" | "graph" | "computerUse".
+     * Lo usan el CLI (/settings) y el desktop (tab Engine).
+     */
+    updateEngineBlock(block, patch) {
+        const current = (this.globalSettings[block] ?? {});
+        this.globalSettings[block] = { ...current, ...patch };
+        this.markModified(block);
+        this.save();
+    }
     setImageAutoResize(enabled) {
         if (!this.globalSettings.images) {
             this.globalSettings.images = {};
@@ -1018,4 +1259,8 @@ export class SettingsManager {
         this.save();
     }
 }
+/** Clamp helper para la config del engine. */
+function clamp(n, min, max) {
+    return Math.min(max, Math.max(min, n));
+}
 //# sourceMappingURL=settings-manager.js.map