@hoilab/ada-cli 0.84.21 → 0.84.22

package/dist/modes/interactive/components/settings-selector.js

@@ -1,12 +1,13 @@
-import { Container, getCapabilities, SelectList, SettingsList, Spacer, Text, } from "@earendil-works/pi-tui";
+import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+import { Container, getCapabilities, SettingsList, Spacer, Text, } from "@earendil-works/pi-tui";
 import { formatHttpIdleTimeoutMs, HTTP_IDLE_TIMEOUT_CHOICES } from "../../../core/http-dispatcher.js";
-import { getSelectListTheme, getSettingsListTheme, parseAutoThemeSetting, theme, } from "../theme/theme.js";
+import { getSettingsListTheme, parseAutoThemeSetting, theme } from "../theme/theme.js";
 import { DynamicBorder } from "./dynamic-border.js";
 import { keyDisplayText } from "./keybinding-hints.js";
-const SETTINGS_SUBMENU_SELECT_LIST_LAYOUT = {
-    minPrimaryColumnWidth: 12,
-    maxPrimaryColumnWidth: 32,
-};
+import { SelectSubmenu, SteppedSubmenu } from "./settings-submenu.js";
+const NO_DEFAULT_MODEL_VALUE = "__none__";
+const NO_DEFAULT_MODEL_LABEL = "not set";
+const MODEL_PICKER_LAYOUT = { minPrimaryColumnWidth: 12, maxPrimaryColumnWidth: 46 };
 const THINKING_DESCRIPTIONS = {
     off: "No reasoning",
     minimal: "Very brief reasoning (~1k tokens)",
@@ -54,43 +55,44 @@ class WarningSettingsSubmenu extends Container {
         this.settingsList.handleInput(data);
     }
 }
-class SelectSubmenu extends Container {
-    selectList;
-    constructor(title, description, options, currentValue, onSelect, onCancel, onSelectionChange) {
-        super();
-        // Title
-        this.addChild(new Text(theme.bold(theme.fg("accent", title)), 0, 0));
-        // Description
-        if (description) {
-            this.addChild(new Spacer(1));
-            this.addChild(new Text(theme.fg("muted", description), 0, 0));
-        }
-        // Spacer
-        this.addChild(new Spacer(1));
-        // Select list
-        this.selectList = new SelectList(options, Math.min(options.length, 10), getSelectListTheme(), SETTINGS_SUBMENU_SELECT_LIST_LAYOUT);
-        // Pre-select current value
-        const currentIndex = options.findIndex((o) => o.value === currentValue);
-        if (currentIndex !== -1) {
-            this.selectList.setSelectedIndex(currentIndex);
-        }
-        this.selectList.onSelect = (item) => {
-            onSelect(item.value);
+const CLEAR_OVERRIDE_VALUE = "__clear__";
+function modelSettingKey(model) {
+    return `${model.provider}/${model.id}`;
+}
+function modelDisplayLabel(model) {
+    return `${model.id} [${model.provider}]`;
+}
+function defaultModelDisplayValue(key, model, overrides) {
+    const label = model ? modelDisplayLabel(model) : key;
+    const override = overrides[key];
+    return override ? `${label} \u00b7 ${override}` : label;
+}
+function modelThinkingOverridesSummary(overrides) {
+    const count = Object.keys(overrides).length;
+    if (count === 0)
+        return "none";
+    return `${count} configured`;
+}
+function modelItemLabel(model) {
+    return `${model.id} ${theme.fg("muted", `[${model.provider}]`)}`;
+}
+function defaultModelItems(models, overrides) {
+    return [...models]
+        .sort((a, b) => {
+        const providerCompare = a.provider.localeCompare(b.provider);
+        if (providerCompare !== 0)
+            return providerCompare;
+        return (a.name || a.id).localeCompare(b.name || b.id);
+    })
+        .map((model) => {
+        const key = modelSettingKey(model);
+        const override = overrides?.[key];
+        return {
+            value: key,
+            label: modelItemLabel(model),
+            description: override ?? undefined,
         };
-        this.selectList.onCancel = onCancel;
-        if (onSelectionChange) {
-            this.selectList.onSelectionChange = (item) => {
-                onSelectionChange(item.value);
-            };
-        }
-        this.addChild(this.selectList);
-        // Hint
-        this.addChild(new Spacer(1));
-        this.addChild(new Text(theme.fg("dim", "  Enter to select · Esc to go back"), 0, 0));
-    }
-    handleInput(data) {
-        this.selectList.handleInput(data);
-    }
+    });
 }
 function themeItems(availableThemes) {
     return availableThemes.map((name) => ({ value: name, label: name }));
@@ -271,7 +273,14 @@ export class SettingsSelectorComponent extends Container {
         super();
         const supportsImages = getCapabilities().images;
         const followUpKey = keyDisplayText("app.message.followUp");
+        const cycleThinkingKey = keyDisplayText("app.thinking.cycle");
         let currentWarnings = { ...config.warnings };
+        const currentModelThinkingLevels = { ...config.modelThinkingLevels };
+        let lastSelectedDefaultModel;
+        const defaultModelByValue = new Map(config.availableDefaultModels.map((model) => [modelSettingKey(model), model]));
+        let currentDefaultModelKey = defaultModelByValue.has(config.defaultModel)
+            ? config.defaultModel
+            : undefined;
         const items = [
             {
                 id: "autocompact",
@@ -301,6 +310,38 @@ export class SettingsSelectorComponent extends Container {
                 currentValue: config.transport,
                 values: ["sse", "websocket", "websocket-cached", "auto"],
             },
+            {
+                id: "default-model",
+                label: "Default model",
+                description: "Startup model for new sessions",
+                currentValue: defaultModelDisplayValue(config.defaultModel, defaultModelByValue.get(config.defaultModel), currentModelThinkingLevels),
+                submenu: (currentValue, done) => {
+                    const fresh = defaultModelItems(config.availableDefaultModels, currentModelThinkingLevels);
+                    const options = fresh.length > 0
+                        ? fresh
+                        : [
+                            {
+                                value: NO_DEFAULT_MODEL_VALUE,
+                                label: "No models available",
+                                description: "Log in to a provider or configure an API key first",
+                            },
+                        ];
+                    return new SelectSubmenu("Default Model", "Select the model to use when starting new sessions", options, currentValue === NO_DEFAULT_MODEL_LABEL ? NO_DEFAULT_MODEL_VALUE : currentValue, (value) => {
+                        const model = defaultModelByValue.get(value);
+                        if (!model) {
+                            done();
+                            return;
+                        }
+                        void callbacks.onDefaultModelChange(model).then(() => {
+                            lastSelectedDefaultModel = model;
+                            currentDefaultModelKey = value;
+                            done(defaultModelDisplayValue(value, model, currentModelThinkingLevels), {
+                                navigateTo: "model-thinking",
+                            });
+                        }, () => done());
+                    }, () => done(), undefined, { searchable: true, layout: MODEL_PICKER_LAYOUT });
+                },
+            },
             {
                 id: "http-idle-timeout",
                 label: "HTTP idle timeout",
@@ -325,7 +366,7 @@ export class SettingsSelectorComponent extends Container {
             {
                 id: "cache-miss-notices",
                 label: "Cache miss notices",
-                description: "Show transcript notices for significant prompt-cache misses",
+                description: "Show transcript notices for significant prompt-cache misses and compaction costs",
                 currentValue: config.showCacheMissNotices ? "true" : "false",
                 values: ["true", "false"],
             },
@@ -383,10 +424,10 @@ export class SettingsSelectorComponent extends Container {
             },
             {
                 id: "thinking",
-                label: "Thinking level",
-                description: "Reasoning depth for thinking-capable models",
+                label: "Default thinking level",
+                description: `Startup reasoning depth for thinking-capable models. ${cycleThinkingKey} cycles in-session.`,
                 currentValue: config.thinkingLevel,
-                submenu: (currentValue, done) => new SelectSubmenu("Thinking Level", "Select reasoning depth for thinking-capable models", config.availableThinkingLevels.map((level) => ({
+                submenu: (currentValue, done) => new SelectSubmenu("Default Thinking Level", "Select the reasoning depth to use when starting new sessions", config.availableThinkingLevels.map((level) => ({
                     value: level,
                     label: level,
                     description: THINKING_DESCRIPTIONS[level],
@@ -395,6 +436,104 @@ export class SettingsSelectorComponent extends Container {
                     done(value);
                 }, () => done()),
             },
+            {
+                id: "model-thinking",
+                label: "Default thinking level per model",
+                description: `Override the default thinking level for specific models. ${cycleThinkingKey} cycles in-session.`,
+                currentValue: modelThinkingOverridesSummary(currentModelThinkingLevels),
+                submenu: (_currentValue, done) => {
+                    const preselected = lastSelectedDefaultModel;
+                    lastSelectedDefaultModel = undefined;
+                    const steps = [
+                        {
+                            key: "model",
+                            title: "Per-Model Thinking Level",
+                            description: "Select a model to configure",
+                            options: () => {
+                                const sorted = [...config.availableDefaultModels].sort((a, b) => {
+                                    const aKey = modelSettingKey(a);
+                                    const bKey = modelSettingKey(b);
+                                    if (aKey === currentDefaultModelKey)
+                                        return -1;
+                                    if (bKey === currentDefaultModelKey)
+                                        return 1;
+                                    const pc = a.provider.localeCompare(b.provider);
+                                    if (pc !== 0)
+                                        return pc;
+                                    return (a.name || a.id).localeCompare(b.name || b.id);
+                                });
+                                const items = sorted.map((model) => {
+                                    const key = modelSettingKey(model);
+                                    const override = currentModelThinkingLevels[key];
+                                    return {
+                                        value: key,
+                                        label: modelItemLabel(model),
+                                        description: override ?? undefined,
+                                    };
+                                });
+                                if (items.length === 0) {
+                                    items.push({
+                                        value: "__none__",
+                                        label: "No models available",
+                                        description: "Log in to a provider or configure an API key first",
+                                    });
+                                }
+                                return items;
+                            },
+                            preselect: () => currentDefaultModelKey,
+                            searchable: true,
+                            layout: MODEL_PICKER_LAYOUT,
+                        },
+                        {
+                            key: "level",
+                            title: (ctx) => {
+                                const m = defaultModelByValue.get(ctx.model);
+                                return `Thinking Level for ${m ? modelDisplayLabel(m) : ctx.model}`;
+                            },
+                            description: "Select default thinking level for this model",
+                            options: (ctx) => {
+                                const model = defaultModelByValue.get(ctx.model);
+                                if (!model)
+                                    return [];
+                                const levels = (model.reasoning ? getSupportedThinkingLevels(model) : ["off"]);
+                                const items = levels.map((level) => ({
+                                    value: level,
+                                    label: level,
+                                    description: THINKING_DESCRIPTIONS[level],
+                                }));
+                                if (currentModelThinkingLevels[ctx.model] !== undefined) {
+                                    items.push({
+                                        value: CLEAR_OVERRIDE_VALUE,
+                                        label: "(clear override)",
+                                        description: `Revert to global default (${config.thinkingLevel})`,
+                                    });
+                                }
+                                return items;
+                            },
+                            preselect: (ctx) => currentModelThinkingLevels[ctx.model],
+                        },
+                    ];
+                    const summary = () => modelThinkingOverridesSummary(currentModelThinkingLevels);
+                    return new SteppedSubmenu(steps, (selections) => {
+                        const model = defaultModelByValue.get(selections.model);
+                        if (!model)
+                            return;
+                        if (selections.level === CLEAR_OVERRIDE_VALUE) {
+                            callbacks.onModelThinkingLevelRemove(model.provider, model.id);
+                            delete currentModelThinkingLevels[selections.model];
+                        }
+                        else {
+                            callbacks.onModelThinkingLevelChange(model.provider, model.id, selections.level);
+                            currentModelThinkingLevels[selections.model] = selections.level;
+                        }
+                    }, () => {
+                        this.settingsList.updateValue("default-model", defaultModelDisplayValue(currentDefaultModelKey ?? config.defaultModel, defaultModelByValue.get(currentDefaultModelKey ?? config.defaultModel), currentModelThinkingLevels));
+                        done(summary());
+                    }, preselected
+                        ? { startAtStep: 1, initialContext: { model: modelSettingKey(preselected) } }
+                        : { loop: true });
+                },
+            },
             {
                 id: "tui-mode",
                 label: "TUI mode",
@@ -477,6 +616,50 @@ export class SettingsSelectorComponent extends Container {
             currentValue: config.memoryMode ?? "policy",
             values: ["policy", "inject"],
         });
+        // ── Ada Intelligence Engine (tras memory-mode) ──
+        const engineAnchor = items.findIndex((item) => item.id === "memory-mode");
+        items.splice(engineAnchor + 1, 0, {
+            id: "engine-goal",
+            label: "Goal Engine",
+            description: "Bucle autónomo con fases TDD, juez obligatorio y frenos (goals con /goal)",
+            currentValue: config.goalEngineEnabled ? "true" : "false",
+            values: ["true", "false"],
+        });
+        items.splice(engineAnchor + 2, 0, {
+            id: "engine-goal-tier",
+            label: "Goal work tier",
+            description: "Modelo de las fases de trabajo: main = por defecto; cheap = el más barato conectado",
+            currentValue: config.goalWorkTier,
+            values: ["main", "cheap"],
+        });
+        items.splice(engineAnchor + 3, 0, {
+            id: "engine-goal-turns",
+            label: "Goal max turns",
+            description: "Freno: turnos máximos por goal antes de abortar",
+            currentValue: String(config.goalMaxTurns),
+            values: ["10", "15", "25", "50", "100"],
+        });
+        items.splice(engineAnchor + 4, 0, {
+            id: "engine-workflows",
+            label: "Workflows",
+            description: "Orquestación paralela sandboxeada (/workflow, tool workflow)",
+            currentValue: config.workflowsEnabled ? "true" : "false",
+            values: ["true", "false"],
+        });
+        items.splice(engineAnchor + 5, 0, {
+            id: "engine-repeat",
+            label: "Subtask retries",
+            description: "Reintentos de una sub-tarea fallida antes de pausar el goal (repeat detector)",
+            currentValue: String(config.goalRepeatTolerance),
+            values: ["1", "2", "3", "5"],
+        });
+        items.splice(engineAnchor + 6, 0, {
+            id: "prompt-optimizer",
+            label: "Prompt optimizer",
+            description: "Mejora automática de tu petición antes del modelo (auto = sin preguntar; clarify = pregunta primero; off = desactivado)",
+            currentValue: config.promptOptimizerMode,
+            values: ["auto", "clarify", "off"],
+        });
         // Skill commands toggle (insert after memory-mode)
         const memoryModeIndex = items.findIndex((item) => item.id === "memory-mode");
         items.splice(memoryModeIndex + 1, 0, {
@@ -565,6 +748,24 @@ export class SettingsSelectorComponent extends Container {
                 case "memory-mode":
                     callbacks.onMemoryModeChange(newValue);
                     break;
+                case "engine-goal":
+                    callbacks.onGoalEngineEnabledChange(newValue === "true");
+                    break;
+                case "engine-goal-tier":
+                    callbacks.onGoalWorkTierChange(newValue);
+                    break;
+                case "engine-goal-turns":
+                    callbacks.onGoalMaxTurnsChange(parseInt(newValue, 10) || 25);
+                    break;
+                case "engine-workflows":
+                    callbacks.onWorkflowsEnabledChange(newValue === "true");
+                    break;
+                case "engine-repeat":
+                    callbacks.onRepeatToleranceChange(parseInt(newValue, 10) || 3);
+                    break;
+                case "prompt-optimizer":
+                    callbacks.onPromptOptimizerModeChange(newValue);
+                    break;
                 case "skill-commands":
                     callbacks.onEnableSkillCommandsChange(newValue === "true");
                     break;