@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/resource-loader.js

@@ -1,28 +1,39 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
 import { basename, dirname, join, resolve, sep } from "node:path";
 import chalk from "chalk";
 import { CONFIG_DIR_NAME } from "../config.js";
 import { loadThemeFromPath } from "../modes/interactive/theme/theme.js";
 import { canonicalizePath, isLocalPath, resolvePath } from "../utils/paths.js";
+import { stripBom } from "../utils/text.js";
 import { createEventBus } from "./event-bus.js";
 import { clearExtensionCache, createExtensionRuntime, loadExtensionFromFactory, loadExtensionsCached, } from "./extensions/loader.js";
 import { findGitPaths } from "./footer-data-provider.js";
-import { DefaultPackageManager } from "./package-manager.js";
-import { loadProjectMemorySync } from "./project-memory.js";
+import { fuentesDeContextoDeAda } from "./harness/fuentes-de-contexto.js";
+import { McpManager } from "./mcp/manager.js";
 import { MemoryEngine } from "./memory-engine/engine.js";
 import { VaultManager } from "./memory-engine/vault.js";
+import { DefaultPackageManager } from "./package-manager.js";
+import { loadProjectMemorySync } from "./project-memory.js";
+import { createPromptCacheExtension } from "./prompt-cache/index.js";
 import { loadPromptTemplates } from "./prompt-templates.js";
 import { SettingsManager } from "./settings-manager.js";
 import { loadSkills } from "./skills.js";
 import { createSourceInfo } from "./source-info.js";
 import { resetTimings } from "./timings.js";
+import { AgentRunner, extractJson } from "./workflows/agent-runner.js";
+import { FileGoalPersistence, GoalEngine } from "./workflows/goal-engine/index.js";
+import { buildGoalJudgePrompt, buildGoalReplanPrompt } from "./workflows/goal-engine/prompts.js";
+import { FileGraphStore, Graph } from "./workflows/graph.js";
+import { WorkflowManager } from "./workflows/manager.js";
+import { DEFAULT_WORKFLOW_LIMITS } from "./workflows/types.js";
 function resolvePromptInput(input, description) {
     if (!input) {
         return undefined;
     }
     if (existsSync(input)) {
         try {
-            return readFileSync(input, "utf-8");
+            return stripBom(readFileSync(input, "utf-8"));
         }
         catch (error) {
             console.error(chalk.yellow(`Warning: Could not read ${description} file ${input}: ${error}`));
@@ -42,7 +53,7 @@ function loadContextFileFromDir(dir) {
                 }
                 return {
                     path: filePath,
-                    content: readFileSync(filePath, "utf-8"),
+                    content: stripBom(readFileSync(filePath, "utf-8")),
                 };
             }
             catch (error) {
@@ -111,14 +122,26 @@ export function loadProjectContextFiles(options) {
     // mode). Falls back to the legacy project-memory file when the engine is
     // unavailable or disabled. Included last so it reads as the freshest
     // project context.
+    // Harness: notas durables que el agente ha refinado. Se añaden como context
+    // file, igual que la memoria, así que quedan fijadas en reload() y no mueven
+    // el prefijo cacheable entre turnos.
+    // Lo que Ada añade al contexto: las notas durables del harness y las reglas
+    // que el proyecto ya tiene escritas para otras herramientas. Vive en
+    // `harness/fuentes-de-contexto.ts` para que aquí sea una llamada: este
+    // fichero es de upstream y cada región nuestra cuesta un hunk del
+    // presupuesto de sincronización.
+    for (const fuente of fuentesDeContextoDeAda(resolvedCwd, resolvedAgentDir)) {
+        if (!seenPaths.has(fuente.path)) {
+            contextFiles.push(fuente);
+            seenPaths.add(fuente.path);
+        }
+    }
     const memoryBlock = options.memoryEngine?.getPromptBlockSync() ?? "";
     if (memoryBlock) {
         contextFiles.push({ path: "<ada-memory>", content: memoryBlock });
     }
     else {
-        const memoryFile = (options.projectMemoryEnabled ?? true)
-            ? loadProjectMemorySync(resolvedCwd, resolvedAgentDir)
-            : null;
+        const memoryFile = (options.projectMemoryEnabled ?? true) ? loadProjectMemorySync(resolvedCwd, resolvedAgentDir) : null;
         if (memoryFile) {
             contextFiles.push(memoryFile);
         }
@@ -148,7 +171,15 @@ export class DefaultResourceLoader {
     noThemes;
     noContextFiles;
     memoryEngine = null;
+    mcpManager = null;
     vaultManager = null;
+    workflowManager = null;
+    /** Getter del modelo de la sesión principal (los subagentes lo heredan). */
+    sessionModelGetter = null;
+    /** Callback: un run de workflow arrancó (la sesión lo reemite para el panel). */
+    onWorkflowRunStarted = null;
+    goalEngine = null;
+    graph = null;
     systemPromptSource;
     appendSystemPromptSource;
     extensionsOverride;
@@ -256,6 +287,222 @@ export class DefaultResourceLoader {
     getVaultManager() {
         return this.vaultManager;
     }
+    setSessionModelGetter(getter) {
+        this.sessionModelGetter = getter;
+    }
+    setOnWorkflowRunStarted(cb) {
+        this.onWorkflowRunStarted = cb;
+    }
+    getWorkflowManager() {
+        if (!this.workflowManager) {
+            this.workflowManager = new WorkflowManager({
+                runsDir: join(this.agentDir, "workflows", "runs"),
+                createSession: (options) => import("./workflows/subagent-host.js").then((m) => m.createSubagentSession({ ...options, hostModel: this.sessionModelGetter?.() ?? undefined })),
+                // Los runs del goal (goal_subtask) marcan la sub-tarea del goal
+                // al terminar — el goal es contenedor, los workflows son los pasos.
+                onEvent: (type, payload) => {
+                    if (type === "workflow_run_started") {
+                        const st = payload;
+                        this.onWorkflowRunStarted?.(st.runId, st.name);
+                    }
+                    if (type === "workflow_run_finished") {
+                        const fin = payload;
+                        void this.goalEngine
+                            ?.onWorkflowFinished(fin.runId, fin.status === "completed", fin.error, {
+                            tokens: fin.tokens,
+                            cost: fin.cost,
+                        })
+                            .catch(() => { });
+                    }
+                },
+            });
+            // Desatascar los runs que murieron con un proceso anterior. Sin esto,
+            // un Ctrl-C durante una sub-tarea deja el goal bloqueado para siempre,
+            // porque tick() no avanza mientras haya una task en `running`.
+            void this.workflowManager.reconcile().catch(() => { });
+            // Barrer dev servers/watchers que sobrevivieron a un SIGKILL previo.
+            // La identidad de arranque evita matar un pid reciclado ajeno.
+            void import("./orphan-process-journal.js")
+                .then(async ({ OrphanProcessJournal }) => {
+                const journal = new OrphanProcessJournal(this.agentDir);
+                const { killProcessTree, setOrphanProcessJournal } = await import("../utils/shell.js");
+                setOrphanProcessJournal(journal);
+                await journal.reap(killProcessTree);
+            })
+                .catch(() => { });
+        }
+        return this.workflowManager;
+    }
+    /**
+     * GoalEngine — el bucle de trabajo autónomo (Fase 4). El work/judge se
+     * conectan al SDK real vía createSubagentSession + AgentRunner; el juez
+     * usa un subagente SIN tools (solo goal+criteria+evidencia → verdict).
+     */
+    /**
+     * Integraciones MCP. Los tokens salen del Vault cifrado; si está bloqueado,
+     * la integración simplemente no está disponible — nunca se cae a texto plano.
+     */
+    getMcpManager() {
+        if (!this.mcpManager) {
+            const servers = this.settingsManager.getMcpServers();
+            // Sin servidores declarados no se instancia nada: el catálogo builtin
+            // solo aparece cuando el usuario configura algo.
+            if (!servers || Object.keys(servers).length === 0)
+                return null;
+            this.mcpManager = new McpManager({
+                getServers: () => this.settingsManager.getMcpServers(),
+                getVaultSecret: async (name) => {
+                    try {
+                        // `get` es síncrono y devuelve null si el vault está bloqueado:
+                        // en ese caso la integración queda no disponible, nunca se cae a
+                        // una credencial en claro.
+                        return this.getVaultManager()?.getSecret(name) ?? undefined;
+                    }
+                    catch {
+                        return undefined;
+                    }
+                },
+            });
+        }
+        return this.mcpManager;
+    }
+    getGoalEngine() {
+        if (!this.goalEngine) {
+            const agentDir = this.agentDir;
+            const createSession = (options) => import("./workflows/subagent-host.js").then((m) => m.createSubagentSession(options));
+            // Techo de agentes: contador fresco por runner, pero se respeta el
+            // mismo ajuste que los workflows para no tener dos políticas.
+            const wfCfg = this.settingsManager.getEngineConfig().workflows;
+            const maxAgents = typeof wfCfg?.maxAgentsPerRun === "number"
+                ? wfCfg.maxAgentsPerRun
+                : DEFAULT_WORKFLOW_LIMITS.maxAgentsPerRun;
+            const _runner = new AgentRunner({
+                agentDir,
+                createSession: createSession,
+                limiter: async (fn) => fn(),
+                agentCounter: { count: 0 },
+                maxAgents,
+            });
+            const judgeRunner = new AgentRunner({
+                agentDir,
+                createSession: createSession,
+                limiter: async (fn) => fn(),
+                agentCounter: { count: 0 },
+                maxAgents,
+            });
+            const goalsDir = join(this.agentDir, "workflows", "goals");
+            // Frenos del GoalEngine leídos de la config (§16.2) en el arranque;
+            // cambios en caliente se aplican en decisiones posteriores vía getConfig.
+            const goalCfg = this.settingsManager.getEngineConfig().goalEngine;
+            const gStopFile = (goalCfg.stopFile ?? "~/.ada-stop");
+            this.goalEngine = new GoalEngine({
+                persistence: new FileGoalPersistence(goalsDir),
+                // Raíz real del proyecto: la huella anti-cheat compara el árbol de
+                // trabajo entre fallos, y process.cwd() no siempre es el repo.
+                cwd: this.cwd,
+                onEvent: (type, _payload) => {
+                    // (los eventos del goal ya los maneja la sesión; aquí solo
+                    // reenviamos el update para el grafo/panel si hace falta)
+                    void type;
+                },
+                frenos: {
+                    maxTurns: (goalCfg.maxTurns ?? 25),
+                    repeatTolerance: (goalCfg.repeatDetector ?? 3),
+                    tokenBudget: (goalCfg.budgetTokens ?? null),
+                    askBefore: (goalCfg.askBefore ?? []),
+                    stopFile: expandTilde(gStopFile),
+                },
+                // P5: modo plan-only desde settings (default off).
+                planOnly: (goalCfg.planOnly ?? false) === true,
+                launchWorkflow: async (input) => {
+                    // Modelo contenedor: cada sub-tarea del goal lanza un workflow
+                    // dinámico. Se genera un script que ejecuta esa sub-tarea con un
+                    // agente (mismo runtime/memoria/vault), con su criterio en el prompt.
+                    // goalEngine.workTier: "cheap" → el agente de la sub-tarea usa el
+                    // modelo barato (ahorro); default "main" (modelo por defecto).
+                    const workTier = goalCfg.workTier === "cheap" ? "cheap" : undefined;
+                    const manager = this.workflowManager;
+                    if (!manager)
+                        throw new Error("WorkflowManager no disponible");
+                    const script = generateSubtaskWorkflowScript(input, workTier);
+                    const { runId } = await manager.execute(script, {
+                        args: { goal: input.goal, task: input.taskTitle, doneCriteria: input.doneCriteria.join("\n- ") },
+                        displayName: input.taskTitle, // el panel muestra esto, no el genérico
+                        await: false, // background; onWorkflowFinished marca la sub-tarea
+                        sessionId: input.sessionId, // el panel del desktop filtra por esto
+                    });
+                    return { runId };
+                },
+                judge: async (input) => {
+                    // Juez FINAL del goal (modelo contenedor: solo corre cuando
+                    // todas las sub-tareas done o hay fallos). Usa el modelo por
+                    // defecto — el veredicto final nunca va en modelo barato.
+                    const result = await judgeRunner.run({
+                        prompt: buildGoalJudgePrompt(input),
+                        label: "goal-judge",
+                        phase: "judge",
+                    });
+                    const parsed = result ? extractJson(result.text) : undefined;
+                    const verdict = parsed && typeof parsed === "object" && parsed.verdict === "done"
+                        ? "done"
+                        : "continue";
+                    return {
+                        verdict,
+                        reason: parsed && typeof parsed === "object" && typeof parsed.reason === "string"
+                            ? parsed.reason
+                            : "sin razón estructurada",
+                        crossModel: true,
+                    };
+                },
+                replanFn: async (input) => {
+                    // P1: re-planificación completa tras continue. Mismo modelo
+                    // del juez (nunca cheap): el nuevo plan debe ser riguroso.
+                    const result = await judgeRunner.run({
+                        prompt: buildGoalReplanPrompt({
+                            goal: input.goal,
+                            doneCriteria: input.doneCriteria,
+                            verifyCommand: input.verifyCommand,
+                            evidence: input.evidence,
+                            currentTasks: input.currentTasks.map((t) => t.title),
+                            lastReason: input.lastReason,
+                        }),
+                        label: "goal-replan",
+                        phase: "judge",
+                    });
+                    const parsed = result ? extractJson(result.text) : undefined;
+                    const tasks = parsed && Array.isArray(parsed.tasks)
+                        ? parsed.tasks
+                            .filter((t) => typeof t?.title === "string" && t.title.trim())
+                            .map((t) => ({ title: t.title.trim() }))
+                        : [];
+                    if (tasks.length === 0)
+                        throw new Error("replan sin tareas válidas");
+                    return {
+                        tasks,
+                        rationale: parsed && typeof parsed.rationale === "string"
+                            ? parsed.rationale
+                            : "plan regenerado",
+                    };
+                },
+            });
+        }
+        return this.goalEngine;
+    }
+    /**
+     * Graph — grafo de trabajo (identidad estructurada del Ada Intelligence
+     * Engine, §5). Persistencia JSON + índice invertido en workflows/graph/.
+     * Lazy a petición (zero-cost hasta el primer uso).
+     */
+    getGraph() {
+        if (!this.graph) {
+            this.graph = new Graph({
+                store: new FileGraphStore(join(this.agentDir, "workflows", "graph")),
+                minConfidence: 0.6,
+            });
+            void this.graph.init().catch(() => { });
+        }
+        return this.graph;
+    }
     getSystemPrompt() {
         return this.systemPrompt;
     }
@@ -781,8 +1028,44 @@ export class DefaultResourceLoader {
             diagnostics.push({ type: "warning", message, path: filePath });
         }
     }
+    /**
+     * Extensiones internas de Ada (caché de prompt, ficheros grandes).
+     *
+     * Van marcadas `hidden`: son infraestructura, no algo que el usuario haya
+     * instalado, así que no salen en la lista de extensiones de la interfaz.
+     *
+     * Pero SÍ tienen que volver en el array. El ExtensionRunner recorre el array
+     * de extensiones para encontrar los manejadores; una extensión que no está
+     * en él es una extensión sin manejadores. Antes esta función se comía el
+     * objeto devuelto por `loadExtensionFromFactory` y no lo devolvía: la caché
+     * de prompt llevaba meses cargándose y `before_provider_request` no se
+     * llamaba NUNCA. Se ve con `getExtensions().extensions`, que salía vacío.
+     */
+    async loadBuiltinExtensions(runtime) {
+        const internas = [];
+        const cargar = async (factory, extensionPath) => {
+            try {
+                const extension = await loadExtensionFromFactory(factory, this.cwd, this.eventBus, runtime, extensionPath);
+                extension.hidden = true;
+                internas.push(extension);
+            }
+            catch {
+                // Una extensión interna nunca debe impedir arrancar una sesión.
+            }
+        };
+        if (this.settingsManager.getPromptCacheEnabled()) {
+            await cargar(createPromptCacheExtension({ agentDir: this.agentDir }), "<ada:prompt-cache>");
+        }
+        // Import dinámico y no estático a propósito: biome ordena los imports y uno
+        // nuevo arriba caería lejos del de `prompt-cache`, abriendo un hunk más
+        // contra el presupuesto de sync, que está agotado (116/116). Aquí dentro no
+        // cuesta nada y además retrasa la carga del módulo hasta que hay sesión.
+        const { crearExtensionDeBlobs } = await import("./blobs/index.js");
+        await cargar(crearExtensionDeBlobs({ agentDir: this.agentDir }), "<ada:blobs>");
+        return internas;
+    }
     async loadExtensionFactories(runtime) {
-        const extensions = [];
+        const extensions = await this.loadBuiltinExtensions(runtime);
         const errors = [];
         for (const [index, input] of this.extensionFactories.entries()) {
             const isNamed = typeof input !== "function";
@@ -915,4 +1198,39 @@ export class DefaultResourceLoader {
         return conflicts;
     }
 }
+/** Expande ~ en rutas (stop-file del GoalEngine). */
+function expandTilde(p) {
+    if (p === "~" || p.startsWith("~/") || p.startsWith("~\\")) {
+        const home = homedir();
+        return p === "~" ? home : home + p.slice(1);
+    }
+    return p;
+}
+/**
+ * Genera el script del workflow dinámico que ejecuta UNA sub-tarea del goal.
+ * Un agente, prompt = la sub-tarea + objetivo + criterios; devuelve un
+ * resumen estructurado que el juez del goal usa.
+ */
+export function generateSubtaskWorkflowScript(input, workTier) {
+    const criteria = input.doneCriteria.length > 0 ? input.doneCriteria.map((c) => `- ${c}`).join("\n") : "- (sin criterios)";
+    const prompt = JSON.stringify(`Objetivo del goal: ${input.goal}\n\nSUB-TAREA que debes cumplir AHORA: ${input.taskTitle}\n\nCriterios de éxito del goal:\n${criteria}\n\nEjecuta la sub-tarea con las tools (read/bash/write/edit/web). NO la des por hecha sin verificación real: corre tests/comandos. Devuelve JSON {"summary": string, "verified": boolean, "evidence": [{"claim": string, "source": string}]} con source archivo:línea o salida de comando.${input.verifyCommand ? `\n\nComando de verificación disponible: ${input.verifyCommand}` : ""}`);
+    const label = JSON.stringify(String(input.taskTitle ?? input.taskId).slice(0, 72));
+    const tierLine = workTier === "cheap" ? '\n  tier: "cheap",' : "";
+    return `export const meta = {
+  "name": "goal_subtask",
+  "description": "Ejecuta una sub-tarea del goal",
+  "phases": [{ "title": "Execute" }, { "title": "Summarize" }]
+}
+
+phase("Execute")
+const result = await agent({
+  prompt: ${prompt},
+  label: ${label},${tierLine}
+  schema: { type: "object", properties: { summary: { type: "string" }, verified: { type: "boolean" }, evidence: { type: "array", items: { type: "object", properties: { claim: { type: "string" }, source: { type: "string" } }, required: ["claim", "source"] } } }, required: ["summary", "verified", "evidence"] }
+})
+
+phase("Summarize")
+return result && result.summary ? JSON.stringify({ summary: result.summary, verified: result.verified, evidence: result.evidence }) : JSON.stringify({ summary: "sin resumen", verified: false, evidence: [] })
+`;
+}
 //# sourceMappingURL=resource-loader.js.map