my-pi-agent 0.1.0

package/tui/bin/my-agent.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+import { AgentApp } from "../dist/app.js";
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {
+    workspace: process.env.INIT_CWD || process.cwd(),
+    model: undefined,
+    mode: "review",
+    continueSession: false,
+    resume: undefined,
+    sessionName: undefined,
+    thinking: undefined,
+    noSession: false,
+    newSession: false,
+    prompt: undefined,
+    pythonExecutable: undefined,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-w" || arg === "--workspace") {
+      options.workspace = args[++i];
+    } else if (arg === "--python-executable") {
+      options.pythonExecutable = args[++i];
+    } else if (arg === "-m" || arg === "--model") {
+      options.model = args[++i];
+    } else if (arg === "--mode") {
+      options.mode = args[++i];
+    } else if (arg === "-c" || arg === "--continue") {
+      options.continueSession = true;
+    } else if (arg === "-r" || arg === "--resume") {
+      const next = args[i + 1];
+      if (next && !next.startsWith("-")) {
+        options.resume = args[++i];
+      } else {
+        options.resume = true;
+      }
+    } else if (arg === "-n" || arg === "--name") {
+      options.sessionName = args[++i];
+    } else if (arg === "--thinking") {
+      options.thinking = args[++i];
+    } else if (arg === "--no-session") {
+      options.noSession = true;
+    } else if (arg === "--new-session") {
+      options.newSession = true;
+    } else if (arg === "-h" || arg === "--help") {
+      console.log(`
+my-agent: High-fidelity Pi-TUI terminal shell for my-pi-agent
+
+Usage:
+  my-agent [options] [prompt]
+
+Options:
+  -c, --continue          一键续接当前项目最近一次历史会话
+  -r, --resume [id]       启动时直接打开交互式会话选择器或恢复指定会话
+  --new-session           强制开启全新会话 (默认)
+  -n, --name <title>      启动时直接为该会话命名
+  -m, --model <model>     指定生效模型 (如 deepseek-chat, gemini-3.8-flash)
+  --thinking <level>      指定思考深度等级 (off/minimal/low/medium/high/max)
+  --no-session            内存无痕沙箱模式 (不持久化 session 文件)
+  -w, --workspace <dir>   指定工作区目录 (默认: 当前目录)
+  --mode <mode>           权限安全模式: review (默认) | yolo | strict
+  -h, --help              查看帮助说明
+`);
+      process.exit(0);
+    } else if (!arg.startsWith("-") && !options.prompt) {
+      options.prompt = arg;
+    }
+  }
+
+  return options;
+}
+
+async function main() {
+  const options = parseArgs();
+  const app = new AgentApp(options);
+
+  process.on("SIGINT", async () => {
+    await app.stop();
+    process.exit(0);
+  });
+
+  process.on("SIGTERM", async () => {
+    await app.stop();
+    process.exit(0);
+  });
+
+  try {
+    await app.start();
+  } catch (err) {
+    console.error("Fatal error starting agent:", err);
+    process.exit(1);
+  }
+}
+
+main();

package/tui/dist/app.d.ts

@@ -0,0 +1,41 @@
+import { type Container, type Editor, type TuiMainScreen } from "@earendil-works/pi-tui";
+import { KernelBridge } from "./bridge/kernel-bridge.js";
+import { PythonKernelClient, type PythonKernelClientOptions } from "./client.js";
+import { type FooterComponent } from "./components/footer.js";
+import { type ToolExecutionComponent } from "./components/tool-execution.js";
+import { BUILTIN_SLASH_COMMANDS, InteractiveMode, type InteractiveModeOptions } from "./interactive/interactive-mode.js";
+export { BUILTIN_SLASH_COMMANDS };
+export interface AppOptions extends InteractiveModeOptions, PythonKernelClientOptions {
+    workspace?: string;
+    model?: string;
+    mode?: string;
+    continueSession?: boolean;
+    resume?: string | boolean;
+    sessionName?: string;
+    thinking?: string;
+    noSession?: boolean;
+    newSession?: boolean;
+    prompt?: string;
+    pythonExecutable?: string;
+}
+export declare class AgentApp {
+    readonly options: AppOptions;
+    readonly client: PythonKernelClient;
+    readonly bridge: KernelBridge;
+    readonly interactiveMode: InteractiveMode;
+    get activeSelectorComponent(): any;
+    get isBusy(): boolean;
+    set isBusy(val: boolean);
+    constructor(options?: AppOptions);
+    get tui(): TuiMainScreen;
+    get chatContainer(): Container;
+    get editor(): Editor;
+    get footer(): FooterComponent;
+    get activeTools(): Map<string, ToolExecutionComponent>;
+    get toolStartTimes(): Map<string, number>;
+    handleAgentEvent(event: any): void;
+    handleUserSubmit(input: string): Promise<void>;
+    renderSessionHistory(messages: any[], banner?: string): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/tui/dist/app.js

@@ -0,0 +1,110 @@
+import { KernelBridge } from "./bridge/kernel-bridge.js";
+import { PythonKernelClient, } from "./client.js";
+import { BUILTIN_SLASH_COMMANDS, InteractiveMode, } from "./interactive/interactive-mode.js";
+export { BUILTIN_SLASH_COMMANDS };
+export class AgentApp {
+    options;
+    client;
+    bridge;
+    interactiveMode;
+    get activeSelectorComponent() {
+        return this.interactiveMode.activeSelectorComponent;
+    }
+    get isBusy() {
+        return this.interactiveMode.isStreaming;
+    }
+    set isBusy(val) {
+        this.interactiveMode.isStreaming = val;
+    }
+    constructor(options = {}) {
+        this.options = options;
+        this.client = new PythonKernelClient(options);
+        this.bridge = new KernelBridge(this.client);
+        this.interactiveMode = new InteractiveMode(this.bridge, options);
+        this.interactiveMode.onExit = async () => {
+            await this.client.shutdown();
+        };
+        const cleanupTerminal = () => {
+            try {
+                this.interactiveMode.ui.stop();
+            }
+            catch (err) {
+                void err;
+            }
+        };
+        process.once("exit", cleanupTerminal);
+    }
+    get tui() {
+        return this.interactiveMode.ui;
+    }
+    get chatContainer() {
+        return this.interactiveMode.chatContainer;
+    }
+    get editor() {
+        return this.interactiveMode.defaultEditor;
+    }
+    get footer() {
+        return this.interactiveMode.footer;
+    }
+    get activeTools() {
+        return this.interactiveMode.activeToolCalls;
+    }
+    get toolStartTimes() {
+        return this.interactiveMode.toolStartTimes;
+    }
+    handleAgentEvent(event) {
+        this.interactiveMode.handleAgentEvent(event);
+    }
+    async handleUserSubmit(input) {
+        await this.interactiveMode.handleUserInput(input);
+    }
+    renderSessionHistory(messages, banner) {
+        this.interactiveMode.renderSessionHistory(messages, banner);
+    }
+    async start() {
+        const initResult = await this.client.start();
+        await this.interactiveMode.init();
+        this.interactiveMode.start();
+        if (initResult?.session_name || initResult?.session_id) {
+            this.footer.update({
+                sessionName: initResult.session_name || initResult.session_id,
+            });
+        }
+        if (initResult?.context_window) {
+            this.footer.update({
+                contextWindow: initResult.context_window,
+            });
+        }
+        if (initResult?.model) {
+            this.footer.update({
+                modelName: initResult.model,
+                providerName: initResult.provider,
+            });
+        }
+        if (initResult?.thinking_level) {
+            this.footer.update({
+                thinkingLevel: initResult.thinking_level,
+            });
+        }
+        if (initResult?.usage) {
+            this.interactiveMode.updateFooterUsage(initResult.usage, initResult.context_window);
+        }
+        if (initResult?.messages && initResult.messages.length > 0) {
+            this.interactiveMode.renderSessionHistory(initResult.messages);
+        }
+        if (this.options.resume === true) {
+            await this.interactiveMode.handleSlashCommand("/resume");
+        }
+        else if (typeof this.options.resume === "string" && this.options.resume) {
+            await this.interactiveMode.handleSlashCommand(`/resume ${this.options.resume}`);
+        }
+        else if (this.options.prompt) {
+            await this.interactiveMode.handleUserInput(this.options.prompt);
+        }
+        this.tui.requestRender();
+    }
+    async stop() {
+        this.interactiveMode.stop();
+        await this.client.shutdown();
+    }
+}

package/tui/dist/bridge/event-translator.d.ts

@@ -0,0 +1,92 @@
+export interface ContentThinking {
+    type: "thinking";
+    thinking: string;
+}
+export interface ContentText {
+    type: "text";
+    text: string;
+}
+export interface ContentToolCall {
+    type: "toolCall";
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export type ContentBlock = ContentThinking | ContentText | ContentToolCall;
+export interface AssistantMessageState {
+    role: "assistant";
+    content: ContentBlock[];
+    stopReason?: string;
+    errorMessage?: string;
+}
+export interface AgentStartSessionEvent {
+    type: "agent_start";
+    systemPrompt: string;
+    userInput: string;
+}
+export interface TurnStartSessionEvent {
+    type: "turn_start";
+    iteration: number;
+}
+export interface TurnEndSessionEvent {
+    type: "turn_end";
+}
+export interface MessageStartSessionEvent {
+    type: "message_start";
+    message: AssistantMessageState | Record<string, unknown>;
+}
+export interface MessageUpdateSessionEvent {
+    type: "message_update";
+    message: AssistantMessageState;
+}
+export interface MessageEndSessionEvent {
+    type: "message_end";
+    message: AssistantMessageState;
+}
+export interface ToolExecutionStartSessionEvent {
+    type: "tool_execution_start";
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+}
+export interface ToolExecutionUpdateSessionEvent {
+    type: "tool_execution_update";
+    toolCallId: string;
+    toolName: string;
+    partialResult: unknown;
+}
+export interface ToolExecutionEndSessionEvent {
+    type: "tool_execution_end";
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    isError: boolean;
+}
+export interface AgentEndSessionEvent {
+    type: "agent_end";
+    iterations: number;
+    stopReason: string;
+}
+export interface ContextCompactedSessionEvent {
+    type: "context_compacted";
+    tokensBefore?: number;
+    tokensAfter?: number;
+}
+export type StandardSessionEvent = AgentStartSessionEvent | TurnStartSessionEvent | TurnEndSessionEvent | MessageStartSessionEvent | MessageUpdateSessionEvent | MessageEndSessionEvent | ToolExecutionStartSessionEvent | ToolExecutionUpdateSessionEvent | ToolExecutionEndSessionEvent | AgentEndSessionEvent | ContextCompactedSessionEvent | Record<string, unknown>;
+export declare class EventTranslator {
+    private currentAssistantMessage;
+    /**
+     * Translates incoming Python RPC notifications or raw event objects
+     * into standardized Pi AgentSessionEvents while tracking in-flight message state.
+     */
+    translate(raw: unknown): StandardSessionEvent | null;
+    /**
+     * Returns a copy of the current in-flight assistant message state, or null if idle.
+     */
+    getCurrentAssistantMessage(): AssistantMessageState | null;
+    /**
+     * Resets internal tracking state.
+     */
+    reset(): void;
+    private cloneMessage;
+}

package/tui/dist/bridge/event-translator.js

@@ -0,0 +1,216 @@
+export class EventTranslator {
+    currentAssistantMessage = null;
+    /**
+     * Translates incoming Python RPC notifications or raw event objects
+     * into standardized Pi AgentSessionEvents while tracking in-flight message state.
+     */
+    translate(raw) {
+        if (!raw || typeof raw !== "object") {
+            return null;
+        }
+        const payload = raw;
+        let event = payload;
+        if (payload.method === "event" &&
+            payload.params &&
+            typeof payload.params === "object") {
+            event = payload.params;
+        }
+        else if (payload.params &&
+            typeof payload.params === "object" &&
+            "type" in payload.params) {
+            event = payload.params;
+        }
+        if (!event.type || typeof event.type !== "string") {
+            return null;
+        }
+        switch (event.type) {
+            case "agent_start": {
+                this.currentAssistantMessage = null;
+                return {
+                    type: "agent_start",
+                    systemPrompt: String(event.system_prompt ?? event.systemPrompt ?? ""),
+                    userInput: String(event.user_input ?? event.userInput ?? ""),
+                };
+            }
+            case "turn_start": {
+                return {
+                    type: "turn_start",
+                    iteration: Number(event.iteration ?? 1),
+                };
+            }
+            case "turn_end": {
+                return {
+                    type: "turn_end",
+                };
+            }
+            case "message_start": {
+                const rawMsg = event.message;
+                const role = String(rawMsg?.role ?? "assistant");
+                if (role === "assistant") {
+                    this.currentAssistantMessage = {
+                        role: "assistant",
+                        content: [],
+                    };
+                    return {
+                        type: "message_start",
+                        message: this.cloneMessage(this.currentAssistantMessage),
+                    };
+                }
+                return {
+                    type: "message_start",
+                    message: rawMsg ?? { role, content: [] },
+                };
+            }
+            case "message_update": {
+                if (!this.currentAssistantMessage) {
+                    this.currentAssistantMessage = {
+                        role: "assistant",
+                        content: [],
+                    };
+                }
+                const reasoningDelta = event.reasoning_delta ?? event.reasoningDelta;
+                if (typeof reasoningDelta === "string" && reasoningDelta !== "") {
+                    let thinkingBlock = this.currentAssistantMessage.content.find((b) => b.type === "thinking");
+                    if (!thinkingBlock) {
+                        thinkingBlock = { type: "thinking", thinking: "" };
+                        this.currentAssistantMessage.content.push(thinkingBlock);
+                    }
+                    thinkingBlock.thinking += reasoningDelta;
+                }
+                const delta = event.delta;
+                if (typeof delta === "string" && delta !== "") {
+                    let textBlock = this.currentAssistantMessage.content.find((b) => b.type === "text");
+                    if (!textBlock) {
+                        textBlock = { type: "text", text: "" };
+                        this.currentAssistantMessage.content.push(textBlock);
+                    }
+                    textBlock.text += delta;
+                }
+                return {
+                    type: "message_update",
+                    message: this.cloneMessage(this.currentAssistantMessage),
+                };
+            }
+            case "message_end": {
+                const stopReason = String(event.stop_reason ?? event.stopReason ?? "stop");
+                if (this.currentAssistantMessage) {
+                    this.currentAssistantMessage.stopReason = stopReason;
+                    const completedMessage = this.cloneMessage(this.currentAssistantMessage);
+                    this.currentAssistantMessage = null;
+                    return {
+                        type: "message_end",
+                        message: completedMessage,
+                    };
+                }
+                const rawMsg = event.message;
+                return {
+                    type: "message_end",
+                    message: rawMsg ?? { role: "assistant", content: [], stopReason },
+                };
+            }
+            case "tool_execution_start": {
+                const toolCallId = String(event.toolCallId ?? event.tool_call_id ?? "");
+                const toolName = String(event.toolName ?? event.tool_name ?? "");
+                const args = (event.args && typeof event.args === "object" ? event.args : {});
+                if (this.currentAssistantMessage) {
+                    this.currentAssistantMessage.content.push({
+                        type: "toolCall",
+                        id: toolCallId,
+                        name: toolName,
+                        arguments: args,
+                    });
+                }
+                return {
+                    type: "tool_execution_start",
+                    toolCallId,
+                    toolName,
+                    args,
+                };
+            }
+            case "tool_execution_update": {
+                return {
+                    type: "tool_execution_update",
+                    toolCallId: String(event.toolCallId ?? event.tool_call_id ?? ""),
+                    toolName: String(event.toolName ?? event.tool_name ?? ""),
+                    partialResult: event.partialResult ?? event.partial_result,
+                };
+            }
+            case "tool_execution_end": {
+                return {
+                    type: "tool_execution_end",
+                    toolCallId: String(event.toolCallId ?? event.tool_call_id ?? ""),
+                    toolName: String(event.toolName ?? event.tool_name ?? ""),
+                    result: event.result,
+                    isError: Boolean(event.isError ?? event.is_error ?? false),
+                };
+            }
+            case "agent_end": {
+                this.currentAssistantMessage = null;
+                return {
+                    type: "agent_end",
+                    iterations: Number(event.iterations ?? 1),
+                    stopReason: String(event.stop_reason ?? event.stopReason ?? "completed"),
+                };
+            }
+            case "context_compacted": {
+                const tokensBefore = typeof event.tokensBefore === "number"
+                    ? event.tokensBefore
+                    : typeof event.tokens_before === "number"
+                        ? event.tokens_before
+                        : undefined;
+                const tokensAfter = typeof event.tokensAfter === "number"
+                    ? event.tokensAfter
+                    : typeof event.tokens_after === "number"
+                        ? event.tokens_after
+                        : undefined;
+                return {
+                    type: "context_compacted",
+                    tokensBefore,
+                    tokensAfter,
+                };
+            }
+            default: {
+                return { ...event };
+            }
+        }
+    }
+    /**
+     * Returns a copy of the current in-flight assistant message state, or null if idle.
+     */
+    getCurrentAssistantMessage() {
+        return this.currentAssistantMessage
+            ? this.cloneMessage(this.currentAssistantMessage)
+            : null;
+    }
+    /**
+     * Resets internal tracking state.
+     */
+    reset() {
+        this.currentAssistantMessage = null;
+    }
+    cloneMessage(msg) {
+        return {
+            role: msg.role,
+            content: msg.content.map((block) => {
+                if (block.type === "thinking") {
+                    return { type: "thinking", thinking: block.thinking };
+                }
+                if (block.type === "text") {
+                    return { type: "text", text: block.text };
+                }
+                if (block.type === "toolCall") {
+                    return {
+                        type: "toolCall",
+                        id: block.id,
+                        name: block.name,
+                        arguments: { ...block.arguments },
+                    };
+                }
+                const exhaustiveCheck = block;
+                return exhaustiveCheck;
+            }),
+            stopReason: msg.stopReason,
+            errorMessage: msg.errorMessage,
+        };
+    }
+}

package/tui/dist/bridge/kernel-bridge.d.ts

@@ -0,0 +1,48 @@
+import { type StandardSessionEvent } from "./event-translator.js";
+export interface PromptOptions {
+    streamingBehavior?: "steer" | "followUp";
+    [key: string]: unknown;
+}
+export interface RpcResponseData {
+    [key: string]: unknown;
+}
+export interface ClientLike {
+    request?(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    sendRequest?(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    on?(event: string, listener: (...args: any[]) => void): void;
+    off?(event: string, listener: (...args: any[]) => void): void;
+    removeListener?(event: string, listener: (...args: any[]) => void): void;
+}
+export interface TranslatorLike {
+    translate(event: unknown): StandardSessionEvent | null;
+}
+/**
+ * KernelBridge acts as a lightweight Session Adapter between the presentation
+ * layer and the PythonKernelClient.
+ */
+export declare class KernelBridge {
+    readonly client: ClientLike;
+    readonly translator: TranslatorLike;
+    constructor(client: ClientLike, translator?: TranslatorLike);
+    private call;
+    prompt(text: string, options?: PromptOptions): Promise<RpcResponseData>;
+    abort(): Promise<RpcResponseData>;
+    steer(text: string): Promise<RpcResponseData>;
+    followUp(text: string): Promise<RpcResponseData>;
+    listModels(options?: Record<string, unknown>): Promise<RpcResponseData>;
+    switchModel(model: string, provider?: string): Promise<RpcResponseData>;
+    listSessions(options?: Record<string, unknown>): Promise<RpcResponseData>;
+    resumeSession(sessionId: string): Promise<RpcResponseData>;
+    deleteSession(sessionId: string): Promise<RpcResponseData>;
+    getSessionHistory(): Promise<RpcResponseData>;
+    newSession(options?: Record<string, unknown>): Promise<RpcResponseData>;
+    getTree(): Promise<RpcResponseData>;
+    getSessionStats(): Promise<RpcResponseData>;
+    branchSession(nodeId: string): Promise<RpcResponseData>;
+    setThinking(level: string): Promise<RpcResponseData>;
+    login(provider: string, key: string): Promise<RpcResponseData>;
+    logout(provider: string): Promise<RpcResponseData>;
+    getSettings(): Promise<RpcResponseData>;
+    setSetting(key: string, value: unknown): Promise<RpcResponseData>;
+    subscribe(listener: (event: StandardSessionEvent) => void): () => void;
+}