my-pi-agent 0.1.0

package/tui/dist/components/session-selector.js

@@ -0,0 +1,393 @@
+import * as os from "node:os";
+import { Container, fuzzyMatch, Input, matchesKey, Spacer, Text, visibleWidth, } from "@earendil-works/pi-tui";
+import { theme } from "../theme/theme.js";
+import { DynamicBorder } from "./dynamic-border.js";
+import { isEnterKey } from "./keys.js";
+function normalizeKey(k) {
+    if (!k)
+        return "";
+    return k.replace(/\\/g, "/").toLowerCase();
+}
+export function buildSessionTree(sessions) {
+    const byKey = new Map();
+    for (const s of sessions) {
+        const node = {
+            session: s,
+            children: [],
+            latestActivity: s.modified * 1000,
+        };
+        byKey.set(s.id, node);
+        byKey.set(s.id.toLowerCase(), node);
+        if (s.path) {
+            byKey.set(s.path, node);
+            byKey.set(normalizeKey(s.path), node);
+            const filename = s.path.split(/[/\\]/).pop() || "";
+            const stem = filename.replace(/\.jsonl$/i, "");
+            if (stem) {
+                byKey.set(stem, node);
+                byKey.set(stem.toLowerCase(), node);
+            }
+        }
+    }
+    const roots = [];
+    for (const s of sessions) {
+        const node = byKey.get(s.id);
+        const pKey = s.parent_session || s.parent_session_path;
+        let parentNode;
+        if (pKey) {
+            const pFilename = pKey.split(/[/\\]/).pop() || "";
+            const pStem = pFilename.replace(/\.jsonl$/i, "");
+            parentNode =
+                byKey.get(pKey) ||
+                    byKey.get(normalizeKey(pKey)) ||
+                    byKey.get(pKey.toLowerCase()) ||
+                    (pStem
+                        ? byKey.get(pStem) || byKey.get(pStem.toLowerCase())
+                        : undefined);
+        }
+        if (parentNode && parentNode !== node) {
+            parentNode.children.push(node);
+        }
+        else {
+            roots.push(node);
+        }
+    }
+    const updateLatestActivity = (node) => {
+        let latest = node.latestActivity;
+        for (const child of node.children) {
+            latest = Math.max(latest, updateLatestActivity(child));
+        }
+        node.latestActivity = latest;
+        return latest;
+    };
+    for (const r of roots) {
+        updateLatestActivity(r);
+    }
+    const sortNodes = (nodes) => {
+        nodes.sort((a, b) => b.latestActivity - a.latestActivity);
+        for (const n of nodes) {
+            sortNodes(n.children);
+        }
+    };
+    sortNodes(roots);
+    return roots;
+}
+export function flattenSessionTree(roots) {
+    const result = [];
+    const walk = (node, depth, ancestorContinues, isLast) => {
+        result.push({ session: node.session, depth, isLast, ancestorContinues });
+        for (let i = 0; i < node.children.length; i++) {
+            const childIsLast = i === node.children.length - 1;
+            const continues = depth > 0 ? !isLast : false;
+            walk(node.children[i], depth + 1, [...ancestorContinues, continues], childIsLast);
+        }
+    };
+    for (let i = 0; i < roots.length; i++) {
+        walk(roots[i], 0, [], i === roots.length - 1);
+    }
+    return result;
+}
+export function buildTreePrefix(node) {
+    if (node.depth === 0) {
+        return "";
+    }
+    const parts = node.ancestorContinues.map((continues) => continues ? "│  " : "   ");
+    const branch = node.isLast ? "└─ " : "├─ ";
+    return parts.join("") + branch;
+}
+function shortenPath(p) {
+    const home = os.homedir();
+    if (!p)
+        return p;
+    if (p.startsWith(home)) {
+        return `~${p.slice(home.length)}`;
+    }
+    return p;
+}
+function formatSessionDate(timestampSec) {
+    const now = Date.now();
+    const diffMs = now - timestampSec * 1000;
+    const diffMins = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMs / 3600000);
+    const diffDays = Math.floor(diffMs / 86400000);
+    if (diffMins < 1)
+        return "now";
+    if (diffMins < 60)
+        return `${diffMins}m`;
+    if (diffHours < 24)
+        return `${diffHours}h`;
+    if (diffDays < 7)
+        return `${diffDays}d`;
+    if (diffDays < 30)
+        return `${Math.floor(diffDays / 7)}w`;
+    if (diffDays < 365)
+        return `${Math.floor(diffDays / 30)}mo`;
+    return `${Math.floor(diffDays / 365)}y`;
+}
+export class SessionSelectorComponent extends Container {
+    loadSessions;
+    onSelect;
+    onCancel;
+    requestRender;
+    activeSessionId;
+    onDelete;
+    searchInput;
+    allSessions = [];
+    filteredSessions = [];
+    displayNodes = [];
+    selectedIndex = 0;
+    maxVisible = 10;
+    scope = "current";
+    showPath = false;
+    confirmingDeleteId = null;
+    errorMessage = null;
+    errorTimeout = null;
+    _focused = false;
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+        this.searchInput.focused = value;
+    }
+    constructor(loadSessions, onSelect, onCancel, requestRender, activeSessionId, onDelete) {
+        super();
+        this.loadSessions = loadSessions;
+        this.onSelect = onSelect;
+        this.onCancel = onCancel;
+        this.requestRender = requestRender;
+        this.activeSessionId = activeSessionId;
+        this.onDelete = onDelete;
+        this.searchInput = new Input();
+        this.searchInput.onSubmit = () => {
+            const selected = this.displayNodes[this.selectedIndex]?.session;
+            if (selected)
+                this.onSelect(selected);
+        };
+        void this.reload();
+    }
+    async reload() {
+        try {
+            this.allSessions = await this.loadSessions(this.scope === "all");
+        }
+        catch {
+            this.allSessions = [];
+        }
+        this.applyFilter();
+        this.rebuildUI();
+        if (this.requestRender) {
+            this.requestRender();
+        }
+    }
+    applyFilter() {
+        const q = this.searchInput.getValue().trim().toLowerCase();
+        if (q) {
+            this.filteredSessions = this.allSessions.filter((s) => {
+                const text = `${s.id} ${s.name || ""} ${s.cwd || ""}`.toLowerCase();
+                return fuzzyMatch(q, text).matches || text.includes(q);
+            });
+            this.displayNodes = this.filteredSessions.map((s) => ({
+                session: s,
+                depth: 0,
+                isLast: false,
+                ancestorContinues: [],
+            }));
+        }
+        else {
+            this.filteredSessions = [...this.allSessions];
+            const roots = buildSessionTree(this.allSessions);
+            this.displayNodes = flattenSessionTree(roots);
+        }
+        this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.displayNodes.length - 1));
+    }
+    rebuildUI() {
+        this.clear();
+        this.addChild(new DynamicBorder());
+        this.addChild(new Spacer(1));
+        // Header Info
+        const scopeLabel = this.scope === "current"
+            ? "◉ Current Folder | ○ All"
+            : "○ Current Folder | ◉ All";
+        this.addChild(new Text(`${theme.bold("Resume Session")}               ${theme.fg("accent", scopeLabel)}`, 1, 0));
+        if (this.confirmingDeleteId !== null) {
+            this.addChild(new Text(theme.fg("error", "Delete session? Enter to confirm · Esc to cancel"), 1, 0));
+        }
+        else if (this.errorMessage === null) {
+            this.addChild(new Text(theme.fg("muted", "Tab: scope · Ctrl+D: delete · Ctrl+P: path · Enter: resume · Esc: cancel"), 1, 0));
+        }
+        else {
+            this.addChild(new Text(theme.fg("error", this.errorMessage), 1, 0));
+        }
+        this.addChild(new Spacer(1));
+        // Search Input
+        this.addChild(this.searchInput);
+        this.addChild(new Spacer(1));
+        // List rendering
+        if (this.displayNodes.length === 0) {
+            this.addChild(new Text(theme.fg("muted", "  未发现匹配的历史会话。"), 1, 0));
+        }
+        else {
+            const start = Math.max(0, Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.displayNodes.length - this.maxVisible));
+            const end = Math.min(start + this.maxVisible, this.displayNodes.length);
+            for (let i = start; i < end; i++) {
+                const node = this.displayNodes[i];
+                if (!node)
+                    continue;
+                const s = node.session;
+                const isSelected = i === this.selectedIndex;
+                const isCurrent = s.id === this.activeSessionId;
+                const isConfirming = s.id === this.confirmingDeleteId;
+                const deletePrefix = isConfirming
+                    ? theme.fg("error", "[delete?] ")
+                    : "";
+                const cursor = isSelected ? theme.fg("accent", "› ") : "  ";
+                const treePrefix = buildTreePrefix(node);
+                let titleText = s.name || s.id;
+                if (isConfirming) {
+                    titleText = theme.fg("error", titleText);
+                }
+                else if (isCurrent) {
+                    titleText = theme.fg("accent", titleText);
+                }
+                else if (s.name) {
+                    titleText = theme.fg("warning", titleText);
+                }
+                const msgInfo = `${s.message_count || 0}`;
+                const timeInfo = formatSessionDate(s.modified);
+                let meta = `${msgInfo} ${timeInfo}`;
+                if (this.scope === "all" && s.cwd) {
+                    meta = `${shortenPath(s.cwd)}  ${meta}`;
+                }
+                if (this.showPath && s.path) {
+                    meta = `${shortenPath(s.path)}  ${meta}`;
+                }
+                const left = cursor +
+                    deletePrefix +
+                    theme.fg("dim", treePrefix) +
+                    (isSelected ? theme.bold(titleText) : titleText);
+                const right = theme.fg(isConfirming ? "error" : "dim", meta);
+                const pad = Math.max(2, 75 - visibleWidth(left) - visibleWidth(right));
+                let rowStr = left + " ".repeat(pad) + right;
+                if (isSelected) {
+                    rowStr = theme.bg("selectedBg", rowStr);
+                }
+                this.addChild(new Text(rowStr, 1, 0));
+            }
+            if (this.displayNodes.length > this.maxVisible) {
+                this.addChild(new Text(theme.fg("muted", `  (${this.selectedIndex + 1}/${this.displayNodes.length})`), 1, 0));
+            }
+        }
+        this.addChild(new Spacer(1));
+        this.addChild(new DynamicBorder());
+    }
+    handleInput(data) {
+        // 处于删除二次确认拦截模式
+        if (this.confirmingDeleteId !== null) {
+            if (isEnterKey(data)) {
+                const toDelete = this.displayNodes.find((n) => n.session.id === this.confirmingDeleteId)?.session;
+                if (toDelete) {
+                    this.executeDelete(toDelete);
+                }
+                return;
+            }
+            if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+                this.confirmingDeleteId = null;
+                this.rebuildUI();
+                if (this.requestRender)
+                    this.requestRender();
+                return;
+            }
+            return;
+        }
+        if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+            this.onCancel();
+            return;
+        }
+        if (matchesKey(data, "ctrl+d")) {
+            const selected = this.displayNodes[this.selectedIndex]?.session;
+            if (selected) {
+                if (selected.id === this.activeSessionId) {
+                    this.setErrorMessage("Cannot delete the currently active session");
+                    return;
+                }
+                this.confirmingDeleteId = selected.id;
+                this.rebuildUI();
+                if (this.requestRender)
+                    this.requestRender();
+            }
+            return;
+        }
+        if (matchesKey(data, "tab")) {
+            this.scope = this.scope === "current" ? "all" : "current";
+            void this.reload();
+            return;
+        }
+        if (matchesKey(data, "ctrl+p")) {
+            this.showPath = !this.showPath;
+            this.rebuildUI();
+            if (this.requestRender)
+                this.requestRender();
+            return;
+        }
+        if (matchesKey(data, "up")) {
+            this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+            this.rebuildUI();
+            if (this.requestRender)
+                this.requestRender();
+            return;
+        }
+        if (matchesKey(data, "down")) {
+            this.selectedIndex = Math.min(this.displayNodes.length - 1, this.selectedIndex + 1);
+            this.rebuildUI();
+            if (this.requestRender)
+                this.requestRender();
+            return;
+        }
+        if (isEnterKey(data)) {
+            const selected = this.displayNodes[this.selectedIndex]?.session;
+            if (selected) {
+                this.onSelect(selected);
+                return;
+            }
+        }
+        const prevQuery = this.searchInput.getValue();
+        this.searchInput.handleInput?.(data);
+        if (this.searchInput.getValue() !== prevQuery) {
+            this.applyFilter();
+            this.rebuildUI();
+            if (this.requestRender)
+                this.requestRender();
+        }
+    }
+    setErrorMessage(msg) {
+        if (this.errorTimeout) {
+            clearTimeout(this.errorTimeout);
+        }
+        this.errorMessage = msg;
+        this.rebuildUI();
+        if (this.requestRender)
+            this.requestRender();
+        this.errorTimeout = setTimeout(() => {
+            this.errorMessage = null;
+            this.errorTimeout = null;
+            this.rebuildUI();
+            if (this.requestRender)
+                this.requestRender();
+        }, 2500);
+    }
+    executeDelete(session) {
+        this.confirmingDeleteId = null;
+        if (this.onDelete) {
+            void Promise.resolve(this.onDelete(session)).then(() => {
+                void this.reload();
+            });
+        }
+        else {
+            this.allSessions = this.allSessions.filter((s) => s.id !== session.id);
+            this.applyFilter();
+            this.rebuildUI();
+            if (this.requestRender)
+                this.requestRender();
+        }
+    }
+}

package/tui/dist/components/settings-selector.d.ts

@@ -0,0 +1,24 @@
+import { Container } from "@earendil-works/pi-tui";
+export interface SettingItemDef {
+    key: string;
+    label: string;
+    type: "boolean" | "cycle" | "string";
+    options?: string[];
+    description: string;
+}
+export declare class SettingsSelectorComponent extends Container {
+    readonly onChange: (key: string, value: unknown) => void;
+    readonly onClose: () => void;
+    readonly definitions: SettingItemDef[];
+    private listContainer;
+    private selectedIndex;
+    private currentSettings;
+    private lastWidth;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    constructor(initialSettings: Record<string, unknown>, onChange: (key: string, value: unknown) => void, onClose: () => void, definitions?: SettingItemDef[]);
+    render(width: number): string[];
+    updateList(): void;
+    handleInput(data: string): void;
+}

package/tui/dist/components/settings-selector.js

@@ -0,0 +1,146 @@
+import { Container, matchesKey, Spacer, Text, visibleWidth, } from "@earendil-works/pi-tui";
+import { theme } from "../theme/theme.js";
+import { DynamicBorder } from "./dynamic-border.js";
+import { isEnterKey } from "./keys.js";
+const SETTING_DEFINITIONS = [
+    {
+        key: "auto_compact",
+        label: "Auto Compaction",
+        type: "boolean",
+        description: "Automatically compact context when usage exceeds threshold",
+    },
+    {
+        key: "default_model",
+        label: "Default Model",
+        type: "string",
+        description: "Default LLM model identifier (switch with /model)",
+    },
+    {
+        key: "default_thinking_level",
+        label: "Thinking Level",
+        type: "cycle",
+        options: ["off", "minimal", "low", "medium", "high", "xhigh", "max"],
+        description: "Default reasoning thinking depth budget",
+    },
+    {
+        key: "default_permission_mode",
+        label: "Permission Mode",
+        type: "cycle",
+        options: ["review", "yolo", "strict"],
+        description: "Security permission mode for workspace mutations",
+    },
+    {
+        key: "theme",
+        label: "Theme",
+        type: "cycle",
+        options: ["dark", "light"],
+        description: "Active terminal color theme palette",
+    },
+];
+export class SettingsSelectorComponent extends Container {
+    onChange;
+    onClose;
+    definitions;
+    listContainer;
+    selectedIndex = 0;
+    currentSettings;
+    lastWidth = 80;
+    _focused = false;
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+    }
+    constructor(initialSettings, onChange, onClose, definitions = SETTING_DEFINITIONS) {
+        super();
+        this.onChange = onChange;
+        this.onClose = onClose;
+        this.definitions = definitions;
+        this.currentSettings = { ...initialSettings };
+        this.listContainer = new Container();
+        this.addChild(new DynamicBorder());
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(theme.bold("Settings"), 0, 0));
+        this.addChild(new Text(theme.fg("muted", "Enter: toggle / cycle value · Up/Down: navigate · Esc: close"), 0, 0));
+        this.addChild(new Spacer(1));
+        this.addChild(this.listContainer);
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(theme.fg("dim", "  Changes are saved to ~/.my-pi-agent/settings.json · Esc to close"), 0, 0));
+        this.addChild(new DynamicBorder());
+        this.updateList();
+    }
+    render(width) {
+        this.lastWidth = width;
+        return super.render(width);
+    }
+    updateList() {
+        this.listContainer.clear();
+        for (let i = 0; i < this.definitions.length; i++) {
+            const def = this.definitions[i];
+            const isSelected = i === this.selectedIndex;
+            const val = this.currentSettings[def.key];
+            let valueDisplay = "";
+            if (def.type === "boolean") {
+                valueDisplay = val
+                    ? theme.fg("success", "[x]")
+                    : theme.fg("muted", "[ ]");
+            }
+            else {
+                valueDisplay = theme.fg("accent", String(val ?? "not set"));
+            }
+            const cursor = isSelected ? theme.fg("accent", "› ") : "  ";
+            const label = isSelected ? theme.bold(def.label) : def.label;
+            const left = `${cursor}${label}`;
+            const right = `${valueDisplay}  ${theme.fg("dim", `(${def.description})`)}`;
+            const pad = Math.max(2, this.lastWidth - 4 - visibleWidth(left) - visibleWidth(right));
+            let lineText = left + " ".repeat(pad) + right;
+            if (isSelected) {
+                lineText = theme.bg("selectedBg", lineText);
+            }
+            this.listContainer.addChild(new Text(lineText, 0, 0));
+        }
+    }
+    handleInput(data) {
+        if (matchesKey(data, "up")) {
+            this.selectedIndex =
+                this.selectedIndex === 0
+                    ? this.definitions.length - 1
+                    : this.selectedIndex - 1;
+            this.updateList();
+        }
+        else if (matchesKey(data, "down")) {
+            this.selectedIndex =
+                this.selectedIndex === this.definitions.length - 1
+                    ? 0
+                    : this.selectedIndex + 1;
+            this.updateList();
+        }
+        else if (isEnterKey(data) || matchesKey(data, "space")) {
+            const def = this.definitions[this.selectedIndex];
+            if (!def)
+                return;
+            let nextVal;
+            if (def.type === "boolean") {
+                nextVal = !this.currentSettings[def.key];
+            }
+            else if (def.type === "cycle" &&
+                def.options &&
+                def.options.length > 0) {
+                const cur = String(this.currentSettings[def.key] ?? def.options[0]);
+                const curIdx = def.options.indexOf(cur);
+                const nextIdx = (curIdx + 1) % def.options.length;
+                nextVal = def.options[nextIdx];
+            }
+            else {
+                return;
+            }
+            this.currentSettings[def.key] = nextVal;
+            this.onChange(def.key, nextVal);
+            this.updateList();
+        }
+        else if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+            this.onClose();
+        }
+    }
+}

package/tui/dist/components/status-indicator.d.ts

@@ -0,0 +1,25 @@
+import { Loader } from "@earendil-works/pi-tui";
+/**
+ * 基础状态指示器（100% 对标 Pi 原厂 StatusIndicator）：继承 Loader 带有 80ms 动态旋转帧
+ */
+export declare class StatusIndicator extends Loader {
+    kind: string;
+    constructor(kind: string, ui: any, spinnerColorFn: (spinner: string) => string, messageColorFn: (msg: string) => string, message: string, indicator?: any);
+    start(): void;
+    renderInBorder(width: number): string;
+    renderSpinnerInBorder(width: number): string;
+    dispose(): void;
+}
+/**
+ * 运行中状态指示器（100% 对标 Pi 原厂 WorkingStatusIndicator）：
+ * 可直接嵌入 CustomEditor 顶部边框，展示转圈动效：── ⠸ Working ───────────
+ */
+export declare class WorkingStatusIndicator extends StatusIndicator {
+    constructor(ui: any, message?: string, indicator?: any, colorFn?: (text: string) => string);
+}
+/**
+ * 上下文压缩状态指示器（对标 Pi 原厂 CompactionStatusIndicator）
+ */
+export declare class CompactionStatusIndicator extends StatusIndicator {
+    constructor(ui: any, reason?: "manual" | "overflow");
+}

package/tui/dist/components/status-indicator.js

@@ -0,0 +1,60 @@
+import { Loader, truncateToWidth } from "@earendil-works/pi-tui";
+import { theme } from "../theme/theme.js";
+/**
+ * 基础状态指示器（100% 对标 Pi 原厂 StatusIndicator）：继承 Loader 带有 80ms 动态旋转帧
+ */
+export class StatusIndicator extends Loader {
+    kind;
+    constructor(kind, ui, spinnerColorFn, messageColorFn, message, indicator) {
+        super(ui, spinnerColorFn, messageColorFn, message, indicator);
+        this.kind = kind;
+        // unref 内部定时器，防止挂死 Node 进程或测试退出
+        const timer = this.intervalId;
+        if (timer && typeof timer.unref === "function") {
+            timer.unref();
+        }
+    }
+    start() {
+        super.start();
+        const timer = this.intervalId;
+        if (timer && typeof timer.unref === "function") {
+            timer.unref();
+        }
+    }
+    renderInBorder(width) {
+        const lines = super.render(width + 2);
+        const line = lines[1] ?? lines[0] ?? "";
+        const clean = line.startsWith(" ")
+            ? line.slice(1).trimEnd()
+            : line.trimEnd();
+        return truncateToWidth(clean, width, "");
+    }
+    renderSpinnerInBorder(width) {
+        const ind = this.getRenderedIndicator?.() ?? "⠋";
+        return truncateToWidth(ind, width, "");
+    }
+    dispose() {
+        this.stop();
+    }
+}
+/**
+ * 运行中状态指示器（100% 对标 Pi 原厂 WorkingStatusIndicator）：
+ * 可直接嵌入 CustomEditor 顶部边框，展示转圈动效：── ⠸ Working ───────────
+ */
+export class WorkingStatusIndicator extends StatusIndicator {
+    constructor(ui, message = "Working", indicator, colorFn) {
+        super("working", ui, colorFn ?? ((text) => theme.fg("accent", text)), colorFn ?? ((text) => theme.fg("muted", text)), message, indicator);
+    }
+}
+/**
+ * 上下文压缩状态指示器（对标 Pi 原厂 CompactionStatusIndicator）
+ */
+export class CompactionStatusIndicator extends StatusIndicator {
+    constructor(ui, reason = "manual") {
+        const cancelHint = "(Esc to cancel)";
+        const label = reason === "manual"
+            ? `Compacting context... ${cancelHint}`
+            : "Context overflow, auto-compacting... (Esc to cancel)";
+        super("compaction", ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), label);
+    }
+}

package/tui/dist/components/theme-selector.d.ts

@@ -0,0 +1,14 @@
+import { Container, SelectList } from "@earendil-works/pi-tui";
+export declare class ThemeSelectorComponent extends Container {
+    readonly currentTheme: string;
+    readonly availableThemes: string[];
+    readonly onSelect: (themeName: string) => void;
+    readonly onCancel: () => void;
+    readonly onPreview?: ((themeName: string) => void) | undefined;
+    selectList: SelectList;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    constructor(currentTheme: string, availableThemes: string[] | undefined, onSelect: (themeName: string) => void, onCancel: () => void, onPreview?: ((themeName: string) => void) | undefined);
+    handleInput(data: string): void;
+}