my-pi-agent 0.1.0

package/tui/dist/bridge/kernel-bridge.js

@@ -0,0 +1,132 @@
+import { EventTranslator, } from "./event-translator.js";
+/**
+ * KernelBridge acts as a lightweight Session Adapter between the presentation
+ * layer and the PythonKernelClient.
+ */
+// Export bridge
+export class KernelBridge {
+    client;
+    translator;
+    constructor(client, translator) {
+        this.client = client;
+        this.translator = translator ?? new EventTranslator();
+    }
+    async call(method, params = {}) {
+        if (typeof this.client.request === "function") {
+            return (await this.client.request(method, params));
+        }
+        if (typeof this.client.sendRequest === "function") {
+            return (await this.client.sendRequest(method, params));
+        }
+        throw new Error("KernelBridge: Provided client must implement request() or sendRequest().");
+    }
+    async prompt(text, options) {
+        if (typeof this.client.prompt === "function") {
+            return this.client.prompt(text, options);
+        }
+        const params = {
+            text,
+            ...(options || {}),
+        };
+        return this.call("prompt", params);
+    }
+    async abort() {
+        if (typeof this.client.abort === "function") {
+            return this.client.abort();
+        }
+        return this.call("abort", {});
+    }
+    async steer(text) {
+        if (typeof this.client.steer === "function") {
+            return this.client.steer(text);
+        }
+        return this.call("steer", { message: text });
+    }
+    async followUp(text) {
+        if (typeof this.client.followup === "function") {
+            return this.client.followup(text);
+        }
+        if (typeof this.client.followUp === "function") {
+            return this.client.followUp(text);
+        }
+        return this.call("followup", { message: text });
+    }
+    async listModels(options = {}) {
+        return this.call("models_list", options);
+    }
+    async switchModel(model, provider) {
+        const params = { model };
+        if (provider !== undefined) {
+            params.provider = provider;
+        }
+        return this.call("model_switch", params);
+    }
+    async listSessions(options = {}) {
+        return this.call("session_list", options);
+    }
+    async resumeSession(sessionId) {
+        return this.call("session_resume", {
+            session_id: sessionId,
+        });
+    }
+    async deleteSession(sessionId) {
+        return this.call("session_delete", {
+            session_id: sessionId,
+        });
+    }
+    async getSessionHistory() {
+        return this.call("session_history", {});
+    }
+    async newSession(options) {
+        return this.call("session_new", options || {});
+    }
+    async getTree() {
+        return this.call("session_tree", {});
+    }
+    async getSessionStats() {
+        return this.call("session_stats", {});
+    }
+    async branchSession(nodeId) {
+        return this.call("session_branch", {
+            target_id: nodeId,
+            node_id: nodeId,
+        });
+    }
+    async setThinking(level) {
+        return this.call("thinking_set", { level });
+    }
+    async login(provider, key) {
+        return this.call("login", { provider, key });
+    }
+    async logout(provider) {
+        return this.call("auth_logout", { provider });
+    }
+    async getSettings() {
+        return this.call("settings_get", {});
+    }
+    async setSetting(key, value) {
+        return this.call("settings_set", { key, value });
+    }
+    subscribe(listener) {
+        const handler = (rawEvent) => {
+            const translated = this.translator.translate(rawEvent);
+            if (translated !== null && translated !== undefined) {
+                listener(translated);
+            }
+        };
+        if (typeof this.client.on === "function") {
+            this.client.on("event", handler);
+            this.client.on("notification", handler);
+        }
+        return () => {
+            if (typeof this.client.off === "function") {
+                this.client.off("event", handler);
+                this.client.off("notification", handler);
+            }
+            else if (typeof this.client.removeListener === "function") {
+                this.client.removeListener("event", handler);
+                this.client.removeListener("notification", handler);
+            }
+        };
+    }
+}

package/tui/dist/client.d.ts

@@ -0,0 +1,63 @@
+import { EventEmitter } from "node:events";
+import { AgentEvent } from "./protocol.js";
+export interface SessionMessage {
+    role: string;
+    content: string;
+    metadata?: {
+        tool_calls?: Array<{
+            id: string;
+            name?: string;
+            args?: Record<string, unknown>;
+            function?: {
+                name: string;
+                arguments: string | Record<string, unknown>;
+            };
+            [key: string]: unknown;
+        }>;
+        tool_call_id?: string;
+        is_error?: boolean;
+        tool_name?: string;
+        thinking?: string;
+        reasoning_content?: string;
+        [key: string]: unknown;
+    };
+}
+export interface InitializeResult {
+    status: string;
+    workspace: string;
+    model: string;
+    session_id?: string;
+    session_file?: string;
+    session_name?: string;
+    messages?: SessionMessage[];
+}
+export interface PythonKernelClientOptions {
+    workspace?: string;
+    model?: string;
+    mode?: string;
+    pythonExecutable?: string;
+    continueSession?: boolean;
+    resume?: string | boolean;
+    sessionName?: string;
+    thinking?: string;
+    noSession?: boolean;
+    newSession?: boolean;
+}
+export declare class PythonKernelClient extends EventEmitter {
+    readonly options: PythonKernelClientOptions;
+    private child;
+    private nextId;
+    private pendingRequests;
+    private activeEventCallback;
+    private rl;
+    constructor(options?: PythonKernelClientOptions);
+    start(): Promise<InitializeResult>;
+    private resolvePythonCommand;
+    private handleLine;
+    sendRequest<T = unknown>(method: string, params?: Record<string, unknown>): Promise<T>;
+    prompt(text: string, onEventOrOptions?: ((event: AgentEvent) => void) | Record<string, unknown>): Promise<void>;
+    steer(message: string): Promise<void>;
+    followup(message: string): Promise<void>;
+    abort(): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/tui/dist/client.js

@@ -0,0 +1,239 @@
+import { spawn, spawnSync } from "node:child_process";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as readline from "node:readline";
+import { EventEmitter } from "node:events";
+export class PythonKernelClient extends EventEmitter {
+    options;
+    child = null;
+    nextId = 1;
+    pendingRequests = new Map();
+    activeEventCallback = null;
+    rl = null;
+    constructor(options = {}) {
+        super();
+        this.options = options;
+    }
+    async start() {
+        if (this.child) {
+            return {
+                status: "ok",
+                workspace: this.options.workspace || process.cwd(),
+                model: this.options.model || "default",
+            };
+        }
+        const workspace = this.options.workspace || process.cwd();
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const repoRoot = path.resolve(__dirname, "../..");
+        const { cmd, args } = this.resolvePythonCommand(workspace, repoRoot);
+        const pythonPath = path.join(repoRoot, "src") +
+            (process.env.PYTHONPATH ? path.delimiter + process.env.PYTHONPATH : "");
+        this.child = spawn(cmd, args, {
+            stdio: ["pipe", "pipe", "inherit"],
+            cwd: repoRoot,
+            windowsHide: true,
+            env: {
+                ...process.env,
+                PYTHONPATH: pythonPath,
+                PYTHONIOENCODING: "utf-8",
+                PYTHONUTF8: "1",
+            },
+        });
+        if (!this.child.stdout || !this.child.stdin) {
+            throw new Error("Failed to initialize stdin/stdout pipes for Python kernel.");
+        }
+        this.child.stdin.on("error", (err) => {
+            this.emit("error", err);
+        });
+        this.rl = readline.createInterface({
+            input: this.child.stdout,
+            terminal: false,
+        });
+        this.rl.on("line", (line) => {
+            this.handleLine(line);
+        });
+        this.child.on("exit", (code, signal) => {
+            this.child = null;
+            this.emit("exit", { code, signal });
+            for (const { reject } of this.pendingRequests.values()) {
+                reject(new Error(`Python kernel terminated prematurely with code ${code}, signal ${signal}`));
+            }
+            this.pendingRequests.clear();
+        });
+        this.child.on("error", (err) => {
+            this.emit("error", err);
+            for (const { reject } of this.pendingRequests.values()) {
+                reject(new Error(`无法启动 Python 内核 (${cmd}): ${err.message}。\n` +
+                    `my-pi-agent 采用双核驱动体系（Node.js TUI + Python 异步内核）。\n` +
+                    `请安装推荐的 Python 极速环境管理工具 uv（安装后全自动自愈配置）：\n` +
+                    `  macOS / Linux: curl -LsSf https://astral.sh/uv/install.sh | sh\n` +
+                    `  Windows: powershell -c "irm https://astral.sh/uv/install.ps1 | iex"\n` +
+                    `安装 uv 后重新运行 my-pi-agent 即可自动运行！`));
+            }
+            this.pendingRequests.clear();
+        });
+        // 初始化内核
+        const res = (await this.sendRequest("initialize", {
+            workspace,
+            model: this.options.model,
+            mode: this.options.mode || "review",
+            continue_session: this.options.continueSession,
+            resume: this.options.resume,
+            name: this.options.sessionName,
+            thinking: this.options.thinking,
+            no_session: this.options.noSession,
+            new_session: this.options.newSession,
+        }));
+        return res;
+    }
+    resolvePythonCommand(workspace, repoRoot) {
+        const rpcArgs = ["-m", "my_coding_agent.rpc_server", "-w", workspace];
+        if (this.options.model) {
+            rpcArgs.push("-m", this.options.model);
+        }
+        // 1. 优先使用外部显式传入的 Python 解释器
+        if (this.options.pythonExecutable) {
+            return { cmd: this.options.pythonExecutable, args: rpcArgs };
+        }
+        // 2. 探测系统 uv 极速包管理器（指定 --project 锚定包根目录，支持全局任意路径启动）
+        try {
+            const probeUv = spawnSync("uv", ["--version"], { stdio: "ignore" });
+            if (probeUv.status === 0) {
+                return {
+                    cmd: "uv",
+                    args: ["run", "--project", repoRoot, "python", ...rpcArgs],
+                };
+            }
+        }
+        catch {
+            // uv 未安装
+        }
+        // 3. 探测系统 python3
+        try {
+            const probePy3 = spawnSync("python3", ["--version"], { stdio: "ignore" });
+            if (probePy3.status === 0) {
+                return { cmd: "python3", args: rpcArgs };
+            }
+        }
+        catch {
+            // python3 未安装
+        }
+        // 4. 探测系统 python
+        try {
+            const probePy = spawnSync("python", ["--version"], { stdio: "ignore" });
+            if (probePy.status === 0) {
+                return { cmd: "python", args: rpcArgs };
+            }
+        }
+        catch {
+            // python 未安装
+        }
+        // 5. 兜底回退为 uv，并将在子进程启动失败时触发友好报错
+        return { cmd: "uv", args: ["run", "python", ...rpcArgs] };
+    }
+    handleLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return;
+        }
+        try {
+            const msg = JSON.parse(trimmed);
+            if ("id" in msg &&
+                (msg.result !== undefined || msg.error !== undefined)) {
+                // RPC Response
+                const res = msg;
+                const pending = this.pendingRequests.get(res.id);
+                if (pending) {
+                    this.pendingRequests.delete(res.id);
+                    if (res.error) {
+                        pending.reject(new Error(res.error.message));
+                    }
+                    else {
+                        pending.resolve(res.result);
+                    }
+                }
+            }
+            else if (msg.method === "event") {
+                // RPC Event Notification
+                const notif = msg;
+                // SAFETY: notif.params is serialized by Python rpc_server.serialize_event to conform to AgentEvent schema
+                const event = notif.params;
+                this.emit("event", event);
+                if (this.activeEventCallback) {
+                    this.activeEventCallback(event);
+                }
+            }
+        }
+        catch {
+            // 忽略无法解析的格式
+        }
+    }
+    async sendRequest(method, params) {
+        if (!this.child || !this.child.stdin) {
+            throw new Error("Python kernel is not running.");
+        }
+        const id = this.nextId++;
+        const req = {
+            jsonrpc: "2.0",
+            id,
+            method,
+            params,
+        };
+        return new Promise((resolve, reject) => {
+            this.pendingRequests.set(id, {
+                resolve: (val) => resolve(val),
+                reject,
+            });
+            this.child.stdin.write(JSON.stringify(req) + "\n");
+        });
+    }
+    async prompt(text, onEventOrOptions) {
+        if (typeof onEventOrOptions === "function") {
+            this.activeEventCallback = onEventOrOptions;
+        }
+        else {
+            this.activeEventCallback = null;
+        }
+        const params = { text };
+        if (onEventOrOptions &&
+            typeof onEventOrOptions === "object" &&
+            typeof onEventOrOptions !== "function") {
+            Object.assign(params, onEventOrOptions);
+        }
+        try {
+            await this.sendRequest("prompt", params);
+        }
+        finally {
+            this.activeEventCallback = null;
+        }
+    }
+    async steer(message) {
+        await this.sendRequest("steer", { message });
+    }
+    async followup(message) {
+        await this.sendRequest("followup", { message });
+    }
+    async abort() {
+        await this.sendRequest("abort");
+    }
+    async shutdown() {
+        try {
+            if (this.child && this.child.stdin) {
+                await this.sendRequest("shutdown");
+            }
+        }
+        catch {
+            // 忽略关闭时的异常
+        }
+        finally {
+            if (this.child) {
+                this.child.kill();
+                this.child = null;
+            }
+            if (this.rl) {
+                this.rl.close();
+                this.rl = null;
+            }
+        }
+    }
+}

package/tui/dist/components/assistant-message.d.ts

@@ -0,0 +1,19 @@
+import { Container } from "@earendil-works/pi-tui";
+export declare class AssistantMessageComponent extends Container {
+    private thinkingContainer;
+    private contentContainer;
+    private thinkingText;
+    private contentText;
+    private isThinkingExpanded;
+    private isFinalized;
+    constructor();
+    appendReasoningDelta(delta: string): void;
+    setReasoning(fullThinking: string): void;
+    appendTextDelta(delta: string): void;
+    setContent(fullContent: string): void;
+    getContentText(): string;
+    toggleThinking(): void;
+    finalize(): void;
+    private updateThinkingDisplay;
+    private updateContentDisplay;
+}

package/tui/dist/components/assistant-message.js

@@ -0,0 +1,90 @@
+import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
+import { getMarkdownTheme, theme } from "../theme/theme.js";
+export class AssistantMessageComponent extends Container {
+    thinkingContainer;
+    contentContainer;
+    thinkingText = "";
+    contentText = "";
+    isThinkingExpanded = true;
+    isFinalized = false;
+    constructor() {
+        super();
+        this.thinkingContainer = new Container();
+        this.contentContainer = new Container();
+        this.addChild(this.thinkingContainer);
+        this.addChild(this.contentContainer);
+    }
+    appendReasoningDelta(delta) {
+        this.thinkingText += delta;
+        this.updateThinkingDisplay();
+    }
+    setReasoning(fullThinking) {
+        if (this.thinkingText !== fullThinking) {
+            this.thinkingText = fullThinking;
+            this.updateThinkingDisplay();
+        }
+    }
+    appendTextDelta(delta) {
+        if (!this.isFinalized && this.thinkingText && this.isThinkingExpanded) {
+            // 当正文开始输出时，将思考区块默认折叠以保持界面清爽整洁
+            this.isThinkingExpanded = false;
+            this.updateThinkingDisplay();
+        }
+        this.contentText += delta;
+        this.updateContentDisplay();
+    }
+    setContent(fullContent) {
+        if (!this.isFinalized && this.thinkingText && this.isThinkingExpanded) {
+            this.isThinkingExpanded = false;
+            this.updateThinkingDisplay();
+        }
+        if (this.contentText !== fullContent) {
+            this.contentText = fullContent;
+            this.updateContentDisplay();
+        }
+    }
+    getContentText() {
+        return this.contentText;
+    }
+    toggleThinking() {
+        this.isThinkingExpanded = !this.isThinkingExpanded;
+        this.updateThinkingDisplay();
+    }
+    finalize() {
+        this.isFinalized = true;
+        if (this.thinkingText) {
+            this.isThinkingExpanded = false;
+            this.updateThinkingDisplay();
+        }
+        this.updateContentDisplay();
+    }
+    updateThinkingDisplay() {
+        this.thinkingContainer.clear();
+        if (!this.thinkingText.trim()) {
+            return;
+        }
+        if (this.isThinkingExpanded) {
+            const label = new Text(theme.bold(theme.fg("thinkingText", "\u25c8 思考过程 (按 Ctrl+O 折叠):")), 1, 0);
+            const md = new Markdown(this.thinkingText.trim(), 1, 0, getMarkdownTheme(), {
+                color: (t) => theme.fg("thinkingText", t),
+                italic: true,
+            });
+            this.thinkingContainer.addChild(label);
+            this.thinkingContainer.addChild(md);
+            this.thinkingContainer.addChild(new Spacer(1));
+        }
+        else {
+            const summary = new Text(theme.italic(theme.fg("thinkingText", `\u25c8 思考过程 (${this.thinkingText.trim().length} 字符，按 Ctrl+O 展开)`)), 1, 0);
+            this.thinkingContainer.addChild(summary);
+            this.thinkingContainer.addChild(new Spacer(1));
+        }
+    }
+    updateContentDisplay() {
+        this.contentContainer.clear();
+        if (!this.contentText.trim()) {
+            return;
+        }
+        const md = new Markdown(this.contentText.trim(), 1, 0, getMarkdownTheme());
+        this.contentContainer.addChild(md);
+    }
+}

package/tui/dist/components/compaction-summary-message.d.ts

@@ -0,0 +1,19 @@
+import { Box } from "@earendil-works/pi-tui";
+export interface CompactionSummaryData {
+    summary: string;
+    tokensBefore: number;
+}
+/**
+ * 渲染上下文压缩（Compaction）折叠卡片（100% 对标 Pi 原厂 CompactionSummaryMessageComponent）。
+ * 默认折叠展示：[compaction] Compacted from X tokens (Ctrl+O to expand)
+ * 按 Ctrl+O 展开时渲染完整的 Markdown 结构化摘要。
+ */
+export declare class CompactionSummaryMessageComponent extends Box {
+    private expanded;
+    private message;
+    constructor(message: CompactionSummaryData);
+    setExpanded(expanded: boolean): void;
+    toggleExpanded(): void;
+    invalidate(): void;
+    private updateDisplay;
+}

package/tui/dist/components/compaction-summary-message.js

@@ -0,0 +1,46 @@
+import { Box, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
+import { getMarkdownTheme, theme } from "../theme/theme.js";
+/**
+ * 渲染上下文压缩（Compaction）折叠卡片（100% 对标 Pi 原厂 CompactionSummaryMessageComponent）。
+ * 默认折叠展示：[compaction] Compacted from X tokens (Ctrl+O to expand)
+ * 按 Ctrl+O 展开时渲染完整的 Markdown 结构化摘要。
+ */
+export class CompactionSummaryMessageComponent extends Box {
+    expanded = false;
+    message;
+    constructor(message) {
+        super(1, 1, (t) => theme.bg("customMessageBg", t));
+        this.message = message;
+        this.updateDisplay();
+    }
+    setExpanded(expanded) {
+        this.expanded = expanded;
+        this.updateDisplay();
+    }
+    toggleExpanded() {
+        this.expanded = !this.expanded;
+        this.updateDisplay();
+    }
+    invalidate() {
+        super.invalidate();
+        this.updateDisplay();
+    }
+    updateDisplay() {
+        this.clear();
+        const tokenStr = (this.message.tokensBefore ?? 0).toLocaleString();
+        const label = theme.fg("customMessageLabel", "\x1b[1m[compaction]\x1b[22m");
+        this.addChild(new Text(label, 0, 0));
+        this.addChild(new Spacer(1));
+        if (this.expanded) {
+            const header = `**Compacted from ${tokenStr} tokens**\n\n`;
+            this.addChild(new Markdown(header + this.message.summary, 0, 0, getMarkdownTheme(), {
+                color: (text) => theme.fg("customMessageText", text),
+            }));
+        }
+        else {
+            this.addChild(new Text(theme.fg("customMessageText", `Compacted from ${tokenStr} tokens (`) +
+                theme.fg("dim", "Ctrl+O") +
+                theme.fg("customMessageText", " to expand)"), 0, 0));
+        }
+    }
+}

package/tui/dist/components/custom-editor.d.ts

@@ -0,0 +1,18 @@
+import { Editor } from "@earendil-works/pi-tui";
+import { type StatusIndicator } from "./status-indicator.js";
+export interface CustomEditorOptions {
+    embedWorkingStatus?: boolean;
+    paddingX?: number;
+    autocompleteMaxVisible?: number;
+}
+/**
+ * 扩展版 Editor（100% 对标 Pi 原厂 CustomEditor）：
+ * 支持在输入框顶部边框实时嵌入转圈动效：── ⠸ Working ─────────────────────────
+ */
+export declare class CustomEditor extends Editor {
+    embedWorkingStatus: boolean;
+    private workingStatusIndicator?;
+    constructor(tui: any, theme: any, options?: CustomEditorOptions);
+    setWorkingStatusIndicator(indicator?: StatusIndicator): void;
+    renderTopBorder(width: number, hiddenLineCount: number): string;
+}

package/tui/dist/components/custom-editor.js

@@ -0,0 +1,56 @@
+import { Editor, visibleWidth } from "@earendil-works/pi-tui";
+/**
+ * 扩展版 Editor（100% 对标 Pi 原厂 CustomEditor）：
+ * 支持在输入框顶部边框实时嵌入转圈动效：── ⠸ Working ─────────────────────────
+ */
+export class CustomEditor extends Editor {
+    embedWorkingStatus;
+    workingStatusIndicator;
+    constructor(tui, theme, options) {
+        super(tui, theme, options);
+        this.embedWorkingStatus = options?.embedWorkingStatus ?? true;
+    }
+    setWorkingStatusIndicator(indicator) {
+        this.workingStatusIndicator = indicator;
+        this.tui.requestRender();
+    }
+    renderTopBorder(width, hiddenLineCount) {
+        if (!this.embedWorkingStatus ||
+            !this.workingStatusIndicator ||
+            width <= 0) {
+            return super.renderTopBorder(width, hiddenLineCount);
+        }
+        let status = this.workingStatusIndicator.renderInBorder(Math.max(1, width - 5));
+        let statusWidth = visibleWidth(status);
+        if (statusWidth === 0) {
+            return super.renderTopBorder(width, hiddenLineCount);
+        }
+        const overflowLabel = hiddenLineCount > 0 ? ` ↑ ${hiddenLineCount} more ` : undefined;
+        const overflowLabelWidth = overflowLabel ? visibleWidth(overflowLabel) : 0;
+        const overflowStart = Math.floor((width - overflowLabelWidth) / 2);
+        const canFitOverflow = () => overflowLabel !== undefined &&
+            overflowLabelWidth + 2 <= width &&
+            overflowStart - (3 + statusWidth + 1) >= 1;
+        if (overflowLabel && !canFitOverflow()) {
+            status = this.workingStatusIndicator.renderSpinnerInBorder(width);
+            statusWidth = visibleWidth(status);
+        }
+        if (canFitOverflow()) {
+            const leftBlockWidth = 3 + statusWidth + 1;
+            return (this.borderColor("── ") +
+                status +
+                this.borderColor(` ${"─".repeat(overflowStart - leftBlockWidth)}${overflowLabel}${"─".repeat(Math.max(0, width - overflowStart - overflowLabelWidth))}`));
+        }
+        if (width >= statusWidth + 5) {
+            return (this.borderColor("── ") +
+                status +
+                this.borderColor(` ${"─".repeat(Math.max(0, width - statusWidth - 4))}`));
+        }
+        status = this.workingStatusIndicator.renderSpinnerInBorder(width);
+        statusWidth = visibleWidth(status);
+        const prefixWidth = Math.min(3, Math.max(0, width - statusWidth));
+        return (this.borderColor("─".repeat(prefixWidth)) +
+            status +
+            this.borderColor("─".repeat(Math.max(0, width - prefixWidth - statusWidth))));
+    }
+}