@armadra/agent 0.5.1 → 0.6.1

package/dist/modes/interactive/config-panel.js

@@ -0,0 +1,319 @@
+/**
+ * `/config` settings panel component (docs/wave6-plan.md §6.3, D24-D26). [W6-S]
+ *
+ * Bottom overlay with the card bar: title + write target (`Tab` switches user / project), a search line,
+ * the grouped `SettingsList`, a rule, the selected key's description (key-docs, dim, wrapped), one notice
+ * line and the key hints. What a key press *does* to a setting is the controller's job (config-ui.ts):
+ * the panel calls `activate(key)` for Enter / Space, `unset(key)` for a confirmed Backspace / Delete,
+ * `commit(key, text)` for the inline number / text editor, `switchScope()` for Tab and `close()` for Esc.
+ *
+ * Keys: ↑↓ (and Ctrl+P / Ctrl+N) move; `/` starts a search (typing filters, Esc clears it first, a
+ * second Esc closes); Backspace / Delete asks once, then unsets; inside the editor Enter saves (an
+ * invalid value stays in the box with the error in red), Esc cancels.
+ */
+import { Card, SettingsList, defaultKeybindings, isPasteData, isPrintableText, matchesKey, truncateToWidth, unwrapPaste, wrapTextWithAnsi, } from "../../tui.js";
+import { msg } from "../../i18n/index.js";
+import { formatSettingValue, getConfigValue, overriddenFor, } from "../../config/edit.js";
+import { SETTING_HINTS, settingDoc, settingDynamicDefault, settingsRegistry, } from "../../config/settings-registry.js";
+const ELSEWHERE = "elsewhere:";
+/** Display text of a setting value (unset ASCII shows the detected value). */
+export function settingValueText(spec, value, theme) {
+    if (value.value === undefined && spec.key === "ui.ascii")
+        return msg().settings.auto(String(theme.glyphs.ascii));
+    return formatSettingValue(value.value);
+}
+function lockReason(value) {
+    const reasons = msg().settings.lockReason;
+    if (value.source === "env")
+        return reasons.env(value.envName ?? "");
+    if (value.source === "cli")
+        return reasons.cli;
+    if (value.source === "profile")
+        return reasons.profile;
+    return reasons.project;
+}
+/** Why the row cannot be changed in `scope` (undefined: editable). */
+export function blockedReason(spec, value, scope) {
+    const s = msg().settings;
+    if (overriddenFor(value, scope) !== undefined)
+        return s.errors.locked(s.labels[spec.key] ?? spec.key, lockReason(value));
+    if (scope === "project" && spec.project === "deny")
+        return s.errors.projectDenied(spec.key);
+    return undefined;
+}
+/** Panel rows for a snapshot (pure; frame tests use it directly). */
+export function settingRows(snapshot, scope, theme) {
+    const s = msg().settings;
+    const labels = s.labels;
+    const rows = settingsRegistry().map((spec) => {
+        const value = getConfigValue(snapshot, spec.key);
+        const locked = overriddenFor(value, scope) !== undefined;
+        const tag = spec.prefix === true ? `${s.apply[spec.apply]} · ${s.prefixTag}` : s.apply[spec.apply];
+        let note;
+        let noteColor;
+        if (locked) {
+            note = s.locked(value.envName ?? value.source);
+            noteColor = "warning";
+        }
+        else if (scope === "project" && spec.project !== "any")
+            note = s.projectNote[spec.project];
+        else if (value.source !== "default")
+            note = s.source(value.source);
+        const row = {
+            id: spec.key,
+            group: s.groups[spec.group],
+            label: labels[spec.key] ?? spec.key,
+            value: settingValueText(spec, value, theme),
+            tag,
+            search: [...(spec.options ?? []), settingDoc(spec.key) ?? ""].join(" "),
+        };
+        if (value.value === undefined)
+            row.valueColor = "dim";
+        if (note !== undefined)
+            row.note = note;
+        if (noteColor !== undefined)
+            row.noteColor = noteColor;
+        if (scope === "project" && spec.project === "deny")
+            row.dim = true;
+        return row;
+    });
+    for (const hint of SETTING_HINTS) {
+        rows.push({
+            id: `${ELSEWHERE}${hint.key}`,
+            group: s.groups.elsewhere,
+            label: hint.key,
+            value: s.hints[hint.hint],
+            dim: true,
+        });
+    }
+    return rows;
+}
+/** Hint text for an "edited elsewhere" row id (undefined for settings). */
+export function hintOf(id) {
+    if (!id.startsWith(ELSEWHERE))
+        return undefined;
+    const key = id.slice(ELSEWHERE.length);
+    const hint = SETTING_HINTS.find((h) => h.key === key);
+    return hint === undefined ? undefined : msg().settings.hints[hint.hint];
+}
+class Lines {
+    build;
+    constructor(build) {
+        this.build = build;
+    }
+    render(width) {
+        return this.build(width);
+    }
+    invalidate() { }
+}
+/** Fixed lines besides the list: title (+ embedded), search, rule, description (≤ 3), notice, footer. */
+const CHROME = 8;
+export class ConfigPanel {
+    snapshot;
+    deps;
+    focused = false;
+    scope = "user";
+    list;
+    searching = false;
+    edit;
+    pendingUnset;
+    notice;
+    busy = false;
+    constructor(snapshot, deps) {
+        this.snapshot = snapshot;
+        this.deps = deps;
+        this.list = new SettingsList({ theme: deps.theme, emptyText: msg().settings.noMatches });
+        this.refresh(snapshot);
+    }
+    /** Selected row id (tests). */
+    get selectedKey() {
+        return this.list.selectedRow?.id;
+    }
+    get editing() {
+        return this.edit !== undefined;
+    }
+    refresh(snapshot = this.snapshot) {
+        this.snapshot = snapshot;
+        this.list.setRows(settingRows(snapshot, this.scope, this.deps.theme));
+    }
+    select(key) {
+        this.list.selectId(key);
+    }
+    setNotice(text, color = "dim") {
+        this.notice = text === undefined ? undefined : { text, color };
+    }
+    /** Open the inline editor for a number / text key. */
+    startEdit(key, initial) {
+        this.edit = { key, text: initial };
+    }
+    handleInput(data) {
+        if (this.busy)
+            return;
+        const keys = this.deps.keybindings ?? defaultKeybindings;
+        if (this.edit !== undefined)
+            return this.editInput(data);
+        const row = this.list.selectedRow;
+        const unsetKey = matchesKey(data, "backspace") || matchesKey(data, "delete");
+        if (!unsetKey || this.searching)
+            this.pendingUnset = undefined;
+        if (keys.matches(data, "tui.select.up"))
+            return this.move(-1);
+        if (keys.matches(data, "tui.select.down"))
+            return this.move(1);
+        if (matchesKey(data, "escape") || keys.matches(data, "app.clear")) {
+            if (this.searching || this.list.query !== "") {
+                this.searching = false;
+                this.list.setQuery("");
+                return;
+            }
+            return this.deps.close();
+        }
+        if (matchesKey(data, "tab")) {
+            this.scope = this.scope === "user" ? "project" : "user";
+            this.notice = undefined;
+            this.refresh();
+            return;
+        }
+        if (this.searching) {
+            if (matchesKey(data, "enter") && row !== undefined)
+                return this.run(this.deps.activate(row.id, this.scope));
+            if (matchesKey(data, "backspace"))
+                return this.list.setQuery([...this.list.query].slice(0, -1).join(""));
+            const text = isPasteData(data) ? unwrapPaste(data) : isPrintableText(data) ? data : "";
+            if (text !== "")
+                this.list.setQuery(this.list.query + text.replace(/\s+/g, " "));
+            return;
+        }
+        if (data === "/") {
+            this.searching = true;
+            return;
+        }
+        if (row === undefined)
+            return;
+        if (matchesKey(data, "enter") || matchesKey(data, "space")) {
+            this.notice = undefined;
+            const hint = hintOf(row.id);
+            if (hint !== undefined)
+                return this.setNotice(hint);
+            return this.run(this.deps.activate(row.id, this.scope));
+        }
+        if (unsetKey && hintOf(row.id) === undefined) {
+            if (this.pendingUnset === row.id) {
+                this.pendingUnset = undefined;
+                return this.run(this.deps.unset(row.id, this.scope));
+            }
+            this.pendingUnset = row.id;
+            this.setNotice(msg().settings.confirmUnset(row.id), "warning");
+        }
+    }
+    move(delta) {
+        this.list.move(delta);
+        this.pendingUnset = undefined;
+        if (!this.searching)
+            this.notice = undefined;
+    }
+    /** Run a controller action; input is ignored until it settles. */
+    run(result) {
+        if (!(result instanceof Promise))
+            return;
+        this.busy = true;
+        void result.finally(() => {
+            this.busy = false;
+            this.deps.requestRender();
+        });
+    }
+    editInput(data) {
+        const edit = this.edit;
+        if (matchesKey(data, "escape") ||
+            (this.deps.keybindings ?? defaultKeybindings).matches(data, "app.clear")) {
+            this.edit = undefined;
+            return;
+        }
+        if (matchesKey(data, "enter")) {
+            this.busy = true;
+            void this.deps
+                .commit(edit.key, edit.text, this.scope)
+                .then((error) => {
+                if (error === undefined)
+                    this.edit = undefined;
+                else
+                    edit.error = error;
+            })
+                .finally(() => {
+                this.busy = false;
+                this.deps.requestRender();
+            });
+            return;
+        }
+        if (matchesKey(data, "backspace"))
+            edit.text = [...edit.text].slice(0, -1).join("");
+        else if (isPasteData(data))
+            edit.text += unwrapPaste(data).replace(/\s+/g, " ");
+        else if (isPrintableText(data))
+            edit.text += data;
+        else
+            return;
+        delete edit.error;
+    }
+    render(width) {
+        const { theme } = this.deps;
+        const s = msg().settings;
+        const rows = this.deps.rows?.();
+        const embedded = this.deps.embedded === true ? 1 : 0;
+        if (rows !== undefined)
+            this.list.maxVisible = rows - 1 - CHROME - embedded;
+        const subtitle = `${s.writeTo(s.scope[this.scope], this.deps.paths[this.scope])}  ${s.tabSwitch}`;
+        const card = new Card(new Lines((w) => this.body(w)), { theme, title: s.title, subtitle });
+        return card.render(width);
+    }
+    body(width) {
+        const { theme } = this.deps;
+        const s = msg().settings;
+        const out = [];
+        if (this.deps.embedded === true)
+            out.push(theme.fg("warning", s.embedded));
+        const query = this.list.query;
+        out.push(this.searching || query !== ""
+            ? `${s.searchPrompt(query)}${this.searching && this.edit === undefined ? theme.fg("accent", "_") : ""}`
+            : theme.fg("dim", s.searchPlaceholder));
+        out.push(...this.list.render(width));
+        out.push(theme.fg("border", theme.glyphs.rule.repeat(Math.max(1, width))));
+        out.push(...this.description(width));
+        if (this.edit !== undefined) {
+            const label = s.labels[this.edit.key] ?? this.edit.key;
+            const box = `${s.editPrompt(label)}${this.edit.text}${theme.fg("accent", "_")}`;
+            out.push(truncateToWidth(box, width));
+            if (this.edit.error !== undefined)
+                out.push(theme.fg("error", truncateToWidth(this.edit.error, width)));
+        }
+        else if (this.notice !== undefined) {
+            out.push(...wrapTextWithAnsi(theme.fg(this.notice.color, this.notice.text), width).slice(0, 2));
+        }
+        const footer = this.edit !== undefined
+            ? s.footerEdit
+            : this.searching
+                ? s.footerSearch
+                : width < 72
+                    ? s.footerCompact
+                    : s.footer;
+        out.push(theme.fg("dim", truncateToWidth(footer, width)));
+        return out;
+    }
+    description(width) {
+        const { theme } = this.deps;
+        const row = this.list.selectedRow;
+        if (row === undefined || hintOf(row.id) !== undefined)
+            return [];
+        const doc = settingDoc(row.id) ?? "";
+        const value = getConfigValue(this.snapshot, row.id);
+        const dynamic = value.value === undefined ? settingDynamicDefault(row.id) : undefined;
+        const text = dynamic === undefined ? doc : `${doc} · ${dynamic}`;
+        const spec = settingsRegistry().find((x) => x.key === row.id);
+        const blocked = spec === undefined ? undefined : blockedReason(spec, value, this.scope);
+        const lines = blocked === undefined ? [] : [theme.fg("warning", truncateToWidth(blocked, width))];
+        if (text !== "")
+            lines.push(...wrapTextWithAnsi(theme.fg("dim", text), width));
+        return lines.slice(0, 3);
+    }
+    invalidate() { }
+}

package/dist/modes/interactive/config-ui.d.ts

@@ -0,0 +1,96 @@
+/**
+ * `/config` controller (docs/wave6-plan.md §6.3, D24-D26). [W6-S]
+ *
+ * - `open("")` shows the panel (config-panel.ts); `open("key=value")` / `open("key value")` sets one key
+ *   in the user config without the panel (same path as `ama config set`).
+ * - Every change is written at once (config/edit.ts) and then applied: keys of the "now" tier go to the
+ *   running session / view (`applySetting`), and `runtime.replaceConfig()` hands the re-merged config to
+ *   `/new`. `defaultModel`, `thinkingLevel` and `permission.mode` also switch the current session.
+ * - `permission.mode: full-auto` in the user config always asks the Bypass confirmation first.
+ * - The first change of a cache-prefix key in a conversation that already has replies shows a notice once
+ *   per panel; closing the panel posts one summary (`from → to (scope)`, plus restart / new-session lists).
+ * - `configCommand()` is the line mode `/config` (`CommandContext.extra.config`).
+ */
+import type { AgentSession } from "../../agent/types.js";
+import type { ModeContext } from "../../cli/deps.js";
+import type { Runtime } from "../../cli/runtime.js";
+import { type ConfigLayerInput } from "../../config/edit.js";
+import type { StatusLineMode } from "../../config/types.js";
+import type { CommandContext, CommandResult } from "../commands-core.js";
+import type { NoticeLevel, ThinkingDisplay } from "./message-view.js";
+import { type PickerHost } from "./pickers.js";
+/** Where "now" settings land in the running UI (every target optional). */
+export interface ConfigApplyTargets {
+    session(): AgentSession;
+    view?: {
+        setOptions(options: {
+            showThinking?: ThinkingDisplay;
+            markdown?: boolean;
+            compact?: boolean;
+        }): void;
+    };
+    loader?: {
+        setAnimation(on: boolean): void;
+    };
+    area?: {
+        setLayout(mode: StatusLineMode): void;
+    };
+    redraw?(): void;
+}
+/** Apply one "now" key to the running session / view; returns false when nothing applies. */
+export declare function applySetting(key: string, value: unknown, targets: ConfigApplyTargets): Promise<boolean>;
+/** Layer inputs of this process: user / project files, the profile and the command line flags. */
+export declare function layerInputFor(runtime: Runtime, context: ModeContext): ConfigLayerInput;
+/** `key=value` / `key value` → [key, raw]. */
+export declare function splitAssignment(args: string): [string, string] | undefined;
+export interface ConfigUiDeps extends PickerHost, ConfigApplyTargets {
+    runtime: Runtime;
+    context: ModeContext;
+    rows(): number;
+    notice(level: NoticeLevel, text: string): void;
+    render(): void;
+    /** Home directory for ~ in paths. */
+    home?: string;
+}
+export declare class ConfigUi {
+    private readonly deps;
+    private panel;
+    private handle;
+    private changes;
+    private prefixNoticeShown;
+    constructor(deps: ConfigUiDeps);
+    private input;
+    /** `/config [key=value]`. */
+    open(args: string): Promise<void>;
+    private close;
+    /** Closing summary (undefined when nothing changed). */
+    summary(): string | undefined;
+    private activate;
+    private pick;
+    private commitText;
+    /**
+     * Write one key and apply it. Errors become panel notices (or are rethrown with `rethrow`, for the
+     * inline editor). Returns the edit result, undefined when refused / cancelled.
+     */
+    private write;
+    private afterWrite;
+    /** `/config key=value`: user scope, no panel. */
+    private direct;
+}
+/** Line mode `/config`: no args lists the settings, `key=value` sets one (user scope). */
+export declare function configCommand(runtime: Runtime, context: ModeContext): (args: string, ctx: CommandContext) => Promise<CommandResult>;
+/** Wiring for interactive-mode.ts (one line there): the session follows `/new` `/resume` `/fork`. */
+export declare function configUiFor(host: PickerHost & {
+    rows(): number;
+}, parts: {
+    runtime: Runtime;
+    context: ModeContext;
+    view: NonNullable<ConfigApplyTargets["view"]>;
+    loader: NonNullable<ConfigApplyTargets["loader"]>;
+    area: NonNullable<ConfigApplyTargets["area"]>;
+    tui: {
+        forceFullRedraw(): void;
+        requestRender(): void;
+    };
+    notice(level: NoticeLevel, text: string): void;
+}): ConfigUi;