apex-code 0.0.1-alpha.0 → 0.0.1-alpha.10

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

@@ -1,12 +1,12 @@
-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 { PERMISSION_MODES } from "../../../core/permissions/store.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 MODEL_PICKER_LAYOUT = { minPrimaryColumnWidth: 12, maxPrimaryColumnWidth: 46 };
 const THINKING_DESCRIPTIONS = {
     off: "No reasoning",
     minimal: "Very brief reasoning (~1k tokens)",
@@ -22,6 +22,38 @@ const DEFAULT_PROJECT_TRUST_LABELS = {
     never: "Never trust",
 };
 const DEFAULT_PROJECT_TRUST_BY_LABEL = new Map(Object.entries(DEFAULT_PROJECT_TRUST_LABELS).map(([value, label]) => [label, value]));
+const PERMISSION_MODE_DESCRIPTIONS = {
+    default: "Ask for anything policy does not already allow",
+    plan: "Block file writes, commands, and delegation while you investigate",
+    acceptEdits: "Auto-allow plain file edits; still ask for commands and network",
+    dontAsk: "Never prompt; deny anything not already permitted",
+    bypassPermissions: "Allow every tool call without asking",
+};
+/**
+ * What outranks a user-scope write, phrased for someone deciding whether to bother.
+ * `user` and `default` are absent because neither shadows anything this menu writes.
+ */
+export const PERMISSION_MODE_OVERRIDE_HINTS = {
+    flag: "--permission-mode on the command line",
+    local: ".apex-code/permissions.local.json in this project",
+    project: ".apex-code/permissions.json in this project",
+    command: "a command-scoped override in this session",
+    session: "a session-scoped override",
+};
+/** Empty when the session has no permission gate, so the row simply does not exist. */
+function permissionModeItems(current, callbacks) {
+    if (!current)
+        return [];
+    return [
+        {
+            id: "permission-mode",
+            label: "Permission mode",
+            description: PERMISSION_MODE_DESCRIPTIONS[current.mode],
+            currentValue: current.mode,
+            submenu: (currentValue, done) => new PermissionModeSubmenu(currentValue, current.origin, (mode) => callbacks.onPermissionModeChange(mode), done),
+        },
+    ];
+}
 /**
  * A submenu component for selecting from a list of options.
  */
@@ -54,42 +86,82 @@ class WarningSettingsSubmenu extends Container {
         this.settingsList.handleInput(data);
     }
 }
-class SelectSubmenu extends Container {
-    selectList;
-    constructor(title, description, options, currentValue, onSelect, onCancel, onSelectionChange) {
+const CLEAR_OVERRIDE_VALUE = "__clear__";
+function modelSettingKey(model) {
+    return `${model.provider}/${model.id}`;
+}
+function modelDisplayLabel(model) {
+    return `${model.id} [${model.provider}]`;
+}
+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}]`)}`;
+}
+/**
+ * Permission mode picker, mode list then a confirm step for `bypassPermissions`.
+ * The confirm exists because the mode list is arrow-cyclable like every other
+ * settings row, so "allow every tool call" is otherwise one stray keypress away.
+ */
+class PermissionModeSubmenu extends Container {
+    inputComponent;
+    current;
+    origin;
+    onSelect;
+    onDone;
+    constructor(current, origin, onSelect, onDone) {
         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);
-        };
-        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));
+        this.current = current;
+        this.origin = origin;
+        this.onSelect = onSelect;
+        this.onDone = onDone;
+        this.showModeList();
     }
     handleInput(data) {
-        this.selectList.handleInput(data);
+        this.inputComponent?.handleInput?.(data);
+    }
+    setContent(component) {
+        this.clear();
+        this.addChild(component);
+        this.inputComponent = component;
+    }
+    description() {
+        const overridden = this.origin !== "user" && this.origin !== "default"
+            ? ` Currently set by ${PERMISSION_MODE_OVERRIDE_HINTS[this.origin]}.`
+            : "";
+        return `Saved to user scope and applied to the next tool call.${overridden}`;
+    }
+    showModeList() {
+        this.setContent(new SelectSubmenu("Permission mode", this.description(), PERMISSION_MODES.map((mode) => ({
+            value: mode,
+            label: mode,
+            description: PERMISSION_MODE_DESCRIPTIONS[mode],
+        })), this.current, (value) => {
+            const mode = value;
+            if (mode === "bypassPermissions") {
+                this.showBypassConfirm();
+                return;
+            }
+            this.onSelect(mode);
+            this.onDone(mode);
+        }, () => this.onDone()));
+    }
+    showBypassConfirm() {
+        this.setContent(new SelectSubmenu("Bypass all permission checks?", "Every tool call runs without asking, in every project, until you change this back. The OS sandbox still confines writes to the workspace and network egress to the allowlist.", [
+            { value: "no", label: `No, keep ${this.current}`, description: "Return to the mode list" },
+            { value: "yes", label: "Yes, bypass", description: "Allow every tool call without asking" },
+        ], "no", (value) => {
+            if (value !== "yes") {
+                this.showModeList();
+                return;
+            }
+            this.onSelect("bypassPermissions");
+            this.onDone("bypassPermissions");
+        }, () => this.showModeList()));
     }
 }
 function themeItems(availableThemes) {
@@ -271,7 +343,12 @@ 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 };
+        const defaultModelByValue = new Map(config.availableDefaultModels.map((model) => [modelSettingKey(model), model]));
+        const currentDefaultModelKey = defaultModelByValue.has(config.defaultModel) ? config.defaultModel : undefined;
+        const currentModelKey = config.currentModel ? modelSettingKey(config.currentModel) : undefined;
         const items = [
             {
                 id: "autocompact",
@@ -325,7 +402,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"],
             },
@@ -344,10 +421,10 @@ export class SettingsSelectorComponent extends Container {
                 values: ["true", "false"],
             },
             {
-                id: "install-telemetry",
-                label: "Install telemetry",
-                description: "Send an anonymous version/update ping after changelog-detected updates",
-                currentValue: config.enableInstallTelemetry ? "true" : "false",
+                id: "send-provider-attribution",
+                label: "Provider attribution headers",
+                description: "Identify this CLI to your configured LLM provider (e.g. OpenRouter billing origin)",
+                currentValue: config.sendProviderAttribution ? "true" : "false",
                 values: ["true", "false"],
             },
             {
@@ -357,6 +434,7 @@ export class SettingsSelectorComponent extends Container {
                 currentValue: DEFAULT_PROJECT_TRUST_LABELS[config.defaultProjectTrust],
                 values: Object.values(DEFAULT_PROJECT_TRUST_LABELS),
             },
+            ...permissionModeItems(config.permissionMode, callbacks),
             {
                 id: "double-escape-action",
                 label: "Double-escape action",
@@ -382,18 +460,98 @@ export class SettingsSelectorComponent extends Container {
                 }, () => done()),
             },
             {
-                id: "thinking",
-                label: "Thinking level",
-                description: "Reasoning depth for thinking-capable models",
-                currentValue: config.thinkingLevel,
-                submenu: (currentValue, done) => new SelectSubmenu("Thinking Level", "Select reasoning depth for thinking-capable models", config.availableThinkingLevels.map((level) => ({
-                    value: level,
-                    label: level,
-                    description: THINKING_DESCRIPTIONS[level],
-                })), currentValue, (value) => {
-                    callbacks.onThinkingLevelChange(value);
-                    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 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 === currentModelKey)
+                                        return -1;
+                                    if (bKey === currentModelKey)
+                                        return 1;
+                                    if (aKey === currentDefaultModelKey)
+                                        return -1;
+                                    if (bKey === currentDefaultModelKey)
+                                        return 1;
+                                    return a.provider.localeCompare(b.provider);
+                                });
+                                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: () => currentModelKey ?? 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;
+                        }
+                    }, () => {
+                        done(summary());
+                    }, { loop: true });
+                },
             },
             {
                 id: "tui-mode",
@@ -402,6 +560,13 @@ export class SettingsSelectorComponent extends Container {
                 currentValue: config.tuiMode,
                 values: ["regular", "fullscreen"],
             },
+            {
+                id: "fullscreen-exit-output",
+                label: "Fullscreen exit output",
+                description: "Print the transcript or only a session resume hint when exiting fullscreen mode",
+                currentValue: config.fullscreenExitOutput,
+                values: ["transcript", "resume-hint"],
+            },
             {
                 id: "fullscreen-scrollbar",
                 label: "Fullscreen scrollbar",
@@ -568,8 +733,8 @@ export class SettingsSelectorComponent extends Container {
                 case "quiet-startup":
                     callbacks.onQuietStartupChange(newValue === "true");
                     break;
-                case "install-telemetry":
-                    callbacks.onEnableInstallTelemetryChange(newValue === "true");
+                case "send-provider-attribution":
+                    callbacks.onSendProviderAttributionChange(newValue === "true");
                     break;
                 case "default-project-trust": {
                     const defaultProjectTrust = DEFAULT_PROJECT_TRUST_BY_LABEL.get(newValue);
@@ -605,6 +770,9 @@ export class SettingsSelectorComponent extends Container {
                 case "tui-mode":
                     callbacks.onTuiModeChange(newValue);
                     break;
+                case "fullscreen-exit-output":
+                    callbacks.onFullscreenExitOutputChange(newValue);
+                    break;
                 case "fullscreen-scrollbar":
                     callbacks.onFullscreenScrollbarChange(newValue);
                     break;