diff --git a/.gitignore b/.gitignore
index 11b67ce..8f054d4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,3 +5,4 @@ dist/
.vscode/
*.tgz
*.log
+.deepcode/settings.json
diff --git a/README_en.md b/README-en.md
similarity index 60%
rename from README_en.md
rename to README-en.md
index ee5a103..c1d4acb 100644
--- a/README_en.md
+++ b/README-en.md
@@ -1,7 +1,24 @@
-# Deep Code CLI
+
+
+
+
+
+ 
+
+
+
Deep Code CLI
+
+[![][npm-release-shield]][npm-release-link] [![][npm-downloads-shield]][npm-downloads-link] [![][github-contributors-shield]][github-contributors-link] [![][github-forks-shield]][github-forks-link] [![][github-stars-shield]][github-stars-link]
+[![][github-issues-shield]][github-issues-link] [![][github-issues-pr-shield]][github-issues-pr-link] [![][github-license-shield]][github-license-link]
+
+English · [中文](./README.md)
+
+
+
+
+
+
+
+
+
+
+
Deep Code CLI
+
+[![][npm-release-shield]][npm-release-link] [![][npm-downloads-shield]][npm-downloads-link] [![][github-contributors-shield]][github-contributors-link] [![][github-forks-shield]][github-forks-link] [![][github-stars-shield]][github-stars-link]
+[![][github-issues-shield]][github-issues-link] [![][github-issues-pr-shield]][github-issues-pr-link] [![][github-license-shield]][github-license-link]
+
+[English](README-en.md) · 中文
+
+
+
+
+
+
+
+
+
+
+
Deep Code CLI
+
+[![][npm-release-shield]][npm-release-link] [![][npm-downloads-shield]][npm-downloads-link] [![][github-contributors-shield]][github-contributors-link] [![][github-forks-shield]][github-forks-link] [![][github-stars-shield]][github-stars-link]
+[![][github-issues-shield]][github-issues-link] [![][github-issues-pr-shield]][github-issues-pr-link] [![][github-license-shield]][github-license-link]
+
+[English](README-en.md) · 中文
+
+
+
Hello
\n" }),
+ },
+ },
+ ],
+ },
+ },
+ ],
+ },
+ createChatResponse("done", { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 }),
+ ]);
+
+ const sessionId = await manager.createSession({ text: "create an index page" });
+ const userMessage = manager.listSessionMessages(sessionId).find((message) => message.role === "user");
+ assert.ok(userMessage?.checkpointHash);
+ assert.equal(fs.existsSync(filePath), true);
+
+ manager.restoreSessionCode(sessionId, userMessage.id);
+
+ assert.equal(fs.existsSync(filePath), false);
+});
+
+test("Write checkpoints restore tool-touched files outside the workspace and leave unrelated files alone", async (t) => {
+ if (!hasGit()) {
+ t.skip("git is not available");
+ return;
+ }
+
+ const workspace = createTempDir("deepcode-write-outside-workspace-");
+ const outsideDir = createTempDir("deepcode-write-outside-target-");
+ const home = createTempDir("deepcode-write-outside-home-");
+ setHomeDir(home);
+
+ const outsideFilePath = path.join(outsideDir, "outside.txt");
+ const unrelatedWorkspaceFilePath = path.join(workspace, "unrelated.txt");
+ const manager = createMockedClientSessionManager(workspace, [
+ {
+ choices: [
+ {
+ message: {
+ content: "",
+ tool_calls: [
+ {
+ id: "call-write-outside",
+ type: "function",
+ function: {
+ name: "write",
+ arguments: JSON.stringify({ file_path: outsideFilePath, content: "outside\n" }),
+ },
+ },
+ ],
+ },
+ },
+ ],
+ },
+ createChatResponse("done", { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 }),
+ ]);
+
+ const sessionId = await manager.createSession({ text: "create an outside file" });
+ const userMessage = manager.listSessionMessages(sessionId).find((message) => message.role === "user");
+ assert.ok(userMessage?.checkpointHash);
+ assert.equal(fs.readFileSync(outsideFilePath, "utf8"), "outside\n");
+
+ fs.writeFileSync(unrelatedWorkspaceFilePath, "keep\n", "utf8");
+ manager.restoreSessionCode(sessionId, userMessage.id);
+
+ assert.equal(fs.existsSync(outsideFilePath), false);
+ assert.equal(fs.readFileSync(unrelatedWorkspaceFilePath, "utf8"), "keep\n");
+});
+
+test("missing git executable does not block sessions or Write tool calls", async () => {
+ const workspace = createTempDir("deepcode-no-git-write-workspace-");
+ const home = createTempDir("deepcode-no-git-write-home-");
+ setHomeDir(home);
+
+ const originalPath = process.env.PATH;
+ process.env.PATH = "";
+ try {
+ const filePath = path.join(workspace, "index.html");
+ const manager = createMockedClientSessionManager(workspace, [
+ {
+ choices: [
+ {
+ message: {
+ content: "",
+ tool_calls: [
+ {
+ id: "call-write-no-git",
+ type: "function",
+ function: {
+ name: "write",
+ arguments: JSON.stringify({ file_path: filePath, content: "No Git
\n" }),
+ },
+ },
+ ],
+ },
+ },
+ ],
+ },
+ createChatResponse("done", { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 }),
+ ]);
+
+ const sessionId = await manager.createSession({ text: "create an index page" });
+ const userMessage = manager.listSessionMessages(sessionId).find((message) => message.role === "user");
+
+ assert.equal(fs.readFileSync(filePath, "utf8"), "No Git
\n");
+ assert.equal(userMessage?.checkpointHash, undefined);
+ assert.equal(manager.getSession(sessionId)?.status, "completed");
+ } finally {
+ if (originalPath === undefined) {
+ delete process.env.PATH;
+ } else {
+ process.env.PATH = originalPath;
+ }
+ }
+});
+
+test("restoreSessionConversation truncates messages before the selected user prompt", async () => {
+ const workspace = createTempDir("deepcode-undo-conversation-workspace-");
+ const home = createTempDir("deepcode-undo-conversation-home-");
+ setHomeDir(home);
+
+ const manager = createSessionManager(workspace, "machine-id-undo-conversation");
+ (manager as any).activateSession = async () => {};
+
+ const sessionId = await manager.createSession({ text: "first prompt" });
+ const firstAssistant = (manager as any).buildAssistantMessage(
+ sessionId,
+ "first answer",
+ null,
+ null
+ ) as SessionMessage;
+ (manager as any).appendSessionMessage(sessionId, firstAssistant);
+ await manager.replySession(sessionId, { text: "second prompt" });
+ const secondUserMessage = manager
+ .listSessionMessages(sessionId)
+ .filter((message) => message.role === "user")
+ .at(-1);
+ assert.ok(secondUserMessage);
+ const secondAssistant = (manager as any).buildAssistantMessage(
+ sessionId,
+ "second answer",
+ null,
+ null
+ ) as SessionMessage;
+ (manager as any).appendSessionMessage(sessionId, secondAssistant);
+
+ manager.restoreSessionConversation(sessionId, secondUserMessage.id);
+
+ const contents = manager.listSessionMessages(sessionId).map((message) => message.content);
+ assert.ok(contents.includes("first prompt"));
+ assert.ok(contents.includes("first answer"));
+ assert.ok(!contents.includes("second prompt"));
+ assert.ok(!contents.includes("second answer"));
+ assert.equal(manager.getSession(sessionId)?.assistantReply, "first answer");
+});
+
+test("restoreSessionCode restores project files from the recorded Git checkpoint", async (t) => {
+ if (!hasGit()) {
+ t.skip("git is not available");
+ return;
+ }
+
+ const workspace = createTempDir("deepcode-undo-code-workspace-");
+ const home = createTempDir("deepcode-undo-code-home-");
+ setHomeDir(home);
+
+ const manager = createSessionManager(workspace, "machine-id-undo-code");
+ const sessionId = "session-code-restore";
+ const checkpointHash = createFileHistoryCommit(home, workspace, sessionId, { "tracked.txt": "before\n" });
+ createFileHistoryCommit(home, workspace, sessionId, { "tracked.txt": "after\n", "new.txt": "remove me\n" });
+ fs.writeFileSync(path.join(workspace, "tracked.txt"), "after\n", "utf8");
+ fs.writeFileSync(path.join(workspace, "new.txt"), "remove me\n", "utf8");
+
+ (manager as any).appendSessionMessage(sessionId, {
+ ...buildTestMessage("user-with-checkpoint", sessionId, "user", "restore here"),
+ checkpointHash,
+ });
+
+ manager.restoreSessionCode(sessionId, "user-with-checkpoint");
+
+ assert.equal(fs.readFileSync(path.join(workspace, "tracked.txt"), "utf8"), "before\n");
+ assert.equal(fs.existsSync(path.join(workspace, "new.txt")), false);
+});
+
test("replySession /continue runs trailing pending tool calls before requesting another response", async () => {
const workspace = createTempDir("deepcode-continue-tool-workspace-");
const home = createTempDir("deepcode-continue-tool-home-");
@@ -877,6 +1256,162 @@ test("replySession /continue runs trailing pending tool calls before requesting
);
});
+test("activateSession pauses for permission when a tool call requires ask", async () => {
+ const workspace = createTempDir("deepcode-permission-ask-workspace-");
+ const home = createTempDir("deepcode-permission-ask-home-");
+ setHomeDir(home);
+
+ const manager = createPermissionSessionManager(
+ workspace,
+ [
+ {
+ choices: [
+ {
+ message: {
+ content: "",
+ tool_calls: [
+ {
+ id: "call-bash",
+ type: "function",
+ function: {
+ name: "bash",
+ arguments: JSON.stringify({
+ command: "rg TODO src",
+ description: "Search TODO markers",
+ sideEffects: ["read-in-cwd"],
+ }),
+ },
+ },
+ ],
+ },
+ },
+ ],
+ usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+ },
+ ],
+ {
+ allow: [],
+ deny: [],
+ ask: [],
+ defaultMode: "askAll",
+ }
+ );
+
+ const sessionId = await manager.createSession({ text: "search todos" });
+ const session = manager.getSession(sessionId);
+ const assistant = manager
+ .listSessionMessages(sessionId)
+ .find((message) => message.role === "assistant" && (message.messageParams as any)?.tool_calls);
+
+ assert.equal(session?.status, "ask_permission");
+ assert.equal(session?.askPermissions?.[0]?.toolCallId, "call-bash");
+ assert.deepEqual(session?.askPermissions?.[0]?.scopes, ["read-in-cwd"]);
+ assert.deepEqual(assistant?.meta?.permissions, [{ toolCallId: "call-bash", permission: "ask" }]);
+ assert.equal(
+ manager.listSessionMessages(sessionId).some((message) => message.role === "tool"),
+ false
+ );
+});
+
+test("replySession applies permission replies, runs pending tools, and stores always allow scopes", async () => {
+ const workspace = createTempDir("deepcode-permission-allow-workspace-");
+ const home = createTempDir("deepcode-permission-allow-home-");
+ setHomeDir(home);
+ fs.writeFileSync(path.join(workspace, "note.txt"), "allowed content\n", "utf8");
+
+ const manager = createPermissionSessionManager(
+ workspace,
+ [createChatResponse("continued", { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 })],
+ {
+ allow: [],
+ deny: [],
+ ask: ["read-in-cwd"],
+ defaultMode: "allowAll",
+ }
+ );
+ const originalActivateSession = manager.activateSession.bind(manager);
+ (manager as any).activateSession = async () => {};
+ const sessionId = await manager.createSession({ text: "first prompt" });
+ const assistant = (manager as any).buildAssistantMessage(
+ sessionId,
+ "Need to read",
+ [
+ {
+ id: "call-read",
+ type: "function",
+ function: { name: "read", arguments: JSON.stringify({ file_path: path.join(workspace, "note.txt") }) },
+ },
+ ],
+ null
+ ) as SessionMessage;
+ assistant.meta = { ...(assistant.meta ?? {}), permissions: [{ toolCallId: "call-read", permission: "ask" }] };
+ (manager as any).appendSessionMessage(sessionId, assistant);
+ (manager as any).activateSession = originalActivateSession;
+
+ await manager.replySession(sessionId, {
+ text: "/continue",
+ permissions: [{ toolCallId: "call-read", permission: "allow" }],
+ alwaysAllows: ["read-in-cwd"],
+ });
+
+ const toolMessage = manager.listSessionMessages(sessionId).find((message) => message.role === "tool");
+ const settings = JSON.parse(fs.readFileSync(path.join(workspace, ".deepcode", "settings.json"), "utf8"));
+
+ assert.match(toolMessage?.content ?? "", /allowed content/);
+ assert.deepEqual(settings.permissions.allow, ["read-in-cwd"]);
+ assert.equal(manager.getSession(sessionId)?.status, "completed");
+});
+
+test("replySession turns denied permission replies into tool errors before appending user text", async () => {
+ const workspace = createTempDir("deepcode-permission-deny-workspace-");
+ const home = createTempDir("deepcode-permission-deny-home-");
+ setHomeDir(home);
+
+ const manager = createPermissionSessionManager(
+ workspace,
+ [createChatResponse("handled denial", { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 })],
+ {
+ allow: [],
+ deny: [],
+ ask: ["write-out-cwd"],
+ defaultMode: "allowAll",
+ }
+ );
+ const originalActivateSession = manager.activateSession.bind(manager);
+ (manager as any).activateSession = async () => {};
+ const sessionId = await manager.createSession({ text: "first prompt" });
+ const assistant = (manager as any).buildAssistantMessage(
+ sessionId,
+ "Need to write",
+ [
+ {
+ id: "call-write",
+ type: "function",
+ function: { name: "write", arguments: JSON.stringify({ file_path: "/tmp/outside.txt", content: "x" }) },
+ },
+ ],
+ null
+ ) as SessionMessage;
+ assistant.meta = { ...(assistant.meta ?? {}), permissions: [{ toolCallId: "call-write", permission: "ask" }] };
+ (manager as any).appendSessionMessage(sessionId, assistant);
+ (manager as any).activateSession = originalActivateSession;
+
+ await manager.replySession(sessionId, {
+ text: "Do not write outside the workspace.",
+ permissions: [{ toolCallId: "call-write", permission: "deny" }],
+ });
+
+ const messages = manager.listSessionMessages(sessionId);
+ const assistantIndex = messages.findIndex((message) => message.id === assistant.id);
+ const toolMessage = messages[assistantIndex + 1];
+ const userMessage = messages[assistantIndex + 2];
+
+ assert.equal(toolMessage?.role, "tool");
+ assert.match(toolMessage?.content ?? "", /User denied the required permission/);
+ assert.equal(userMessage?.role, "user");
+ assert.equal(userMessage?.content, "Do not write outside the workspace.");
+});
+
test("replySession preserves raw session messages when a previous tool call is pending", async () => {
const workspace = createTempDir("deepcode-pending-tool-workspace-");
const home = createTempDir("deepcode-pending-tool-home-");
@@ -1235,6 +1770,66 @@ test("Write tool params prefer file_path even when content appears first", () =>
assert.equal(toolMessage.meta?.paramsMd, filePath);
});
+test("LLM tool calls without ids receive generated 32 character ids", async () => {
+ const workspace = createTempDir("deepcode-tool-call-id-workspace-");
+ const home = createTempDir("deepcode-tool-call-id-home-");
+ setHomeDir(home);
+
+ const filePath = path.join(workspace, "note.txt");
+ fs.writeFileSync(filePath, "hello\n", "utf8");
+ const plan = "## Task List\n\n- [ ] Inspect current behavior";
+ const manager = createMockedClientSessionManager(workspace, [
+ {
+ choices: [
+ {
+ message: {
+ content: "",
+ tool_calls: [
+ {
+ id: "",
+ type: "function",
+ function: {
+ name: "UpdatePlan",
+ arguments: JSON.stringify({ plan, explanation: "Initial plan" }),
+ },
+ },
+ {
+ type: "function",
+ function: {
+ name: "read",
+ arguments: JSON.stringify({ file_path: filePath }),
+ },
+ },
+ ],
+ },
+ },
+ ],
+ },
+ createChatResponse("done", { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 }),
+ ]);
+
+ const sessionId = await manager.createSession({ text: "inspect note" });
+ const assistantMessage = manager
+ .listSessionMessages(sessionId)
+ .find((message) => message.role === "assistant" && (message.messageParams as any)?.tool_calls);
+ const toolCalls = (assistantMessage?.messageParams as { tool_calls?: Array<{ id?: unknown }> } | null)?.tool_calls;
+
+ assert.equal(toolCalls?.length, 2);
+ assert.match(String(toolCalls?.[0]?.id), /^[0-9a-f]{32}$/);
+ assert.match(String(toolCalls?.[1]?.id), /^[0-9a-f]{32}$/);
+ assert.notEqual(toolCalls?.[0]?.id, toolCalls?.[1]?.id);
+
+ const toolMessages = manager.listSessionMessages(sessionId).filter((message) => message.role === "tool");
+ assert.deepEqual(
+ toolMessages.map((message) => (message.messageParams as { tool_call_id?: unknown } | null)?.tool_call_id),
+ toolCalls?.map((toolCall) => toolCall.id)
+ );
+
+ const readToolMessage = toolMessages.find((message) => JSON.parse(message.content ?? "{}").name === "read");
+ assert.equal((readToolMessage?.meta?.function as { name?: string } | undefined)?.name, "read");
+ assert.equal(readToolMessage?.meta?.paramsMd, "note.txt");
+});
+
test("buildOpenAIMessages repairs mixed missing duplicate and orphan tool messages", () => {
const manager = createSessionManager(process.cwd(), "machine-id-mixed-tool-badcase");
const assistantMessage = (manager as any).buildAssistantMessage(
@@ -1562,7 +2157,7 @@ test("SessionManager streams chat completions and counts reasoning progress", as
assert.equal(progressEvents[2]?.formattedTokens, "3");
});
-test("SessionManager cancels skill matching before a session is created", async () => {
+test("SessionManager persists session and user message before skill matching is cancelled", async () => {
const workspace = createTempDir("deepcode-skill-abort-workspace-");
const home = createTempDir("deepcode-skill-abort-home-");
setHomeDir(home);
@@ -1591,7 +2186,13 @@ test("SessionManager cancels skill matching before a session is created", async
await manager.handleUserPrompt({ text: "please use demo" });
- assert.equal(manager.listSessions().length, 0);
+ // Session and user message are persisted before skill matching triggers an abort.
+ assert.equal(manager.listSessions().length, 1);
+ const [session] = manager.listSessions();
+ assert.equal(session?.status, "pending");
+ const messages = manager.listSessionMessages(session!.id);
+ const userMessage = messages.find((m) => m.role === "user");
+ assert.equal(userMessage?.content, "please use demo");
});
test("SessionManager treats OpenAI APIUserAbortError as interrupted", async () => {
@@ -1641,6 +2242,278 @@ test("SessionManager treats OpenAI APIUserAbortError as interrupted", async () =
assert.equal(session?.failReason, "interrupted");
});
+test("SessionManager marks MCP server as failed on single failed attempt (no auto-retry)", async () => {
+ const workspace = createTempDir("deepcode-mcp-fail-noworkspace-");
+ const serverPath = path.join(workspace, "mcp-server-fail.cjs");
+ fs.writeFileSync(serverPath, "process.exit(7);", "utf8");
+
+ const manager = createSessionManager(workspace, "machine-id-mcp-fail-no");
+ await manager.initMcpServers({ broken: { command: process.execPath, args: [serverPath] } });
+
+ const status = manager.getMcpStatus();
+ assert.equal(status.length, 1);
+ assert.equal(status[0]?.status, "failed");
+ assert.match(status[0]?.error ?? "", /exited with code 7/);
+
+ manager.dispose();
+});
+
+test("SessionManager reconnect succeeds on previously failed server", async () => {
+ const workspace = createTempDir("deepcode-mcp-reconn-ok-workspace-");
+ const serverPath = path.join(workspace, "mcp-server-ok.cjs");
+ fs.writeFileSync(
+ serverPath,
+ `
+const readline = require("readline");
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+function send(message) {
+ process.stdout.write(JSON.stringify(message) + "\\n");
+}
+rl.on("line", (line) => {
+ const request = JSON.parse(line);
+ if (!("id" in request)) return;
+ if (request.method === "initialize") {
+ send({ jsonrpc: "2.0", id: request.id, result: { protocolVersion: "2024-11-05", capabilities: {} } });
+ return;
+ }
+ if (request.method === "tools/list") {
+ send({ jsonrpc: "2.0", id: request.id, result: { tools: [{ name: "ping", inputSchema: { type: "object", properties: {} } }] } });
+ return;
+ }
+ send({ jsonrpc: "2.0", id: request.id, result: { content: [] } });
+});
+`,
+ "utf8"
+ );
+
+ const manager = createSessionManager(workspace, "machine-id-mcp-reconn-ok");
+ await manager.initMcpServers({ fixable: { command: process.execPath, args: [serverPath] } });
+
+ const status = manager.getMcpStatus();
+ assert.equal(status.length, 1);
+ assert.equal(status[0]?.status, "ready");
+ assert.equal(status[0]?.toolCount, 1);
+
+ manager.dispose();
+});
+
+test("SessionManager adjusts the active Bash timeout control and session metadata", async () => {
+ const workspace = createTempDir("deepcode-bash-timeout-session-");
+ const home = createTempDir("deepcode-bash-timeout-home-");
+ setHomeDir(home);
+
+ const manager = createSessionManager(workspace, "");
+ const sessionId = await manager.createSession({ text: "hello" });
+
+ (manager as any).addSessionProcess(sessionId, 123, "sleep 10");
+
+ let timeoutInfo = {
+ timeoutMs: 10 * 60 * 1000,
+ startedAtMs: 1000,
+ deadlineAtMs: 1000 + 10 * 60 * 1000,
+ timedOut: false,
+ };
+ (manager as any).setSessionProcessTimeoutControl(sessionId, 123, {
+ getInfo: () => timeoutInfo,
+ setTimeoutMs: (timeoutMs: number) => {
+ timeoutInfo = {
+ ...timeoutInfo,
+ timeoutMs,
+ deadlineAtMs: timeoutInfo.startedAtMs + timeoutMs,
+ };
+ return timeoutInfo;
+ },
+ });
+
+ const adjustment = manager.adjustActiveBashTimeout(5 * 60 * 1000);
+ const processInfo = manager.getSession(sessionId)?.processes?.get("123");
+
+ assert.equal(adjustment?.processId, "123");
+ assert.equal(adjustment?.timeoutMs, 15 * 60 * 1000);
+ assert.equal(processInfo?.timeoutMs, 15 * 60 * 1000);
+ assert.equal(processInfo?.deadlineAt, new Date(timeoutInfo.deadlineAtMs).toISOString());
+});
+
+test("SessionManager.deleteSession removes session entry from the index", () => {
+ const workspace = createTempDir("deepcode-delete-workspace-");
+ const home = createTempDir("deepcode-delete-home-");
+ setHomeDir(home);
+
+ const manager = createSessionManager(workspace, "machine-id-delete");
+ (manager as any).activateSession = async () => {};
+
+ // Create two sessions
+ const session1 = createSessionAndMessages(manager, "session-delete-1", "First session");
+ const session2 = createSessionAndMessages(manager, "session-delete-2", "Second session");
+
+ assert.equal(manager.listSessions().length, 2);
+
+ // Delete the first session
+ const result = manager.deleteSession(session1);
+ assert.equal(result, true);
+
+ const remaining = manager.listSessions();
+ assert.equal(remaining.length, 1);
+ assert.equal(remaining[0]?.id, session2);
+});
+
+test("SessionManager.deleteSession removes the messages file", () => {
+ const workspace = createTempDir("deepcode-delete-msg-workspace-");
+ const home = createTempDir("deepcode-delete-msg-home-");
+ setHomeDir(home);
+
+ const manager = createSessionManager(workspace, "machine-id-delete-msg");
+ (manager as any).activateSession = async () => {};
+
+ const sessionId = createSessionAndMessages(manager, "session-delete-msg", "Test session");
+ const messagePath = path.join(
+ home,
+ ".deepcode",
+ "projects",
+ workspace.replace(/[\\\\/]/g, "-").replace(/:/g, ""),
+ `${sessionId}.jsonl`
+ );
+
+ // Verify messages file exists
+ assert.ok(fs.existsSync(messagePath));
+
+ manager.deleteSession(sessionId);
+
+ // Verify messages file is removed
+ assert.equal(fs.existsSync(messagePath), false);
+});
+
+test("SessionManager.deleteSession returns false when session does not exist", () => {
+ const workspace = createTempDir("deepcode-delete-nonexist-workspace-");
+ const home = createTempDir("deepcode-delete-nonexist-home-");
+ setHomeDir(home);
+
+ const manager = createSessionManager(workspace, "machine-id-delete-nonexist");
+
+ const result = manager.deleteSession("nonexistent-session-id");
+ assert.equal(result, false);
+ assert.equal(manager.listSessions().length, 0);
+});
+
+test("SessionManager.deleteSession does not affect other sessions", () => {
+ const workspace = createTempDir("deepcode-delete-others-workspace-");
+ const home = createTempDir("deepcode-delete-others-home-");
+ setHomeDir(home);
+
+ const manager = createSessionManager(workspace, "machine-id-delete-others");
+ (manager as any).activateSession = async () => {};
+
+ const session1 = createSessionAndMessages(manager, "session-keep-1", "Keep session 1");
+ const session2 = createSessionAndMessages(manager, "session-keep-2", "Keep session 2");
+
+ // Delete non-existent session
+ const result = manager.deleteSession("non-existent");
+ assert.equal(result, false);
+ assert.equal(manager.listSessions().length, 2);
+
+ // Delete one session
+ assert.equal(manager.deleteSession(session1), true);
+ assert.equal(manager.listSessions().length, 1);
+ assert.equal(manager.listSessions()[0]?.id, session2);
+
+ // The remaining session should still have its messages accessible
+ const messages = manager.listSessionMessages(session2);
+ assert.ok(messages.length > 0);
+});
+
+/**
+ * Helper: creates a session and writes a few messages to it so we can test
+ * that deleteSession removes both the index entry and the messages file.
+ */
+function createSessionAndMessages(manager: SessionManager, sessionId: string, summary: string): string {
+ const now = new Date().toISOString();
+ const index = (manager as any).loadSessionsIndex();
+ index.entries.push({
+ id: sessionId,
+ summary,
+ assistantReply: null,
+ assistantThinking: null,
+ assistantRefusal: null,
+ toolCalls: null,
+ status: "completed",
+ failReason: null,
+ usage: null,
+ usagePerModel: null,
+ activeTokens: 0,
+ createTime: now,
+ updateTime: now,
+ processes: null,
+ });
+ (manager as any).saveSessionsIndex(index);
+
+ // Write a couple of message lines to the messages file
+ const projectDir = (manager as any).getProjectStorage().projectDir;
+ const messagePath = path.join(projectDir, `${sessionId}.jsonl`);
+ const msg = JSON.stringify({
+ id: "msg-1",
+ sessionId,
+ role: "user",
+ content: summary,
+ visible: true,
+ createTime: now,
+ updateTime: now,
+ });
+ fs.writeFileSync(messagePath, `${msg}\n`, "utf8");
+
+ return sessionId;
+}
+
+function hasGit(): boolean {
+ try {
+ execFileSync("git", ["--version"], { stdio: "ignore" });
+ return true;
+ } catch {
+ return false;
+ }
+}
+
+function createFileHistoryCommit(
+ home: string,
+ workspace: string,
+ sessionId: string,
+ files: Record
+): string {
+ const projectCode = workspace.replace(/[\\/]/g, "-").replace(/:/g, "");
+ const gitDir = path.join(home, ".deepcode", "projects", projectCode, "file-history", ".git");
+ const fileHistory = new GitFileHistory(workspace, gitDir);
+ fileHistory.ensureSession(sessionId);
+
+ const filePaths: string[] = [];
+ for (const [relativePath, content] of Object.entries(files)) {
+ const filePath = path.join(workspace, relativePath);
+ fs.mkdirSync(path.dirname(filePath), { recursive: true });
+ fs.writeFileSync(filePath, content, "utf8");
+ filePaths.push(filePath);
+ }
+ const commitHash = fileHistory.recordCheckpoint(sessionId, filePaths, "checkpoint");
+ assert.ok(commitHash);
+ return commitHash;
+}
+
+function runFileHistoryGit(
+ gitDir: string,
+ workspace: string,
+ args: string[],
+ input = "",
+ env: NodeJS.ProcessEnv = process.env
+): string {
+ return execFileSync(
+ "git",
+ ["-c", "core.autocrlf=false", "-c", "core.eol=lf", `--git-dir=${gitDir}`, `--work-tree=${workspace}`, ...args],
+ {
+ encoding: "utf8",
+ input,
+ env,
+ stdio: ["pipe", "pipe", "pipe"],
+ }
+ );
+}
+
function createSessionManager(projectRoot: string, machineId: string): SessionManager {
return new SessionManager({
projectRoot,
@@ -1657,6 +2530,49 @@ function createSessionManager(projectRoot: string, machineId: string): SessionMa
});
}
+function createNotifyingSessionManager(
+ projectRoot: string,
+ responses: unknown[],
+ notifyPath: string,
+ notifyOutput: string
+): SessionManager {
+ const client = {
+ chat: {
+ completions: {
+ create: async () => {
+ const response = responses.shift();
+ assert.ok(response, "expected a queued chat response");
+ if (response instanceof Error) {
+ throw response;
+ }
+ return response;
+ },
+ },
+ },
+ };
+
+ return new SessionManager({
+ projectRoot,
+ createOpenAIClient: () => ({
+ client: client as any,
+ model: "test-model",
+ baseURL: "https://api.deepseek.com",
+ thinkingEnabled: false,
+ notify: notifyPath,
+ env: {
+ NOTIFY_OUTPUT: notifyOutput,
+ STATUS: "stale-status",
+ FAIL_REASON: "stale-failure",
+ BODY: "stale-body",
+ TITLE: "stale-title",
+ },
+ }),
+ getResolvedSettings: () => ({ model: "test-model" }),
+ renderMarkdown: (text) => text,
+ onAssistantMessage: () => {},
+ });
+}
+
function createMockedClientSessionManager(projectRoot: string, responses: unknown[]): SessionManager {
const client = {
chat: {
@@ -1684,6 +2600,42 @@ function createMockedClientSessionManager(projectRoot: string, responses: unknow
});
}
+function createPermissionSessionManager(
+ projectRoot: string,
+ responses: unknown[],
+ permissions: {
+ allow: any[];
+ deny: any[];
+ ask: any[];
+ defaultMode: "allowAll" | "askAll";
+ }
+): SessionManager {
+ const client = {
+ chat: {
+ completions: {
+ create: async () => {
+ const response = responses.shift();
+ assert.ok(response, "expected a queued chat response");
+ return response;
+ },
+ },
+ },
+ };
+
+ return new SessionManager({
+ projectRoot,
+ createOpenAIClient: () => ({
+ client: client as any,
+ model: "test-model",
+ baseURL: "https://api.deepseek.com",
+ thinkingEnabled: false,
+ }),
+ getResolvedSettings: () => ({ model: "test-model", permissions }),
+ renderMarkdown: (text) => text,
+ onAssistantMessage: () => {},
+ });
+}
+
function createMockedClientSessionManagerWithClient(projectRoot: string, client: unknown): SessionManager {
return new SessionManager({
projectRoot,
@@ -1740,6 +2692,55 @@ function createTempDir(prefix: string): string {
return dir;
}
+function createNotifyRecorderScript(dir: string): string {
+ const scriptPath = path.join(dir, "notify-recorder.cjs");
+ fs.writeFileSync(
+ scriptPath,
+ `#!/usr/bin/env node
+const fs = require("fs");
+const keys = ["DURATION", "STATUS", "FAIL_REASON", "BODY", "TITLE"];
+const record = {};
+for (const key of keys) {
+ record[key] = Object.prototype.hasOwnProperty.call(process.env, key) ? process.env[key] : null;
+}
+fs.appendFileSync(process.env.NOTIFY_OUTPUT, JSON.stringify(record) + "\\n", "utf8");
+`,
+ "utf8"
+ );
+ fs.chmodSync(scriptPath, 0o755);
+ return scriptPath;
+}
+
+async function waitForNotifyRecords(
+ outputPath: string,
+ expectedCount: number
+): Promise>> {
+ for (let attempt = 0; attempt < 100; attempt += 1) {
+ if (fs.existsSync(outputPath)) {
+ const records = fs
+ .readFileSync(outputPath, "utf8")
+ .split(/\r?\n/)
+ .filter(Boolean)
+ .map((line) => JSON.parse(line) as Record);
+ if (records.length >= expectedCount) {
+ return records;
+ }
+ }
+ await new Promise((resolve) => setTimeout(resolve, 20));
+ }
+ assert.fail(`expected ${expectedCount} notify records in ${outputPath}`);
+}
+
+async function waitForMcpStatus(manager: SessionManager, expectedStatus: string): Promise {
+ for (let attempt = 0; attempt < 100; attempt += 1) {
+ if (manager.getMcpStatus()[0]?.status === expectedStatus) {
+ return;
+ }
+ await new Promise((resolve) => setTimeout(resolve, 20));
+ }
+ assert.fail(`expected MCP status ${expectedStatus}`);
+}
+
function escapeRegExp(value: string): string {
return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}
diff --git a/src/tests/sessionList.test.ts b/src/tests/sessionList.test.ts
index e3bf51c..3dfda33 100644
--- a/src/tests/sessionList.test.ts
+++ b/src/tests/sessionList.test.ts
@@ -1,6 +1,7 @@
import { test } from "node:test";
import assert from "node:assert/strict";
-import { formatSessionTitle } from "../ui";
+import { formatSessionTitle, filterSessions, formatSessionStatus } from "../ui";
+import type { SessionEntry } from "../session";
test("formatSessionTitle replaces newlines with spaces", () => {
assert.equal(formatSessionTitle("first line\nsecond line\r\nthird"), "first line second line third");
@@ -9,3 +10,108 @@ test("formatSessionTitle replaces newlines with spaces", () => {
test("formatSessionTitle truncates after normalizing whitespace", () => {
assert.equal(formatSessionTitle("one\n two three", 10), "one two th…");
});
+
+test("formatSessionStatus maps status values to display labels", () => {
+ assert.equal(formatSessionStatus("completed"), "done");
+ assert.equal(formatSessionStatus("processing"), "running");
+ assert.equal(formatSessionStatus("pending"), "pending");
+ assert.equal(formatSessionStatus("waiting_for_user"), "waiting");
+ assert.equal(formatSessionStatus("failed"), "failed");
+ assert.equal(formatSessionStatus("interrupted"), "stopped");
+ assert.equal(formatSessionStatus("unknown_status" as any), "unknown_status");
+});
+
+test("filterSessions returns all sessions when query is empty", () => {
+ const sessions = buildSessions([{ summary: "Fix login bug" }, { summary: "Add dark mode" }]);
+ assert.equal(filterSessions(sessions, "").length, 2);
+ assert.equal(filterSessions(sessions, " ").length, 2);
+});
+
+test("filterSessions matches by summary (case-insensitive)", () => {
+ const sessions = buildSessions([
+ { summary: "Fix login bug" },
+ { summary: "Add dark mode" },
+ { summary: "Refactor auth module" },
+ ]);
+
+ assert.equal(filterSessions(sessions, "login").length, 1);
+ assert.equal(filterSessions(sessions, "LOGIN").length, 1);
+ assert.equal(filterSessions(sessions, "Login").length, 1);
+});
+
+test("filterSessions matches by status (case-insensitive)", () => {
+ const sessions = buildSessions([
+ { summary: "Task 1", status: "completed" },
+ { summary: "Task 2", status: "failed" },
+ { summary: "Task 3", status: "completed" },
+ ]);
+
+ assert.equal(filterSessions(sessions, "failed").length, 1);
+ assert.equal(filterSessions(sessions, "completed").length, 2);
+});
+
+test("filterSessions matches by failReason", () => {
+ const sessions = buildSessions([
+ { summary: "Task 1", status: "failed", failReason: "API key not found" },
+ { summary: "Task 2", status: "completed" },
+ ]);
+
+ assert.equal(filterSessions(sessions, "API key").length, 1);
+ assert.equal(filterSessions(sessions, "not found").length, 1);
+});
+
+test("filterSessions matches by assistantReply", () => {
+ const sessions = buildSessions([
+ { summary: "Task 1", assistantReply: "The bug was fixed by updating the config." },
+ { summary: "Task 2", assistantReply: "Dark mode has been added successfully." },
+ ]);
+
+ assert.equal(filterSessions(sessions, "dark mode").length, 1);
+ assert.equal(filterSessions(sessions, "config").length, 1);
+});
+
+test("filterSessions returns empty array when no match", () => {
+ const sessions = buildSessions([{ summary: "Fix login bug" }, { summary: "Add dark mode" }]);
+
+ assert.equal(filterSessions(sessions, "nonexistent").length, 0);
+});
+
+test("filterSessions matches across multiple fields on same session", () => {
+ const sessions = buildSessions([
+ { summary: "Fix login bug", status: "failed", failReason: "Timeout error" },
+ { summary: "Add dark mode", status: "completed" },
+ ]);
+
+ // Should match the first session via status
+ assert.equal(filterSessions(sessions, "failed").length, 1);
+ // Should match the first session via failReason
+ assert.equal(filterSessions(sessions, "timeout").length, 1);
+ // Partial summary match
+ assert.equal(filterSessions(sessions, "login").length, 1);
+});
+
+test("filterSessions handles sessions with null fields", () => {
+ const sessions = buildSessions([{ summary: null }, { summary: "Valid summary" }]);
+
+ assert.equal(filterSessions(sessions, "valid").length, 1);
+ assert.equal(filterSessions(sessions, "summary").length, 1);
+});
+
+function buildSessions(overrides: Array>): SessionEntry[] {
+ return overrides.map((override, i) => ({
+ id: `session-${i}`,
+ summary: override.summary ?? null,
+ assistantReply: override.assistantReply ?? null,
+ assistantThinking: null,
+ assistantRefusal: null,
+ toolCalls: null,
+ status: override.status ?? "completed",
+ failReason: override.failReason ?? null,
+ usage: null,
+ usagePerModel: null,
+ activeTokens: 0,
+ createTime: new Date().toISOString(),
+ updateTime: new Date().toISOString(),
+ processes: null,
+ }));
+}
diff --git a/src/tests/settings-and-notify.test.ts b/src/tests/settings-and-notify.test.ts
index 6990288..52f8671 100644
--- a/src/tests/settings-and-notify.test.ts
+++ b/src/tests/settings-and-notify.test.ts
@@ -1,6 +1,12 @@
import { test } from "node:test";
import assert from "node:assert/strict";
-import { buildNotifyEnv, formatDurationSeconds, launchNotifyScript, type NotifySpawn } from "../common/notify";
+import {
+ buildNotifyEnv,
+ formatDurationSeconds,
+ launchNotifyScript,
+ type NotifyContext,
+ type NotifySpawn,
+} from "../common/notify";
import { applyModelConfigSelection, resolveSettings, resolveSettingsSources } from "../settings";
const TEST_PROCESS_ENV = {};
@@ -141,6 +147,35 @@ test("resolveSettingsSources applies user, project, and DEEPCODE environment pre
assert.equal(resolved.env.WEBHOOK, "system-webhook");
});
+test("resolveSettingsSources merges permission settings", () => {
+ const resolved = resolveSettingsSources(
+ {
+ permissions: {
+ allow: ["read-in-cwd", "network"],
+ ask: ["write-out-cwd"],
+ defaultMode: "askAll",
+ },
+ },
+ {
+ permissions: {
+ allow: ["write-in-cwd", "read-in-cwd"],
+ deny: ["delete-out-cwd"],
+ defaultMode: "allowAll",
+ },
+ },
+ {
+ model: "default-model",
+ baseURL: "https://default.example.com",
+ },
+ TEST_PROCESS_ENV
+ );
+
+ assert.deepEqual(resolved.permissions.allow, ["read-in-cwd", "network", "write-in-cwd"]);
+ assert.deepEqual(resolved.permissions.ask, ["write-out-cwd"]);
+ assert.deepEqual(resolved.permissions.deny, ["delete-out-cwd"]);
+ assert.equal(resolved.permissions.defaultMode, "allowAll");
+});
+
test("resolveSettingsSources merges MCP env with documented priority", () => {
const resolved = resolveSettingsSources(
{
@@ -358,14 +393,79 @@ test("formatDurationSeconds preserves sub-second precision and trims trailing ze
assert.equal(formatDurationSeconds(4000), "4");
});
-test("buildNotifyEnv injects DURATION", () => {
+test("buildNotifyEnv injects DURATION without context", () => {
const env = buildNotifyEnv(2750, { HOME: "/tmp/home" });
assert.equal(env.HOME, "/tmp/home");
assert.equal(env.DURATION, "2");
+ assert.equal(env.STATUS, undefined);
+ assert.equal(env.FAIL_REASON, undefined);
+ assert.equal(env.BODY, undefined);
+ assert.equal(env.TITLE, undefined);
+});
+
+test("buildNotifyEnv injects STATUS, FAIL_REASON, BODY, and TITLE from context", () => {
+ const context: NotifyContext = {
+ status: "failed",
+ failReason: "API key not found",
+ body: "Hello, this is the last assistant message.",
+ title: "Fix login bug",
+ };
+ const env = buildNotifyEnv(5000, { HOME: "/tmp/home" }, context);
+ assert.equal(env.HOME, "/tmp/home");
+ assert.equal(env.DURATION, "5");
+ assert.equal(env.STATUS, "failed");
+ assert.equal(env.FAIL_REASON, "API key not found");
+ assert.equal(env.BODY, "Hello, this is the last assistant message.");
+ assert.equal(env.TITLE, "Fix login bug");
+});
+
+test("buildNotifyEnv omits optional context fields when not provided", () => {
+ const env = buildNotifyEnv(
+ 1000,
+ {
+ HOME: "/tmp/home",
+ STATUS: "stale-status",
+ FAIL_REASON: "stale-failure",
+ BODY: "stale-body",
+ TITLE: "stale-title",
+ },
+ { status: "completed" }
+ );
+ assert.equal(env.STATUS, "completed");
+ assert.equal(env.FAIL_REASON, undefined);
+ assert.equal(env.BODY, undefined);
+ assert.equal(env.TITLE, undefined);
+});
+
+test("buildNotifyEnv ignores empty strings in context", () => {
+ const env = buildNotifyEnv(
+ 1000,
+ { HOME: "/tmp/home" },
+ {
+ status: "",
+ failReason: "",
+ body: "",
+ title: "",
+ }
+ );
+ assert.equal(env.STATUS, undefined);
+ assert.equal(env.FAIL_REASON, undefined);
+ assert.equal(env.BODY, undefined);
+ assert.equal(env.TITLE, undefined);
+});
+
+test("buildNotifyEnv preserves special characters in body and title", () => {
+ const context: NotifyContext = {
+ body: 'Line 1\nLine 2\tindented "quoted"',
+ title: "Fix: login & signup (urgent)",
+ };
+ const env = buildNotifyEnv(1000, {}, context);
+ assert.equal(env.BODY, 'Line 1\nLine 2\tindented "quoted"');
+ assert.equal(env.TITLE, "Fix: login & signup (urgent)");
});
test(
- "launchNotifyScript passes DURATION and falls back to /bin/sh for non-executable scripts",
+ "launchNotifyScript passes DURATION, context vars, and falls back to /bin/sh for non-executable scripts",
{ skip: process.platform === "win32" },
() => {
const calls: Array<{
@@ -390,7 +490,13 @@ test(
};
};
- launchNotifyScript("/tmp/notify.sh", 2750, "/tmp/project", spawnProcess, { WEBHOOK: "configured" });
+ const context: NotifyContext = {
+ status: "completed",
+ body: "Task finished successfully.",
+ title: "Fix login bug",
+ };
+
+ launchNotifyScript("/tmp/notify.sh", 2750, "/tmp/project", spawnProcess, { WEBHOOK: "configured" }, context);
assert.equal(calls.length, 2);
assert.equal(calls[0]?.command, "/tmp/notify.sh");
@@ -398,9 +504,16 @@ test(
assert.equal(calls[0]?.options.cwd, "/tmp/project");
assert.equal(calls[0]?.options.env?.DURATION, "2");
assert.equal(calls[0]?.options.env?.WEBHOOK, "configured");
+ assert.equal(calls[0]?.options.env?.STATUS, "completed");
+ assert.equal(calls[0]?.options.env?.FAIL_REASON, undefined);
+ assert.equal(calls[0]?.options.env?.BODY, "Task finished successfully.");
+ assert.equal(calls[0]?.options.env?.TITLE, "Fix login bug");
assert.equal(calls[1]?.command, "/bin/sh");
assert.deepEqual(calls[1]?.args, ["/tmp/notify.sh"]);
assert.equal(calls[1]?.options.cwd, "/tmp/project");
assert.equal(calls[1]?.options.env?.DURATION, "2");
+ assert.equal(calls[1]?.options.env?.STATUS, "completed");
+ assert.equal(calls[1]?.options.env?.BODY, "Task finished successfully.");
+ assert.equal(calls[1]?.options.env?.TITLE, "Fix login bug");
}
);
diff --git a/src/tests/slashCommands.test.ts b/src/tests/slashCommands.test.ts
index bba5244..30d77ee 100644
--- a/src/tests/slashCommands.test.ts
+++ b/src/tests/slashCommands.test.ts
@@ -19,7 +19,18 @@ test("buildSlashCommands prefixes skills before built-ins", () => {
assert.equal(items[0].kind, "skill");
assert.equal(items[0].name, "skill-writer");
const builtinNames = items.filter((i) => i.kind !== "skill").map((i) => i.name);
- assert.deepEqual(builtinNames, ["skills", "model", "new", "init", "resume", "continue", "mcp", "exit"]);
+ assert.deepEqual(builtinNames, [
+ "skills",
+ "model",
+ "new",
+ "init",
+ "resume",
+ "continue",
+ "undo",
+ "mcp",
+ "raw",
+ "exit",
+ ]);
});
test("filterSlashCommands matches partial prefixes", () => {
@@ -66,6 +77,13 @@ test("findExactSlashCommand returns built-in /continue", () => {
assert.equal(item?.kind, "continue");
});
+test("findExactSlashCommand returns built-in /undo", () => {
+ const items = buildSlashCommands(skills);
+ const item = findExactSlashCommand(items, "/undo");
+ assert.ok(item);
+ assert.equal(item?.kind, "undo");
+});
+
test("findExactSlashCommand returns built-in /skills", () => {
const items = buildSlashCommands(skills);
const item = findExactSlashCommand(items, "/skills");
@@ -80,6 +98,13 @@ test("findExactSlashCommand returns built-in /model", () => {
assert.equal(item?.kind, "model");
});
+test("findExactSlashCommand returns built-in /raw", () => {
+ const items = buildSlashCommands(skills);
+ const item = findExactSlashCommand(items, "/raw");
+ assert.ok(item);
+ assert.equal(item?.kind, "raw");
+});
+
test("findExactSlashCommand returns the matching skill", () => {
const items = buildSlashCommands(skills);
const item = findExactSlashCommand(items, "/code-review");
diff --git a/src/tests/tool-executor.test.ts b/src/tests/tool-executor.test.ts
new file mode 100644
index 0000000..f36def2
--- /dev/null
+++ b/src/tests/tool-executor.test.ts
@@ -0,0 +1,41 @@
+import { afterEach, test } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { ToolExecutor } from "../tools/executor";
+
+const tempDirs: string[] = [];
+
+afterEach(() => {
+ while (tempDirs.length > 0) {
+ const dir = tempDirs.pop();
+ if (dir) {
+ fs.rmSync(dir, { recursive: true, force: true });
+ }
+ }
+});
+
+test("ToolExecutor accepts title-case built-in tool aliases", async () => {
+ const workspace = fs.mkdtempSync(path.join(os.tmpdir(), "deepcode-tool-executor-"));
+ tempDirs.push(workspace);
+ const filePath = path.join(workspace, "sample.txt");
+ fs.writeFileSync(filePath, "alpha\nbeta\n", "utf8");
+
+ const executor = new ToolExecutor(workspace);
+ const executions = await executor.executeToolCalls("alias-session", [
+ {
+ id: "call-read",
+ type: "function",
+ function: {
+ name: "Read",
+ arguments: JSON.stringify({ file_path: filePath }),
+ },
+ },
+ ]);
+
+ assert.equal(executions.length, 1);
+ assert.equal(executions[0]?.result.ok, true);
+ assert.equal(executions[0]?.result.name, "read");
+ assert.match(executions[0]?.result.output ?? "", /alpha/);
+});
diff --git a/src/tests/tool-handlers.test.ts b/src/tests/tool-handlers.test.ts
index 0b21edd..f66153c 100644
--- a/src/tests/tool-handlers.test.ts
+++ b/src/tests/tool-handlers.test.ts
@@ -4,7 +4,7 @@ import * as fs from "fs";
import * as os from "os";
import * as path from "path";
import { setTimeout as delay } from "node:timers/promises";
-import type { ToolExecutionContext } from "../tools/executor";
+import type { ProcessTimeoutControl, ToolExecutionContext } from "../tools/executor";
import { handleBashTool } from "../tools/bash-handler";
import { handleEditTool } from "../tools/edit-handler";
import { handleReadTool } from "../tools/read-handler";
@@ -52,6 +52,58 @@ test("Bash streams stdout and stderr before command completion", async () => {
assert.match(streamedOutput, /err/);
});
+test("Bash terminates commands that exceed the configured timeout", async () => {
+ const workspace = createTempWorkspace();
+ const exitedPids: Array = [];
+
+ const result = await handleBashTool(
+ {
+ command: "printf 'start\\n'; sleep 5; printf 'done\\n'",
+ },
+ createContext("bash-timeout", workspace, {
+ bashTimeoutMs: 100,
+ bashMinTimeoutMs: 1,
+ onProcessExit: (pid) => {
+ exitedPids.push(pid);
+ },
+ })
+ );
+
+ assert.equal(result.ok, false);
+ assert.equal(result.error, "Command timed out.");
+ assert.equal(result.metadata?.timedOut, true);
+ assert.equal(result.metadata?.timeoutMs, 100);
+ assert.doesNotMatch(result.output ?? "", /done/);
+ assert.equal(exitedPids.length, 1);
+});
+
+test("Bash timeout control can extend the active command deadline", async () => {
+ const workspace = createTempWorkspace();
+ let timeoutControl: ProcessTimeoutControl | null = null;
+
+ const result = await handleBashTool(
+ {
+ command: "sleep 0.2; printf 'done\\n'",
+ },
+ createContext("bash-timeout-extend", workspace, {
+ bashTimeoutMs: 100,
+ bashMinTimeoutMs: 1,
+ onProcessTimeoutControl: (_pid, control) => {
+ if (control) {
+ timeoutControl = control;
+ control.setTimeoutMs(1000);
+ }
+ },
+ })
+ );
+
+ assert.ok(timeoutControl);
+ assert.equal(result.ok, true);
+ assert.match(result.output ?? "", /done/);
+ assert.equal(result.metadata?.timedOut, false);
+ assert.equal(result.metadata?.timeoutMs, 1000);
+});
+
test("UpdatePlan accepts a markdown task list string", async () => {
const workspace = createTempWorkspace();
const plan = ["## Task List", "", "- [>] Inspect current behavior", "- [ ] Implement UpdatePlan"].join("\n");
diff --git a/src/tools/bash-handler.ts b/src/tools/bash-handler.ts
index 071da53..4272271 100644
--- a/src/tools/bash-handler.ts
+++ b/src/tools/bash-handler.ts
@@ -1,5 +1,7 @@
import { spawn } from "child_process";
-import type { ToolExecutionContext, ToolExecutionResult } from "./executor";
+import { DEFAULT_BASH_TIMEOUT_MS, clampBashTimeoutMs } from "../common/bash-timeout";
+import { killProcessTree } from "../common/process-tree";
+import type { ProcessTimeoutControl, ProcessTimeoutInfo, ToolExecutionContext, ToolExecutionResult } from "./executor";
import {
buildDisableExtglobCommand,
buildShellEnv,
@@ -22,6 +24,9 @@ type ToolCommandResult = {
truncated: boolean;
shellPath?: string;
startCwd?: string;
+ timedOut?: boolean;
+ timeoutMs?: number;
+ deadlineAt?: string;
};
export async function handleBashTool(
@@ -48,12 +53,15 @@ export async function handleBashTool(
execution.exitCode,
execution.signal,
shellPath,
- startCwd
+ startCwd,
+ execution.timedOut,
+ execution.timeoutMs,
+ execution.deadlineAtMs
);
updateSessionCwd(context.sessionId, startCwd, result.cwd);
if (execution.error || result.exitCode !== 0 || result.signal !== null) {
- const errorMessage = buildErrorMessage(result.exitCode, result.signal, execution.error);
+ const errorMessage = buildErrorMessage(result.exitCode, result.signal, execution.error, execution.timedOut);
return formatResult({ ...result, ok: false }, "bash", errorMessage);
}
@@ -102,10 +110,27 @@ async function executeShellCommand(
cwd: string,
command: string,
context: ToolExecutionContext
-): Promise<{ stdout: string; stderr: string; exitCode: number | null; signal: string | null; error?: string }> {
+): Promise<{
+ stdout: string;
+ stderr: string;
+ exitCode: number | null;
+ signal: string | null;
+ error?: string;
+ timedOut: boolean;
+ timeoutMs: number;
+ deadlineAtMs: number;
+}> {
return new Promise((resolve) => {
const detached = process.platform !== "win32";
const configuredEnv = context.createOpenAIClient?.().env ?? {};
+ const minTimeoutMs = context.bashMinTimeoutMs;
+ const initialTimeoutMs = clampBashTimeoutMs(context.bashTimeoutMs ?? DEFAULT_BASH_TIMEOUT_MS, minTimeoutMs);
+ const startedAtMs = Date.now();
+ let timeoutMs = initialTimeoutMs;
+ let deadlineAtMs = startedAtMs + timeoutMs;
+ let timedOut = false;
+ let settled = false;
+ let timeoutTimer: ReturnType | null = null;
const child = spawn(shellPath, shellArgs, {
cwd,
env: buildShellEnv(shellPath, configuredEnv),
@@ -114,8 +139,53 @@ async function executeShellCommand(
stdio: ["ignore", "pipe", "pipe"],
});
const pid = child.pid;
+
+ const getTimeoutInfo = (): ProcessTimeoutInfo => ({
+ timeoutMs,
+ startedAtMs,
+ deadlineAtMs,
+ timedOut,
+ });
+ const stopTimeoutTimer = () => {
+ if (timeoutTimer) {
+ clearTimeout(timeoutTimer);
+ timeoutTimer = null;
+ }
+ };
+ const triggerTimeout = () => {
+ if (settled || timedOut || typeof pid !== "number") {
+ return;
+ }
+ timedOut = true;
+ stopTimeoutTimer();
+ killProcessTree(pid, "SIGKILL");
+ };
+ const scheduleTimeout = () => {
+ stopTimeoutTimer();
+ if (settled) {
+ return;
+ }
+ const remainingMs = Math.max(0, deadlineAtMs - Date.now());
+ timeoutTimer = setTimeout(triggerTimeout, remainingMs);
+ };
+ const timeoutControl: ProcessTimeoutControl = {
+ getInfo: getTimeoutInfo,
+ setTimeoutMs: (nextTimeoutMs) => {
+ timeoutMs = clampBashTimeoutMs(nextTimeoutMs, minTimeoutMs);
+ deadlineAtMs = startedAtMs + timeoutMs;
+ if (deadlineAtMs <= Date.now()) {
+ triggerTimeout();
+ } else {
+ scheduleTimeout();
+ }
+ return getTimeoutInfo();
+ },
+ };
+
if (typeof pid === "number") {
context.onProcessStart?.(pid, command);
+ context.onProcessTimeoutControl?.(pid, timeoutControl);
+ scheduleTimeout();
}
let stdout = "";
@@ -138,7 +208,10 @@ async function executeShellCommand(
});
child.on("close", (code, signal) => {
+ settled = true;
+ stopTimeoutTimer();
if (typeof pid === "number") {
+ context.onProcessTimeoutControl?.(pid, null);
context.onProcessExit?.(pid);
}
resolve({
@@ -147,6 +220,9 @@ async function executeShellCommand(
exitCode: typeof code === "number" ? code : null,
signal: signal ?? null,
error,
+ timedOut,
+ timeoutMs,
+ deadlineAtMs,
});
});
});
@@ -173,7 +249,10 @@ function buildToolCommandResult(
exitCode: number | null,
signal: string | null,
shellPath: string,
- startCwd: string
+ startCwd: string,
+ timedOut: boolean = false,
+ timeoutMs?: number,
+ deadlineAtMs?: number
): ToolCommandResult {
const { output: cleanedStdout, cwd } = stripMarker(stdout, marker);
const combined = joinOutput(cleanedStdout, stderr);
@@ -187,6 +266,9 @@ function buildToolCommandResult(
truncated,
shellPath,
startCwd,
+ timedOut,
+ timeoutMs,
+ deadlineAt: typeof deadlineAtMs === "number" ? new Date(deadlineAtMs).toISOString() : undefined,
};
}
@@ -231,10 +313,13 @@ function truncateOutput(output: string): { text: string; truncated: boolean } {
return { text: output.slice(0, MAX_OUTPUT_CHARS), truncated: true };
}
-function buildErrorMessage(exitCode: number | null, signal: string | null, error?: string): string {
+function buildErrorMessage(exitCode: number | null, signal: string | null, error?: string, timedOut = false): string {
if (error) {
return error;
}
+ if (timedOut) {
+ return "Command timed out.";
+ }
if (signal) {
return `Command terminated by signal ${signal}.`;
}
@@ -253,6 +338,15 @@ function formatResult(result: ToolCommandResult, name: string, errorMessage?: st
shellPath: result.shellPath,
startCwd: result.startCwd,
};
+ if (typeof result.timedOut === "boolean") {
+ metadata.timedOut = result.timedOut;
+ }
+ if (typeof result.timeoutMs === "number") {
+ metadata.timeoutMs = result.timeoutMs;
+ }
+ if (result.deadlineAt) {
+ metadata.deadlineAt = result.deadlineAt;
+ }
const outputValue = result.output ? result.output : undefined;
diff --git a/src/tools/edit-handler.ts b/src/tools/edit-handler.ts
index 29108e5..454a673 100644
--- a/src/tools/edit-handler.ts
+++ b/src/tools/edit-handler.ts
@@ -321,7 +321,9 @@ export async function handleEditTool(
const updated = applyReplacement(raw, replacementOldString, replacementNewString, matches, replaceAll);
const diffPreview = buildDiffPreview(filePath, raw, updated);
+ context.onBeforeFileMutation?.(filePath);
writeTextFile(filePath, updated, metadata.encoding, metadata.lineEndings);
+ context.onAfterFileMutation?.(filePath);
const freshMetadata = readTextFileWithMetadata(filePath);
recordFileState(
context.sessionId,
diff --git a/src/tools/executor.ts b/src/tools/executor.ts
index 70ceab1..220fc89 100644
--- a/src/tools/executor.ts
+++ b/src/tools/executor.ts
@@ -39,15 +39,35 @@ export type ToolExecutionContext = {
onProcessStart?: (processId: string | number, command: string) => void;
onProcessExit?: (processId: string | number) => void;
onProcessStdout?: (processId: string | number, chunk: string) => void;
+ onProcessTimeoutControl?: (processId: string | number, control: ProcessTimeoutControl | null) => void;
+ onBeforeFileMutation?: (filePath: string) => void;
+ onAfterFileMutation?: (filePath: string) => void;
+ bashTimeoutMs?: number;
+ bashMinTimeoutMs?: number;
};
export type ToolExecutionHooks = {
onProcessStart?: (processId: string | number, command: string) => void;
onProcessExit?: (processId: string | number) => void;
onProcessStdout?: (processId: string | number, chunk: string) => void;
+ onProcessTimeoutControl?: (processId: string | number, control: ProcessTimeoutControl | null) => void;
+ onBeforeFileMutation?: (filePath: string) => void;
+ onAfterFileMutation?: (filePath: string) => void;
shouldStop?: () => boolean;
};
+export type ProcessTimeoutInfo = {
+ timeoutMs: number;
+ startedAtMs: number;
+ deadlineAtMs: number;
+ timedOut: boolean;
+};
+
+export type ProcessTimeoutControl = {
+ getInfo: () => ProcessTimeoutInfo;
+ setTimeoutMs: (timeoutMs: number) => ProcessTimeoutInfo;
+};
+
export type ToolExecutionResult = {
ok: boolean;
name: string;
@@ -69,6 +89,13 @@ export type ToolHandler = (
context: ToolExecutionContext
) => Promise;
+const BUILT_IN_TOOL_NAME_ALIASES = new Map([
+ ["Bash", "bash"],
+ ["Read", "read"],
+ ["Write", "write"],
+ ["Edit", "edit"],
+]);
+
export type ToolCallExecution = {
toolCallId: string;
content: string;
@@ -167,7 +194,8 @@ export class ToolExecutor {
hooks?: ToolExecutionHooks
): Promise {
const toolName = toolCall.function.name;
- const handler = this.toolHandlers.get(toolName);
+ const handlerName = BUILT_IN_TOOL_NAME_ALIASES.get(toolName) ?? toolName;
+ const handler = this.toolHandlers.get(handlerName);
if (!handler) {
// Try MCP tools
if (this.mcpManager?.isMcpTool(toolName)) {
@@ -200,6 +228,9 @@ export class ToolExecutor {
onProcessStart: hooks?.onProcessStart,
onProcessExit: hooks?.onProcessExit,
onProcessStdout: hooks?.onProcessStdout,
+ onProcessTimeoutControl: hooks?.onProcessTimeoutControl,
+ onBeforeFileMutation: hooks?.onBeforeFileMutation,
+ onAfterFileMutation: hooks?.onAfterFileMutation,
});
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
diff --git a/src/tools/write-handler.ts b/src/tools/write-handler.ts
index 153c1c6..a4c81bf 100644
--- a/src/tools/write-handler.ts
+++ b/src/tools/write-handler.ts
@@ -97,7 +97,9 @@ export async function handleWriteTool(
const encoding = existingMetadata?.encoding ?? "utf8";
const lineEndings = existingMetadata?.lineEndings ?? (input.content.includes("\r\n") ? "CRLF" : "LF");
const diffPreview = buildDiffPreview(filePath, existingMetadata?.content ?? null, normalizedContent);
+ context.onBeforeFileMutation?.(filePath);
const bytes = writeTextFile(filePath, normalizedContent, encoding, lineEndings);
+ context.onAfterFileMutation?.(filePath);
const freshMetadata = readTextFileWithMetadata(filePath);
recordFileState(
diff --git a/src/ui/App.tsx b/src/ui/App.tsx
index 8d8dca1..71e9ca3 100644
--- a/src/ui/App.tsx
+++ b/src/ui/App.tsx
@@ -4,27 +4,30 @@ import chalk from "chalk";
import * as fs from "fs";
import * as os from "os";
import * as path from "path";
-import OpenAI from "openai";
+import { createOpenAIClient } from "../common/openai-client";
import {
- SessionManager,
type LlmStreamProgress,
type MessageMeta,
+ type PermissionScope,
type SessionEntry,
+ SessionManager,
type SessionMessage,
type SessionStatus,
type SkillInfo,
+ type UndoTarget,
type UserPromptContent,
} from "../session";
import {
applyModelConfigSelection,
- resolveSettingsSources,
type DeepcodingSettings,
type ModelConfigSelection,
type ResolvedDeepcodingSettings,
+ resolveSettingsSources,
} from "../settings";
-import { PromptInput, type PromptSubmission } from "./PromptInput";
-import { MessageView } from "./MessageView";
+import { PromptInput, type PromptDraft, type PromptSubmission } from "./PromptInput";
+import { MessageView, RawModeExitPrompt } from "./components";
import { SessionList } from "./SessionList";
+import { UndoSelector, type UndoRestoreMode } from "./UndoSelector";
import { buildLoadingText } from "./loadingText";
import { findExpandedThinkingId } from "./thinkingState";
import { WelcomeScreen } from "./WelcomeScreen";
@@ -32,39 +35,57 @@ import { AskUserQuestionPrompt } from "./AskUserQuestionPrompt";
import { McpStatusList } from "./McpStatusList";
import { ProcessStdoutView } from "./ProcessStdoutView";
import {
+ type AskUserQuestionAnswers,
findPendingAskUserQuestion,
formatAskUserQuestionAnswers,
- type AskUserQuestionAnswers,
} from "./askUserQuestion";
+import { PermissionPrompt, type PermissionPromptResult } from "./PermissionPrompt";
import { buildExitSummaryText } from "./exitSummary";
+import { RawMode, useRawModeContext } from "./contexts";
+import { renderMessageToStdout } from "./components/MessageView/utils";
+import { renderRawModeMessages } from "./utils";
+import { ANSI_CLEAR_SCREEN } from "./constants";
const DEFAULT_MODEL = "deepseek-v4-pro";
const DEFAULT_BASE_URL = "https://api.deepseek.com";
-type View = "chat" | "session-list" | "mcp-status";
+type View = "chat" | "session-list" | "undo" | "mcp-status";
type AppProps = {
projectRoot: string;
- version?: string;
initialPrompt?: string;
onRestart?: () => void;
};
-export function App({ projectRoot, version = "", initialPrompt, onRestart }: AppProps): React.ReactElement {
+function App({ projectRoot, initialPrompt, onRestart }: AppProps): React.ReactElement {
const { exit } = useApp();
const { stdout, write } = useStdout();
- const { columns } = useWindowSize();
+ const { columns, rows } = useWindowSize();
+ const { mode, setMode } = useRawModeContext();
const initialPromptSubmittedRef = useRef(false);
+ const processStdoutRef = useRef>(new Map());
+ const rawModeRef = useRef(mode);
+ const writeRef = useRef(write);
+ const lastRenderedColumnsRef = useRef(null);
+ const messagesRef = useRef([]);
const [view, setView] = useState("chat");
const [busy, setBusy] = useState(false);
const [skills, setSkills] = useState([]);
const [messages, setMessages] = useState([]);
const [sessions, setSessions] = useState([]);
+ const [undoTargets, setUndoTargets] = useState([]);
+ const [promptDraft, setPromptDraft] = useState(null);
const [statusLine, setStatusLine] = useState("");
const [errorLine, setErrorLine] = useState(null);
const [streamProgress, setStreamProgress] = useState(null);
const [runningProcesses, setRunningProcesses] = useState(null);
const [activeStatus, setActiveStatus] = useState(null);
+ const [activeAskPermissions, setActiveAskPermissions] = useState(undefined);
+ const [pendingPermissionReply, setPendingPermissionReply] = useState<{
+ sessionId: string;
+ permissions: PermissionPromptResult["permissions"];
+ alwaysAllows: PermissionScope[];
+ } | null>(null);
const [dismissedQuestionIds, setDismissedQuestionIds] = useState>(() => new Set());
const [isExiting, setIsExiting] = useState(false);
const [showWelcome, setShowWelcome] = useState(true);
@@ -73,9 +94,8 @@ export function App({ projectRoot, version = "", initialPrompt, onRestart }: App
const [nowTick, setNowTick] = useState(0);
const [mcpStatuses, setMcpStatuses] = useState>([]);
const [showProcessStdout, setShowProcessStdout] = useState(false);
- const processStdoutRef = useRef>(new Map());
- const messagesRef = useRef([]);
+ rawModeRef.current = mode;
messagesRef.current = messages;
const sessionManager = useMemo(() => {
@@ -86,11 +106,16 @@ export function App({ projectRoot, version = "", initialPrompt, onRestart }: App
renderMarkdown: (text) => text,
onAssistantMessage: (message: SessionMessage) => {
setMessages((prev) => [...prev, message]);
+ if (rawModeRef.current === RawMode.Raw) {
+ process.stdout.write("\n");
+ process.stdout.write(renderMessageToStdout(message, rawModeRef.current) + "\n\n");
+ }
},
onSessionEntryUpdated: (entry) => {
setStatusLine(buildStatusLine(entry));
setRunningProcesses(entry.processes);
setActiveStatus(entry.status);
+ setActiveAskPermissions(entry.askPermissions);
},
onLlmStreamProgress: (progress) => {
if (progress.phase === "end") {
@@ -119,6 +144,33 @@ export function App({ projectRoot, version = "", initialPrompt, onRestart }: App
});
}, [projectRoot]);
+ /**
+ * Navigate to a sub-view.
+ */
+ const navigateToSubView = useCallback((targetView: View) => {
+ setShowWelcome(false);
+ setView(targetView);
+ }, []);
+
+ /**
+ * Reset the static view to the welcome screen.
+ */
+ const resetStaticView = useCallback(
+ (loadedMessages: SessionMessage[], options?: { clearScreen?: boolean }) => {
+ if (options?.clearScreen) {
+ process.stdout.write(ANSI_CLEAR_SCREEN);
+ }
+ setMessages([]);
+ setWelcomeNonce((n) => n + 1);
+ navigateToSubView("chat");
+ setTimeout(() => {
+ setMessages(loadedMessages);
+ setShowWelcome(true);
+ }, 0);
+ },
+ [navigateToSubView]
+ );
+
useEffect(() => {
if (!busy) {
return;
@@ -147,23 +199,55 @@ export function App({ projectRoot, version = "", initialPrompt, onRestart }: App
[sessionManager]
);
+ /**
+ * Reset the app to the welcome screen.
+ */
+ const resetToWelcome = useCallback(async () => {
+ writeRef.current(ANSI_CLEAR_SCREEN);
+ sessionManager.setActiveSessionId(null);
+ setStatusLine("");
+ setErrorLine(null);
+ setRunningProcesses(null);
+ setActiveStatus(null);
+ setActiveAskPermissions(undefined);
+ setPendingPermissionReply(null);
+ setDismissedQuestionIds(new Set());
+ resetStaticView([]);
+ await refreshSkills();
+ }, [sessionManager, resetStaticView, refreshSkills]);
+
+ /**
+ * Refresh the list of sessions.
+ */
useEffect(() => {
refreshSessionsList();
void refreshSkills();
}, [refreshSessionsList, refreshSkills]);
+ // Eagerly create the OpenAI client on mount so the TCP+TLS connection
+ // warmup (fire-and-forget inside createOpenAIClient) starts before the
+ // user sends their first prompt.
+ useEffect(() => {
+ createOpenAIClient(projectRoot);
+ }, [projectRoot]);
+
+ /**
+ * Initialize MCP servers.
+ */
useLayoutEffect(() => {
const settings = resolveCurrentSettings(projectRoot);
void sessionManager.initMcpServers(settings.mcpServers);
}, [projectRoot, sessionManager]);
+ /**
+ * Dispose the session manager on unmount.
+ */
useEffect(() => {
return () => {
sessionManager.dispose();
};
}, [sessionManager]);
- const writeRef = useRef(write);
writeRef.current = write;
const handlePrompt = useCallback(
async (submission: PromptSubmission) => {
@@ -187,37 +271,34 @@ export function App({ projectRoot, version = "", initialPrompt, onRestart }: App
if (onRestart) {
onRestart();
} else {
- writeRef.current("\u001B[2J\u001B[3J\u001B[H");
- sessionManager.setActiveSessionId(null);
- setMessages([]);
- setStatusLine("");
- setErrorLine(null);
- setRunningProcesses(null);
- setActiveStatus(null);
- setDismissedQuestionIds(new Set());
- setShowWelcome(true);
- setWelcomeNonce((n) => n + 1);
- await refreshSkills();
+ await resetToWelcome();
refreshSessionsList();
}
return;
}
if (submission.command === "resume") {
- setShowWelcome(false);
refreshSessionsList();
- setView("session-list");
+ navigateToSubView("session-list");
return;
}
if (submission.command === "continue" && isCurrentSessionEmpty(sessionManager)) {
- setShowWelcome(false);
refreshSessionsList();
- setView("session-list");
+ navigateToSubView("session-list");
+ return;
+ }
+ if (submission.command === "undo") {
+ const activeSessionId = sessionManager.getActiveSessionId();
+ if (!activeSessionId) {
+ setErrorLine("No active session to undo.");
+ return;
+ }
+ setUndoTargets(sessionManager.listUndoTargets(activeSessionId));
+ navigateToSubView("undo");
return;
}
if (submission.command === "mcp") {
- setShowWelcome(false);
setMcpStatuses(sessionManager.getMcpStatus());
- setView("mcp-status");
+ navigateToSubView("mcp-status");
return;
}
@@ -226,7 +307,16 @@ export function App({ projectRoot, version = "", initialPrompt, onRestart }: App
imageUrls: submission.imageUrls,
skills:
submission.selectedSkills && submission.selectedSkills.length > 0 ? submission.selectedSkills : undefined,
+ permissions: submission.permissions,
+ alwaysAllows: submission.alwaysAllows,
};
+ const activeSessionId = sessionManager.getActiveSessionId();
+ const permissionReply =
+ pendingPermissionReply && activeSessionId === pendingPermissionReply.sessionId ? pendingPermissionReply : null;
+ if (permissionReply) {
+ prompt.permissions = permissionReply.permissions;
+ prompt.alwaysAllows = permissionReply.alwaysAllows;
+ }
const trimmedText = (submission.text ?? "").trim();
const selectedSkillNames = submission.selectedSkills?.map((skill) => skill.name).filter(Boolean) ?? [];
@@ -246,6 +336,9 @@ export function App({ projectRoot, version = "", initialPrompt, onRestart }: App
processStdoutRef.current.clear();
try {
await sessionManager.handleUserPrompt(prompt);
+ if (permissionReply) {
+ setPendingPermissionReply(null);
+ }
await refreshSkills();
refreshSessionsList();
} catch (error) {
@@ -257,7 +350,16 @@ export function App({ projectRoot, version = "", initialPrompt, onRestart }: App
setRunningProcesses(null);
}
},
- [exit, onRestart, sessionManager, refreshSkills, refreshSessionsList]
+ [
+ sessionManager,
+ pendingPermissionReply,
+ exit,
+ onRestart,
+ refreshSkills,
+ refreshSessionsList,
+ navigateToSubView,
+ resetToWelcome,
+ ]
);
const handleInterrupt = useCallback(() => {
@@ -272,6 +374,11 @@ export function App({ projectRoot, version = "", initialPrompt, onRestart }: App
setShowProcessStdout(false);
}, []);
+ const handleAdjustBashTimeout = useCallback(
+ (deltaMs: number) => sessionManager.adjustActiveBashTimeout(deltaMs),
+ [sessionManager]
+ );
+
const handleModelConfigChange = useCallback(
(selection: ModelConfigSelection): string => {
const current = resolveCurrentSettings(projectRoot);
@@ -323,6 +430,13 @@ export function App({ projectRoot, version = "", initialPrompt, onRestart }: App
[handlePrompt]
);
+ const reloadActiveSessionView = useCallback(
+ (sessionId: string): void => {
+ resetStaticView(loadVisibleMessages(sessionManager, sessionId), { clearScreen: true });
+ },
+ [resetStaticView, sessionManager]
+ );
+
useEffect(() => {
if (initialPromptSubmittedRef.current || !initialPrompt || !initialPrompt.trim()) {
return;
@@ -338,54 +452,138 @@ export function App({ projectRoot, version = "", initialPrompt, onRestart }: App
const handleSelectSession = useCallback(
async (sessionId: string) => {
- const currentSessionId = sessionManager.getActiveSessionId();
- if (currentSessionId !== sessionId) {
- process.stdout.write("\u001B[2J\u001B[3J\u001B[H");
- }
sessionManager.setActiveSessionId(sessionId);
// Clear first so resets its index to 0.
- setMessages([]);
- setShowWelcome(false);
- setWelcomeNonce((n) => n + 1);
- setView("chat");
- // Load messages after the reset so all static items are rendered.
- setTimeout(() => {
- setMessages(loadVisibleMessages(sessionManager, sessionId));
- setShowWelcome(true);
- }, 0);
+ resetStaticView(loadVisibleMessages(sessionManager, sessionId), { clearScreen: true });
const session = sessionManager.getSession(sessionId);
setStatusLine(session ? buildStatusLine(session) : "");
setRunningProcesses(session?.processes ?? null);
setActiveStatus(session?.status ?? null);
+ setActiveAskPermissions(session?.askPermissions);
+ if (pendingPermissionReply && pendingPermissionReply.sessionId !== sessionId) {
+ setPendingPermissionReply(null);
+ }
await refreshSkills(sessionId);
},
- [sessionManager, refreshSkills]
+ [sessionManager, resetStaticView, pendingPermissionReply, refreshSkills]
+ );
+
+ const handleDeleteSession = useCallback(
+ async (id: string): Promise => {
+ const isActiveSession = sessionManager.getActiveSessionId() === id;
+
+ // If the deleted session is the active one, clear the active session first
+ if (isActiveSession) {
+ sessionManager.setActiveSessionId(null);
+ }
+
+ sessionManager.deleteSession(id);
+ refreshSessionsList();
+
+ if (isActiveSession) {
+ await resetToWelcome();
+ }
+ },
+ [sessionManager, refreshSessionsList, resetToWelcome]
+ );
+
+ const handleUndoRestore = useCallback(
+ async (target: UndoTarget, restoreMode: UndoRestoreMode): Promise => {
+ const sessionId = sessionManager.getActiveSessionId();
+ if (!sessionId) {
+ setErrorLine("No active session to undo.");
+ setView("chat");
+ setShowWelcome(true);
+ return;
+ }
+
+ const errors: string[] = [];
+ if (restoreMode === "code-and-conversation") {
+ try {
+ sessionManager.restoreSessionCode(sessionId, target.message.id);
+ } catch (error) {
+ errors.push(`Code restore failed: ${error instanceof Error ? error.message : String(error)}`);
+ }
+ }
+
+ let conversationRestored = false;
+ try {
+ sessionManager.restoreSessionConversation(sessionId, target.message.id);
+ conversationRestored = true;
+ } catch (error) {
+ errors.push(`Conversation restore failed: ${error instanceof Error ? error.message : String(error)}`);
+ }
+
+ refreshSessionsList();
+ await refreshSkills(sessionId);
+ setView("chat");
+ setErrorLine(errors.length > 0 ? errors.join(" ") : null);
+ if (conversationRestored) {
+ setPromptDraft(buildPromptDraftFromSessionMessage(target.message, Date.now()));
+ }
+ reloadActiveSessionView(sessionId);
+ },
+ [reloadActiveSessionView, refreshSessionsList, refreshSkills, sessionManager]
+ );
+
+ const handleRawModeChange = useCallback(
+ (nextMode: string) => {
+ const activeSessionId = sessionManager.getActiveSessionId();
+ setMode(nextMode as RawMode);
+ // Reset chat view state synchronously so the transition frame does not
+ // re-render a stale welcome screen before handleSelectSession runs.
+ setShowWelcome(false);
+ setMessages([]);
+ // Clear screen to remove stale formatted text.
+ process.stdout.write(ANSI_CLEAR_SCREEN);
+
+ setTimeout(() => {
+ if (nextMode === RawMode.Raw) {
+ // Write all messages directly to stdout for raw scrollback mode.
+ const allMessages = activeSessionId ? loadVisibleMessages(sessionManager, activeSessionId) : [];
+ renderRawModeMessages(allMessages, nextMode);
+ } else if (activeSessionId) {
+ // Switch to chat view to render messages.
+ handleSelectSession(activeSessionId);
+ } else {
+ // No active session: just show the welcome screen once.
+ setWelcomeNonce((n) => n + 1);
+ setShowWelcome(true);
+ }
+ }, 200);
+ },
+ [handleSelectSession, sessionManager, setMode]
);
- const [stableColumns, setStableColumns] = useState(columns);
- useEffect(() => {
- const timer = setTimeout(() => setStableColumns(columns), 100);
- return () => clearTimeout(timer);
- }, [columns]);
- const lastRenderedColumnsRef = useRef(null);
useEffect(() => {
if (!stdout?.isTTY) {
return;
}
- if (stableColumns <= 0) {
+ if (columns <= 0) {
return;
}
if (lastRenderedColumnsRef.current === null) {
- lastRenderedColumnsRef.current = stableColumns;
+ lastRenderedColumnsRef.current = columns;
return;
}
- if (lastRenderedColumnsRef.current === stableColumns) {
+ if (lastRenderedColumnsRef.current === columns) {
+ return;
+ }
+ lastRenderedColumnsRef.current = columns;
+
+ if (mode === RawMode.Raw) {
+ // In raw mode, re-render all messages directly to stdout at the new width.
+ // Use process.stdout.write instead of writeRef to avoid Ink interference.
+ process.stdout.write(ANSI_CLEAR_SCREEN);
+ const activeSessionId = sessionManager.getActiveSessionId();
+ const allMessages = activeSessionId ? loadVisibleMessages(sessionManager, activeSessionId) : [];
+ renderRawModeMessages(allMessages, mode);
return;
}
- lastRenderedColumnsRef.current = stableColumns;
// Force full redraw on terminal resize to avoid stale wrapped rows.
writeRef.current("\u001B[2J\u001B[H");
+
setMessages([]);
setShowWelcome(false);
setWelcomeNonce((n) => n + 1);
@@ -397,8 +595,10 @@ export function App({ projectRoot, version = "", initialPrompt, onRestart }: App
setMessages(nextMessages);
setShowWelcome(true);
}, 0);
- }, [busy, sessionManager, stableColumns, stdout]);
- const screenWidth = useMemo(() => stableColumns ?? stdout?.columns ?? 80, [stableColumns, stdout]);
+ }, [busy, mode, sessionManager, columns, stdout]);
+
+ const screenWidth = useMemo(() => columns ?? stdout?.columns ?? 80, [columns, stdout]);
+ const screenHeight = useMemo(() => rows ?? stdout?.rows ?? 24, [rows, stdout]);
const promptHistory = useMemo(() => {
return messages
.filter((message) => message.role === "user" && typeof message.content === "string")
@@ -413,7 +613,7 @@ export function App({ projectRoot, version = "", initialPrompt, onRestart }: App
// eslint-disable-next-line react-hooks/exhaustive-deps -- nowTick forces periodic recalculation for spinner animation
[busy, streamProgress, runningProcesses, nowTick]
);
- const welcomeSettings = resolvedSettings;
+
const welcomeItem: SessionMessage = useMemo(
() => ({
id: `__welcome__${welcomeNonce}`,
@@ -430,11 +630,14 @@ export function App({ projectRoot, version = "", initialPrompt, onRestart }: App
[welcomeNonce]
);
const staticItems = useMemo(() => {
+ if (mode === RawMode.Raw) {
+ return [];
+ }
if (showWelcome && view === "chat") {
return [welcomeItem, ...messages];
}
return messages;
- }, [showWelcome, view, messages, welcomeItem]);
+ }, [mode, showWelcome, view, messages, welcomeItem]);
const handleQuestionAnswers = useCallback(
(answers: AskUserQuestionAnswers) => {
@@ -453,6 +656,43 @@ export function App({ projectRoot, version = "", initialPrompt, onRestart }: App
setDismissedQuestionIds((prev) => new Set(prev).add(pendingQuestion.messageId));
}, [pendingQuestion]);
+ const handlePermissionResult = useCallback(
+ (result: PermissionPromptResult) => {
+ const sessionId = sessionManager.getActiveSessionId();
+ if (!sessionId) {
+ return;
+ }
+ if (result.hasDeny) {
+ setPendingPermissionReply({
+ sessionId,
+ permissions: result.permissions,
+ alwaysAllows: result.alwaysAllows,
+ });
+ setStatusLine("Permission denied. Add a reply, then press Enter to continue.");
+ return;
+ }
+ void handlePrompt({
+ text: "/continue",
+ imageUrls: [],
+ command: "continue",
+ permissions: result.permissions,
+ alwaysAllows: result.alwaysAllows,
+ });
+ },
+ [handlePrompt, sessionManager]
+ );
+
+ const handlePermissionCancel = useCallback(() => {
+ sessionManager.interruptActiveSession();
+ setActiveStatus("interrupted");
+ setActiveAskPermissions(undefined);
+ refreshSessionsList();
+ }, [refreshSessionsList, sessionManager]);
+
+ if (mode === RawMode.Raw) {
+ return handleRawModeChange(prev)} />;
+ }
+
return (
@@ -462,9 +702,8 @@ export function App({ projectRoot, version = "", initialPrompt, onRestart }: App
);
@@ -494,22 +733,53 @@ export function App({ projectRoot, version = "", initialPrompt, onRestart }: App
processStdoutRef={processStdoutRef}
runningProcesses={runningProcesses}
onDismiss={handleDismissProcessStdout}
+ onAdjustTimeout={handleAdjustBashTimeout}
screenWidth={screenWidth}
+ screenHeight={screenHeight}
/>
) : view === "session-list" ? (
void handleSelectSession(id)}
onCancel={() => setView("chat")}
+ onDelete={(id) => {
+ void handleDeleteSession(id);
+ }}
+ />
+ ) : view === "undo" ? (
+ void handleUndoRestore(target, restoreMode)}
+ onCancel={() => {
+ setView("chat");
+ setShowWelcome(true);
+ }}
/>
) : view === "mcp-status" ? (
- setView("chat")} />
+ setView("chat")}
+ onReconnect={(name) => {
+ const latest = resolveCurrentSettings(projectRoot);
+ void sessionManager.reconnectMcpServer(name, latest.mcpServers?.[name]);
+ }}
+ />
) : shouldShowQuestionPrompt && pendingQuestion && !busy ? (
+ ) : activeStatus === "ask_permission" &&
+ activeAskPermissions &&
+ activeAskPermissions.length > 0 &&
+ !pendingPermissionReply &&
+ !busy ? (
+
) : isExiting ? null : (
;
- machineId?: string;
-} {
- const settings = resolveCurrentSettings(projectRoot);
- if (!settings.apiKey) {
- return {
- client: null,
- model: settings.model,
- baseURL: settings.baseURL,
- thinkingEnabled: settings.thinkingEnabled,
- reasoningEffort: settings.reasoningEffort,
- debugLogEnabled: settings.debugLogEnabled,
- notify: settings.notify,
- webSearchTool: settings.webSearchTool,
- env: settings.env,
- machineId: getMachineId(),
- };
- }
-
- const client = new OpenAI({
- apiKey: settings.apiKey,
- baseURL: settings.baseURL || undefined,
- });
- return {
- client,
- model: settings.model,
- baseURL: settings.baseURL,
- thinkingEnabled: settings.thinkingEnabled,
- reasoningEffort: settings.reasoningEffort,
- debugLogEnabled: settings.debugLogEnabled,
- notify: settings.notify,
- webSearchTool: settings.webSearchTool,
- env: settings.env,
- machineId: getMachineId(),
- };
-}
-
-function getMachineId(): string | undefined {
- try {
- const idPath = path.join(os.homedir(), ".deepcode", "machine-id");
- if (fs.existsSync(idPath)) {
- const raw = fs.readFileSync(idPath, "utf8").trim();
- if (raw) {
- return raw;
- }
- }
- const generated = `${os.hostname()}-${Math.random().toString(36).slice(2)}-${Date.now()}`;
- fs.mkdirSync(path.dirname(idPath), { recursive: true });
- fs.writeFileSync(idPath, generated, "utf8");
- return generated;
- } catch {
- return undefined;
- }
-}
+export { createOpenAIClient } from "../common/openai-client";
function getUserSettingsPath(): string {
return path.join(os.homedir(), ".deepcode", "settings.json");
diff --git a/src/ui/AppContainer.tsx b/src/ui/AppContainer.tsx
new file mode 100644
index 0000000..c8b3177
--- /dev/null
+++ b/src/ui/AppContainer.tsx
@@ -0,0 +1,21 @@
+import React from "react";
+import { AppContext } from "./contexts";
+import App from "./App";
+import { RawModeProvider } from "./contexts/RawModeContext";
+
+const AppContainer: React.FC<{
+ projectRoot: string;
+ version: string;
+ initialPrompt: string | undefined;
+ onRestart: () => void;
+}> = ({ version, projectRoot, initialPrompt, onRestart }) => {
+ return (
+
+
+
+
+
+ );
+};
+
+export default AppContainer;
diff --git a/src/ui/McpStatusList.tsx b/src/ui/McpStatusList.tsx
index a09039d..095612a 100644
--- a/src/ui/McpStatusList.tsx
+++ b/src/ui/McpStatusList.tsx
@@ -5,9 +5,10 @@ import type { McpServerStatus } from "../mcp/mcp-manager";
type Props = {
statuses: McpServerStatus[];
onCancel: () => void;
+ onReconnect: (name: string) => void;
};
-export function McpStatusList({ statuses, onCancel }: Props): React.ReactElement {
+export function McpStatusList({ statuses, onCancel, onReconnect }: Props): React.ReactElement {
const { columns, rows } = useWindowSize();
// 视图模式：server-list（服务器列表） 或 server-detail（服务器详情）
@@ -20,10 +21,10 @@ export function McpStatusList({ statuses, onCancel }: Props): React.ReactElement
setViewMode("server-list");
}, []);
- // 进入服务器详情
+ // 进入服务器详情（允许 ready、failed、reconnecting 状态）
const enterDetail = useCallback(() => {
const server = statuses[selectedServerIndex];
- if (server && server.status === "ready") {
+ if (server && (server.status === "ready" || server.status === "failed" || server.status === "reconnecting")) {
setViewMode("server-detail");
}
}, [statuses, selectedServerIndex]);
@@ -59,6 +60,7 @@ export function McpStatusList({ statuses, onCancel }: Props): React.ReactElement
server={statuses[selectedServerIndex]}
onBack={goBack}
onCancel={onCancel}
+ onReconnect={onReconnect}
rows={rows}
columns={columns}
/>
@@ -173,6 +175,7 @@ function ServerListView({
const readyCount = statuses.filter((s) => s.status === "ready").length;
const startingCount = statuses.filter((s) => s.status === "starting").length;
+ const reconnectingCount = statuses.filter((s) => s.status === "reconnecting").length;
const failedCount = statuses.filter((s) => s.status === "failed").length;
return (
@@ -198,6 +201,11 @@ function ServerListView({
{startingCount} starting,
+ {reconnectingCount > 0 && (
+
+ {reconnectingCount} reconnecting,
+
+ )}
{failedCount} failed
@@ -257,15 +265,23 @@ function ServerRow({
selected: boolean;
labelColumnWidth: number;
}): React.ReactElement {
- const icon = status.status === "ready" ? "✓" : status.status === "failed" ? "✗" : "●";
- const color = status.status === "ready" ? "green" : status.status === "failed" ? "red" : "yellow";
+ const icon =
+ status.status === "ready" ? "✓" : status.status === "failed" ? "✗" : status.status === "reconnecting" ? "↻" : "●";
+ const color =
+ status.status === "ready"
+ ? "green"
+ : status.status === "failed"
+ ? "red"
+ : status.status === "reconnecting"
+ ? "#ff9900"
+ : "yellow";
// 加载动画：循环显示 (空) → . → .. → ... → (空) → ...
const [dots, setDots] = React.useState(0);
React.useEffect(() => {
- if (status.status !== "starting") return;
+ if (status.status !== "starting" && status.status !== "reconnecting") return;
const interval = setInterval(() => {
- setDots((d) => (d + 1) % 4); // 0 → 1 → 2 → 3 → 0 ...
+ setDots((d) => (d + 1) % 4);
}, 500);
return () => clearInterval(interval);
}, [status.status]);
@@ -275,7 +291,9 @@ function ServerRow({
? `Ready (${status.toolCount} tools, ${status.promptCount} prompts, ${status.resourceCount} resources)`
: status.status === "failed"
? `Failed`
- : "Starting" + (dots > 0 ? ".".repeat(dots) : " "); // 动态显示 (空) / . / .. / ...
+ : status.status === "reconnecting"
+ ? `Reconnecting${dots > 0 ? ".".repeat(dots) : " "}`
+ : "Starting" + (dots > 0 ? ".".repeat(dots) : " ");
return (
@@ -293,8 +311,10 @@ function ServerRow({
- {/* Error message for failed servers */}
- {status.status === "failed" && status.error ? : null}
+ {/* Error message for failed or reconnecting servers */}
+ {(status.status === "failed" || status.status === "reconnecting") && status.error ? (
+
+ ) : null}
);
}
@@ -304,59 +324,54 @@ function ServerDetailView({
server,
onBack,
onCancel,
+ onReconnect,
rows,
columns,
}: {
server: McpServerStatus;
onBack: () => void;
onCancel: () => void;
+ onReconnect: (name: string) => void;
rows: number;
columns: number;
}): React.ReactElement {
- const [activeIndex, setActiveIndex] = useState(0);
+ const [activeIndex, setActiveIndex] = React.useState(0);
+ const hasReconnect = server.status === "failed";
+ const canScroll = server.status === "ready";
- // 合并所有 items（tools, prompts, resources）
+ // 合并所有 items（tools, prompts, resources）+ Reconnect 选项
const allItems = useMemo(() => {
const items: { type: string; name: string }[] = [];
+ if (hasReconnect) {
+ items.push({ type: "action", name: "Reconnect" });
+ }
server.tools.forEach((tool) => items.push({ type: "tool", name: tool }));
server.prompts.forEach((prompt) => items.push({ type: "prompt", name: prompt }));
server.resources.forEach((resource) => items.push({ type: "resource", name: resource }));
return items;
- }, [server]);
+ }, [server, hasReconnect]);
const totalItems = allItems.length;
const maxVisible = useMemo(() => {
- const reservedLines = 10; // header + title + stats + footer + borders
+ const reservedLines = 12; // header + title + stats + error + footer + borders
const availableLines = Math.max(0, Math.min(rows, 30) - reservedLines);
return Math.max(1, availableLines);
}, [rows]);
- // 使用 ref 跟踪 visibleStart，避免循环依赖
const visibleStartRef = React.useRef(0);
- // 计算可见窗口起始位置：当 activeIndex 超出可见区域时才滚动（类似终端光标行为）
const visibleStart = useMemo(() => {
if (totalItems === 0) return 0;
-
const currentStart = visibleStartRef.current;
let newStart = currentStart;
-
- // 如果 activeIndex 在当前可见窗口之前，滚动到 activeIndex
if (activeIndex < currentStart) {
newStart = activeIndex;
- }
- // 如果 activeIndex 在当前可见窗口之后，滚动到 activeIndex
- else if (activeIndex >= currentStart + maxVisible) {
+ } else if (activeIndex >= currentStart + maxVisible) {
newStart = activeIndex - maxVisible + 1;
}
-
- // 限制在合法范围内
newStart = Math.max(0, Math.min(newStart, Math.max(0, totalItems - maxVisible)));
-
- // 更新 ref
visibleStartRef.current = newStart;
-
return newStart;
}, [activeIndex, maxVisible, totalItems]);
@@ -371,11 +386,16 @@ function ServerDetailView({
onBack();
return;
}
- // Space 或 Enter 键返回一级菜单
- if (input === " " || key.return) {
+ if (key.return || input === " ") {
+ if (activeIndex === 0 && hasReconnect) {
+ onReconnect(server.name);
+ onBack();
+ return;
+ }
onBack();
return;
}
+ if (!canScroll && !hasReconnect) return;
if (key.upArrow) {
setActiveIndex((prev) => Math.max(0, prev - 1));
return;
@@ -384,25 +404,33 @@ function ServerDetailView({
setActiveIndex((prev) => Math.min(totalItems - 1, prev + 1));
return;
}
- if (key.pageUp) {
+ if (key.pageUp && canScroll) {
setActiveIndex((prev) => Math.max(0, prev - maxVisible));
return;
}
- if (key.pageDown) {
+ if (key.pageDown && canScroll) {
setActiveIndex((prev) => Math.min(totalItems - 1, prev + maxVisible));
return;
}
- if (key.home) {
+ if (key.home && canScroll) {
setActiveIndex(0);
return;
}
- if (key.end) {
+ if (key.end && canScroll) {
setActiveIndex(totalItems - 1);
}
});
- const icon = "✓";
- const color = "green";
+ const statusIcon =
+ server.status === "ready" ? "✓" : server.status === "failed" ? "✗" : server.status === "reconnecting" ? "↻" : "●";
+ const statusColor =
+ server.status === "ready"
+ ? "green"
+ : server.status === "failed"
+ ? "red"
+ : server.status === "reconnecting"
+ ? "#ff9900"
+ : "yellow";
return (
{/* Header row */}
- {icon}
+ {statusIcon}
{server.name}
- — Details
+ — {server.status === "ready" ? "Details" : "Status"}
{/* Server info */}
- {server.toolCount} tools, {server.promptCount} prompts, {server.resourceCount} resources
+ {server.status === "ready"
+ ? `${server.toolCount} tools, ${server.promptCount} prompts, ${server.resourceCount} resources`
+ : `Status: ${server.status}`}
+ {/* Error for failed/reconnecting */}
+ {server.error && (server.status === "failed" || server.status === "reconnecting") ? (
+
+
+
+ ) : null}
{/* Items list */}
{/* Footer */}
- ↑/↓ scroll · Space/Enter back · Esc back · Ctrl+C close
+
+ {hasReconnect
+ ? "Enter to reconnect · Esc back · Ctrl+C close"
+ : canScroll
+ ? "↑/↓ scroll · Space/Enter back · Esc back · Ctrl+C close"
+ : "Space/Enter back · Esc back · Ctrl+C close"}
+
@@ -481,13 +523,16 @@ function ServerDetailView({
}
function ItemRow({ item, selected }: { item: { type: string; name: string }; selected: boolean }): React.ReactElement {
- const icon = item.type === "tool" ? "🔧" : item.type === "prompt" ? "📝" : "📦";
+ const isAction = item.type === "action";
+ const icon = isAction ? "↻" : item.type === "tool" ? "🔧" : item.type === "prompt" ? "📝" : "📦";
+ const color = isAction && selected ? "#ff9900" : selected ? "#229ac3" : undefined;
return (
+ {selected ? "> " : " "}
{icon}
-
- {item.name}
+
+ {isAction ? `[${item.name}]` : item.name}
);
diff --git a/src/ui/MessageView.tsx b/src/ui/MessageView.tsx
deleted file mode 100644
index 6f388d0..0000000
--- a/src/ui/MessageView.tsx
+++ /dev/null
@@ -1,386 +0,0 @@
-import React from "react";
-import { Box, Text } from "ink";
-import { renderMarkdown } from "./markdown";
-import type { SessionMessage } from "../session";
-
-type Props = {
- message: SessionMessage;
- collapsed?: boolean;
- width?: number;
-};
-
-export function MessageView({ message, collapsed, width = 80 }: Props): React.ReactElement | null {
- if (!message.visible) {
- return null;
- }
-
- if (message.role === "user") {
- const text = message.content || "(no content)";
- return (
-
-
- {`>`}
-
-
- {text}
- {Array.isArray(message.contentParams) && message.contentParams.length > 0 ? (
- {` 📎 ${message.contentParams.length} image attachment(s)`}
- ) : null}
-
-
- );
- }
-
- if (message.role === "assistant") {
- const isThinking = Boolean(message.meta?.asThinking);
- const content = (message.content || "").trim();
-
- if (isThinking) {
- const summary = buildThinkingSummary(content, message.messageParams);
- if (collapsed !== false) {
- return (
-
-
-
- );
- }
- return (
-
-
-
- {content ? {renderMarkdown(content)} : null}
-
-
- );
- }
-
- const containerWidth = Math.max(1, width - 2);
- const contentWidth = Math.max(1, width - 4);
-
- return (
-
-
- ✦
-
-
- {content ? {renderMarkdown(content)} : null}
-
-
- );
- }
-
- if (message.role === "tool") {
- const summary = buildToolSummary(message);
- const diffLines = getToolDiffPreviewLines(summary);
- const planLines = getUpdatePlanPreviewLines(summary);
- return (
-
-
- {diffLines.length > 0 ? : null}
- {planLines.length > 0 ? : null}
-
- );
- }
-
- if (message.role === "system") {
- // Render model change messages in the same style as user commands.
- if (message.meta?.isModelChange) {
- return (
-
-
- {`>`}
-
-
- {message.content}
-
-
- );
- }
-
- if (message.meta?.skill) {
- return (
-
- ⚡ Loaded skill: {message.meta.skill.name}
-
- );
- }
- if (message.meta?.isSummary) {
- return (
-
-
- (conversation summary inserted)
-
-
- );
- }
- return null;
- }
-
- return null;
-}
-
-function StatusLine({
- bulletColor,
- name,
- params,
-}: {
- bulletColor: "gray" | "green" | "red";
- name: string;
- params: string;
-}): React.ReactElement {
- return (
-
- {[
-
- ✧
- ,
- " ",
-
- {name}
- ,
- params ? {` ${params}`} : null,
- ]}
-
- );
-}
-
-function formatToolStatusParams(summary: ToolSummary): string {
- const params = firstNonEmptyLine(summary.params);
- return summary.name.toLowerCase() === "bash" ? params : truncate(params, 120);
-}
-
-type ToolSummary = {
- name: string;
- params: string;
- ok: boolean;
- metadata: Record | null;
-};
-
-type DiffPreviewLine = {
- marker: string;
- content: string;
- kind: "added" | "removed" | "context";
-};
-
-function buildToolSummary(message: SessionMessage): ToolSummary {
- const payload = parseToolPayload(message.content);
- const metaFunctionName =
- message.meta?.function && typeof (message.meta.function as { name?: unknown }).name === "string"
- ? (message.meta.function as { name: string }).name
- : null;
- const name = payload.name || metaFunctionName || "tool";
- const params =
- name === "AskUserQuestion"
- ? extractAskUserQuestionParams(message) || getMetaParams(message)
- : getMetaParams(message);
-
- return {
- name,
- params,
- ok: payload.ok !== false,
- metadata: payload.metadata,
- };
-}
-
-function getMetaParams(message: SessionMessage): string {
- return typeof message.meta?.paramsMd === "string" ? message.meta.paramsMd.trim() : "";
-}
-
-function extractAskUserQuestionParams(message: SessionMessage): string {
- const fromFunction = extractQuestionsFromToolFunction(message.meta?.function);
- if (fromFunction) {
- return fromFunction;
- }
-
- const params = getMetaParams(message);
- if (!params) {
- return "";
- }
-
- try {
- const parsed = JSON.parse(params);
- return extractQuestionsFromValue(parsed);
- } catch {
- return "";
- }
-}
-
-function extractQuestionsFromToolFunction(toolFunction: unknown): string {
- if (!toolFunction || typeof toolFunction !== "object") {
- return "";
- }
- const args = (toolFunction as { arguments?: unknown }).arguments;
- if (typeof args !== "string" || !args.trim()) {
- return "";
- }
- try {
- const parsed = JSON.parse(args);
- return extractQuestionsFromValue((parsed as { questions?: unknown })?.questions);
- } catch {
- return "";
- }
-}
-
-function extractQuestionsFromValue(value: unknown): string {
- if (!Array.isArray(value)) {
- return "";
- }
- return value
- .map((item) => {
- if (!item || typeof item !== "object" || Array.isArray(item)) {
- return "";
- }
- return typeof (item as { question?: unknown }).question === "string"
- ? (item as { question: string }).question.trim()
- : "";
- })
- .filter(Boolean)
- .join(" / ");
-}
-
-function parseToolPayload(content: string | null): {
- name: string | null;
- ok: boolean;
- metadata: Record | null;
-} {
- if (!content) {
- return { name: null, ok: true, metadata: null };
- }
-
- try {
- const parsed = JSON.parse(content) as { name?: unknown; ok?: unknown; metadata?: unknown };
- return {
- name: typeof parsed.name === "string" && parsed.name.trim() ? parsed.name.trim() : null,
- ok: parsed.ok !== false,
- metadata: isPlainRecord(parsed.metadata) ? parsed.metadata : null,
- };
- } catch {
- return { name: null, ok: true, metadata: null };
- }
-}
-
-function getToolDiffPreviewLines(summary: ToolSummary): DiffPreviewLine[] {
- if (!summary.ok || !["edit", "write"].includes(summary.name.toLowerCase())) {
- return [];
- }
- const diffPreview = summary.metadata?.diff_preview;
- if (typeof diffPreview !== "string" || !diffPreview.trim()) {
- return [];
- }
- return parseDiffPreview(diffPreview);
-}
-
-function getUpdatePlanPreviewLines(summary: ToolSummary): string[] {
- if (!summary.ok || summary.name !== "UpdatePlan") {
- return [];
- }
- const plan = summary.metadata?.plan;
- if (typeof plan !== "string" || !plan.trim()) {
- return [];
- }
- return plan
- .split(/\r?\n/)
- .map((line) => line.trimEnd())
- .filter((line) => line.trim().length > 0);
-}
-
-export function parseDiffPreview(diffPreview: string): DiffPreviewLine[] {
- return diffPreview
- .split("\n")
- .filter((line) => line && !line.startsWith("--- ") && !line.startsWith("+++ ") && !line.startsWith("@@ "))
- .map((line) => {
- if (line.startsWith("+")) {
- return { marker: "+", content: line.slice(1), kind: "added" };
- }
- if (line.startsWith("-")) {
- return { marker: "-", content: line.slice(1), kind: "removed" };
- }
- return {
- marker: " ",
- content: line.startsWith(" ") ? line.slice(1) : line,
- kind: "context",
- };
- });
-}
-
-function DiffPreview({ lines }: { lines: DiffPreviewLine[] }): React.ReactElement {
- return (
-
- └ Changes
-
- {lines.map((line, index) => (
-
-
- {line.marker}
-
-
- {line.content}
-
-
- ))}
-
-
- );
-}
-
-function PlanPreview({ lines }: { lines: string[] }): React.ReactElement {
- return (
-
- └ Plan
-
- {lines.map((line, index) => (
-
- {line}
-
- ))}
-
-
- );
-}
-
-function isPlainRecord(value: unknown): value is Record {
- return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-
-function formatStatusName(value: string): string {
- return value ? `${value.charAt(0).toUpperCase()}${value.slice(1)}` : "Tool";
-}
-
-function truncate(value: string, max: number): string {
- if (value.length <= max) {
- return value;
- }
- return `${value.slice(0, max)}…`;
-}
-
-function firstNonEmptyLine(value: string): string {
- for (const line of value.split(/\r?\n/)) {
- const trimmed = line.trim().replace(/\s+/g, " ");
- if (trimmed) {
- return trimmed;
- }
- }
- return "";
-}
-
-function buildThinkingSummary(content: string, messageParams: unknown | null): string {
- if (content) {
- const normalized = content.replace(/\r?\n/g, " ").replace(/\s+/g, " ");
- let result = truncate(normalized, 100);
- if (result.endsWith(":") || result.endsWith("：")) {
- result = result.slice(0, -1);
- }
- return result;
- }
-
- const params = messageParams as { reasoning_content?: unknown } | null | undefined;
- if (typeof params?.reasoning_content === "string" && params.reasoning_content.trim()) {
- return "(reasoning...)";
- }
-
- return "";
-}
diff --git a/src/ui/PermissionPrompt.tsx b/src/ui/PermissionPrompt.tsx
new file mode 100644
index 0000000..03881a5
--- /dev/null
+++ b/src/ui/PermissionPrompt.tsx
@@ -0,0 +1,274 @@
+import React, { useEffect, useMemo, useState } from "react";
+import { Box, Text } from "ink";
+import type { AskPermissionRequest, AskPermissionScope, PermissionScope, UserToolPermission } from "../session";
+import { useTerminalInput } from "./PromptInput";
+
+export type PermissionPromptResult = {
+ permissions: UserToolPermission[];
+ alwaysAllows: PermissionScope[];
+ hasDeny: boolean;
+};
+
+type Props = {
+ requests: AskPermissionRequest[];
+ onSubmit: (result: PermissionPromptResult) => void;
+ onCancel: () => void;
+};
+
+type ScopePrompt = {
+ request: AskPermissionRequest;
+ scope: AskPermissionScope;
+};
+
+type PromptOption = {
+ kind: "allow" | "always" | "deny";
+ label: string;
+ scopeDescription?: string;
+ scopeColor?: string;
+};
+
+const ALWAYS_ALLOWED_SCOPES = new Set([
+ "read-in-cwd",
+ "read-out-cwd",
+ "write-in-cwd",
+ "write-out-cwd",
+ "delete-in-cwd",
+ "delete-out-cwd",
+ "query-git-log",
+ "mutate-git-log",
+ "network",
+ "mcp",
+]);
+
+export function PermissionPrompt({ requests, onSubmit, onCancel }: Props): React.ReactElement | null {
+ const prompts = useMemo(() => buildScopePrompts(requests), [requests]);
+ const [index, setIndex] = useState(0);
+ const [cursor, setCursor] = useState(0);
+ const [decisions, setDecisions] = useState>({});
+ const [alwaysAllows, setAlwaysAllows] = useState([]);
+
+ const effectiveIndex = findNextPromptIndex(prompts, index, alwaysAllows);
+ const prompt = prompts[effectiveIndex] ?? null;
+ const options = prompt ? buildOptions(prompt.scope) : [];
+
+ useEffect(() => {
+ setIndex(0);
+ setCursor(0);
+ setDecisions({});
+ setAlwaysAllows([]);
+ }, [requests]);
+
+ useEffect(() => {
+ if (!prompt) {
+ onSubmit(buildResult(requests, decisions, alwaysAllows));
+ }
+ }, [alwaysAllows, decisions, onSubmit, prompt, requests]);
+
+ useEffect(() => {
+ if (cursor >= options.length) {
+ setCursor(Math.max(0, options.length - 1));
+ }
+ }, [cursor, options.length]);
+
+ useTerminalInput((input, key) => {
+ if (!prompt) {
+ return;
+ }
+ if (key.escape || (key.ctrl && (input === "c" || input === "C"))) {
+ onCancel();
+ return;
+ }
+ if (key.upArrow) {
+ setCursor((value) => Math.max(0, value - 1));
+ return;
+ }
+ if (key.downArrow) {
+ setCursor((value) => Math.min(options.length - 1, value + 1));
+ return;
+ }
+ if (input && /^[1-3]$/.test(input)) {
+ const nextCursor = Number(input) - 1;
+ if (nextCursor >= 0 && nextCursor < options.length) {
+ commit(options[nextCursor]!.kind);
+ }
+ return;
+ }
+ if (key.return) {
+ commit(options[cursor]?.kind ?? "allow");
+ }
+ });
+
+ if (!prompt) {
+ return null;
+ }
+
+ function commit(kind: "allow" | "always" | "deny"): void {
+ if (!prompt) {
+ return;
+ }
+ if (kind === "always" && isAlwaysAllowedScope(prompt.scope)) {
+ const scope = prompt.scope;
+ setAlwaysAllows((prev) => (prev.includes(scope) ? prev : [...prev, scope]));
+ setDecisions((prev) => ({
+ ...prev,
+ [prompt.request.toolCallId]: prev[prompt.request.toolCallId] === "deny" ? "deny" : "allow",
+ }));
+ } else {
+ setDecisions((prev) => ({
+ ...prev,
+ [prompt.request.toolCallId]:
+ kind === "deny" ? "deny" : prev[prompt.request.toolCallId] === "deny" ? "deny" : "allow",
+ }));
+ }
+ setIndex(effectiveIndex + 1);
+ setCursor(0);
+ }
+
+ return (
+
+
+
+ Permission required
+
+
+ {" "}
+ {Math.min(effectiveIndex + 1, prompts.length)}/{prompts.length}
+
+
+ {prompt.request.name}
+ {prompt.request.command}
+ {prompt.request.description ? {prompt.request.description} : null}
+
+ Do you want to proceed?
+
+
+ {options.map((option, optionIndex) => (
+
+ {optionIndex === cursor ? "> " : " "}
+ {optionIndex + 1}. {renderOptionLabel(option)}
+
+ ))}
+
+
+ ↑/↓ move · Enter select · Esc interrupt
+
+
+ );
+}
+
+function renderOptionLabel(option: PromptOption): React.ReactNode {
+ if (option.scopeDescription && option.scopeColor) {
+ return (
+ <>
+ {option.label}
+ {option.scopeDescription}
+
+ );
+ }
+ return option.label;
+}
+
+function buildScopePrompts(requests: AskPermissionRequest[]): ScopePrompt[] {
+ const prompts: ScopePrompt[] = [];
+ for (const request of requests) {
+ for (const scope of request.scopes.length > 0 ? request.scopes : ["unknown" as const]) {
+ prompts.push({ request, scope });
+ }
+ }
+ return prompts;
+}
+
+function buildOptions(scope: AskPermissionScope): PromptOption[] {
+ const options: PromptOption[] = [{ kind: "allow", label: "Yes" }];
+ if (isAlwaysAllowedScope(scope)) {
+ options.push({
+ kind: "always",
+ label: "Yes, and always allow ",
+ scopeDescription: describeScope(scope),
+ scopeColor: getScopeRiskColor(scope),
+ });
+ }
+ options.push({ kind: "deny", label: "No" });
+ return options;
+}
+
+function findNextPromptIndex(prompts: ScopePrompt[], startIndex: number, alwaysAllows: PermissionScope[]): number {
+ let index = startIndex;
+ while (index < prompts.length) {
+ const scope = prompts[index]!.scope;
+ if (isAlwaysAllowedScope(scope) && alwaysAllows.includes(scope)) {
+ index += 1;
+ continue;
+ }
+ return index;
+ }
+ return prompts.length;
+}
+
+function buildResult(
+ requests: AskPermissionRequest[],
+ decisions: Record,
+ alwaysAllows: PermissionScope[]
+): PermissionPromptResult {
+ const permissions = requests.map((request) => ({
+ toolCallId: request.toolCallId,
+ permission: decisions[request.toolCallId] === "deny" ? ("deny" as const) : ("allow" as const),
+ }));
+ return {
+ permissions,
+ alwaysAllows,
+ hasDeny: permissions.some((permission) => permission.permission === "deny"),
+ };
+}
+
+function isAlwaysAllowedScope(scope: AskPermissionScope): scope is PermissionScope {
+ return ALWAYS_ALLOWED_SCOPES.has(scope);
+}
+
+export function getScopeRiskColor(scope: AskPermissionScope): string {
+ switch (scope) {
+ case "read-in-cwd":
+ case "query-git-log":
+ return "#22c55e";
+ case "read-out-cwd":
+ case "write-in-cwd":
+ case "network":
+ case "mcp":
+ return "#f59e0b";
+ case "write-out-cwd":
+ case "delete-in-cwd":
+ case "delete-out-cwd":
+ case "mutate-git-log":
+ case "unknown":
+ return "#ef4444";
+ default:
+ return "#ef4444";
+ }
+}
+
+function describeScope(scope: PermissionScope): string {
+ switch (scope) {
+ case "read-in-cwd":
+ return "reads inside this workspace";
+ case "read-out-cwd":
+ return "reads outside this workspace";
+ case "write-in-cwd":
+ return "writes inside this workspace";
+ case "write-out-cwd":
+ return "writes outside this workspace";
+ case "delete-in-cwd":
+ return "deletes inside this workspace";
+ case "delete-out-cwd":
+ return "deletes outside this workspace";
+ case "query-git-log":
+ return "Git history queries";
+ case "mutate-git-log":
+ return "Git history changes";
+ case "network":
+ return "network access";
+ case "mcp":
+ return "MCP tool access";
+ default:
+ return scope;
+ }
+}
diff --git a/src/ui/ProcessStdoutView.tsx b/src/ui/ProcessStdoutView.tsx
index a0676c6..bc76a2f 100644
--- a/src/ui/ProcessStdoutView.tsx
+++ b/src/ui/ProcessStdoutView.tsx
@@ -1,6 +1,7 @@
import React, { useEffect, useMemo, useRef, useState } from "react";
import { Box, Text } from "ink";
-import type { SessionEntry } from "../session";
+import { BASH_TIMEOUT_DECREMENT_MS, BASH_TIMEOUT_INCREMENT_MS } from "../common/bash-timeout";
+import type { BashTimeoutAdjustment, SessionEntry, SessionProcessEntry } from "../session";
import { useTerminalInput } from "./prompt";
type RunningProcesses = SessionEntry["processes"];
@@ -9,21 +10,31 @@ type ProcessStdoutViewProps = {
processStdoutRef: React.MutableRefObject>;
runningProcesses: RunningProcesses;
onDismiss: () => void;
+ onAdjustTimeout: (deltaMs: number) => BashTimeoutAdjustment | null;
screenWidth: number;
+ screenHeight: number;
};
const REFRESH_INTERVAL_MS = 150;
-const MAX_VISIBLE_LINES = 100;
+const MAX_PANEL_HEIGHT = 30;
+const MIN_PANEL_HEIGHT = 5;
export const ProcessStdoutView = React.memo(function ProcessStdoutView({
processStdoutRef,
runningProcesses,
onDismiss,
+ onAdjustTimeout,
screenWidth,
+ screenHeight,
}: ProcessStdoutViewProps): React.ReactElement {
const [stdoutText, setStdoutText] = useState("");
const [scrollOffset, setScrollOffset] = useState(0);
- const containerRef = useRef<{ lineCount: number }>({ lineCount: 0 });
+ const [statusMessage, setStatusMessage] = useState("");
+ const statusTimerRef = useRef | null>(null);
+
+ const panelHeight = Math.max(MIN_PANEL_HEIGHT, Math.min(screenHeight - 1, MAX_PANEL_HEIGHT));
+ const reservedRows = statusMessage ? 2 : 1;
+ const visibleLineLimit = Math.max(1, panelHeight - reservedRows);
useEffect(() => {
const updateStdout = () => {
@@ -51,21 +62,37 @@ export const ProcessStdoutView = React.memo(function ProcessStdoutView({
return () => clearInterval(interval);
}, [processStdoutRef, runningProcesses]);
- // Update container line count for scroll awareness
+ useEffect(() => {
+ return () => {
+ if (statusTimerRef.current) {
+ clearTimeout(statusTimerRef.current);
+ }
+ };
+ }, []);
+
const lines = useMemo(() => stdoutText.split("\n"), [stdoutText]);
- containerRef.current.lineCount = lines.length;
+ const timeoutProcess = useMemo(() => getLatestTimeoutProcess(runningProcesses), [runningProcesses]);
const visibleLines = useMemo(() => {
- if (lines.length <= MAX_VISIBLE_LINES) {
+ if (lines.length <= visibleLineLimit) {
return lines;
}
- const start = Math.max(0, lines.length - MAX_VISIBLE_LINES - scrollOffset);
- const slice = lines.slice(start, start + MAX_VISIBLE_LINES);
- if (lines.length > MAX_VISIBLE_LINES) {
+ const outputLineLimit = Math.max(1, visibleLineLimit - 1);
+ const start = Math.max(0, lines.length - outputLineLimit - scrollOffset);
+ const slice = lines.slice(start, start + outputLineLimit);
+ if (lines.length > visibleLineLimit) {
slice.unshift(`... (${start} lines above · ↑/↓ to scroll · ${lines.length} total lines) ...`);
}
return slice;
- }, [lines, scrollOffset]);
+ }, [lines, scrollOffset, visibleLineLimit]);
+
+ const setTemporaryStatus = (message: string) => {
+ setStatusMessage(message);
+ if (statusTimerRef.current) {
+ clearTimeout(statusTimerRef.current);
+ }
+ statusTimerRef.current = setTimeout(() => setStatusMessage(""), 2000);
+ };
useTerminalInput(
(input, key) => {
@@ -73,8 +100,18 @@ export const ProcessStdoutView = React.memo(function ProcessStdoutView({
onDismiss();
return;
}
+ if (input === "+") {
+ const adjustment = onAdjustTimeout(BASH_TIMEOUT_INCREMENT_MS);
+ setTemporaryStatus(formatAdjustmentStatus(adjustment));
+ return;
+ }
+ if (input === "-") {
+ const adjustment = onAdjustTimeout(-BASH_TIMEOUT_DECREMENT_MS);
+ setTemporaryStatus(formatAdjustmentStatus(adjustment));
+ return;
+ }
if (key.upArrow) {
- setScrollOffset((s) => Math.min(s + 10, Math.max(0, lines.length - MAX_VISIBLE_LINES)));
+ setScrollOffset((s) => Math.min(s + 10, Math.max(0, lines.length - visibleLineLimit)));
return;
}
if (key.downArrow) {
@@ -82,11 +119,11 @@ export const ProcessStdoutView = React.memo(function ProcessStdoutView({
return;
}
if (key.pageUp) {
- setScrollOffset((s) => Math.min(s + MAX_VISIBLE_LINES, Math.max(0, lines.length - MAX_VISIBLE_LINES)));
+ setScrollOffset((s) => Math.min(s + visibleLineLimit, Math.max(0, lines.length - visibleLineLimit)));
return;
}
if (key.pageDown) {
- setScrollOffset((s) => Math.max(s - MAX_VISIBLE_LINES, 0));
+ setScrollOffset((s) => Math.max(s - visibleLineLimit, 0));
return;
}
},
@@ -94,16 +131,58 @@ export const ProcessStdoutView = React.memo(function ProcessStdoutView({
);
return (
-
+
📟 Process Output
- (Ctrl+O or Esc to close · ↑↓ PageUp/PageDown to scroll)
+ {` (${formatTimeoutHint(
+ timeoutProcess?.entry
+ )} · +/- adjust · Ctrl+O or Esc to close · ↑↓ PageUp/PageDown to scroll)`}
-
+
{visibleLines.map((line, index) => (
{line}
))}
+ {statusMessage ? (
+
+ {statusMessage}
+
+ ) : null}
);
});
+
+function getLatestTimeoutProcess(
+ runningProcesses: RunningProcesses
+): { pid: string; entry: SessionProcessEntry } | null {
+ if (!runningProcesses) {
+ return null;
+ }
+ let latest: { pid: string; entry: SessionProcessEntry } | null = null;
+ for (const [pid, entry] of runningProcesses.entries()) {
+ if (typeof entry.timeoutMs !== "number") {
+ continue;
+ }
+ latest = { pid, entry };
+ }
+ return latest;
+}
+
+function formatTimeoutHint(entry?: SessionProcessEntry): string {
+ if (!entry || typeof entry.timeoutMs !== "number") {
+ return "timeout unavailable";
+ }
+ return `timeout ${formatDuration(entry.timeoutMs)}`;
+}
+
+function formatAdjustmentStatus(adjustment: BashTimeoutAdjustment | null): string {
+ if (!adjustment) {
+ return "No adjustable Bash timeout";
+ }
+ return `Timeout set to ${formatDuration(adjustment.timeoutMs)}`;
+}
+
+function formatDuration(ms: number): string {
+ const totalMinutes = Math.max(1, Math.round(ms / 60000));
+ return `${totalMinutes}m`;
+}
diff --git a/src/ui/PromptInput.tsx b/src/ui/PromptInput.tsx
index 0387ceb..8c808e9 100644
--- a/src/ui/PromptInput.tsx
+++ b/src/ui/PromptInput.tsx
@@ -1,13 +1,21 @@
import React, { useEffect, useMemo, useState } from "react";
import { Box, Text, useApp, useStdout } from "ink";
import chalk from "chalk";
+import { ARGS_SEPARATOR } from "./constants";
import {
EMPTY_BUFFER,
+ PASTE_MARKER_REGEX,
backspace,
+ cleanPasteContent,
deleteForward,
+ deletePasteMarkerBackward,
+ deletePasteMarkerForward,
deleteWordBefore,
deleteWordAfter,
+ expandPasteMarkers,
+ findPasteMarkerContaining,
getCurrentSlashToken,
+ hasActivePasteMarkers,
insertText,
isEmpty,
killLine,
@@ -38,24 +46,37 @@ import {
} from "./fileMentions";
import type { FileMentionItem } from "./fileMentions";
import { readClipboardImageAsync } from "./clipboard";
-import type { SkillInfo } from "../session";
+import type { PermissionScope, SessionEntry, SkillInfo, UserToolPermission } from "../session";
// Re-exported from prompt modules for backward compatibility
-export { useTerminalInput, parseTerminalInput } from "./prompt";
+export { useTerminalInput, parseTerminalInput, dispatchTerminalInput } from "./prompt";
export type { InputKey } from "./prompt";
import { useTerminalInput } from "./prompt";
import type { InputKey } from "./prompt";
-import { useHiddenTerminalCursor, useTerminalExtendedKeys, useTerminalFocusReporting } from "./prompt";
-import SlashCommandMenu from "./SlashCommandMenu";
-import type { ModelConfigSelection, ReasoningEffort } from "../settings";
-import DropdownMenu from "./DropdownMenu";
+import {
+ useHiddenTerminalCursor,
+ useTerminalExtendedKeys,
+ useBracketedPaste,
+ useTerminalFocusReporting,
+} from "./prompt";
+import SlashCommandMenu, { isSkillSelected } from "./SlashCommandMenu";
+import type { ModelConfigSelection } from "../settings";
+import { FileMentionMenu, ModelsDropdown, RawModelDropdown, SkillsDropdown } from "./components";
export type PromptSubmission = {
text: string;
imageUrls: string[];
selectedSkills?: SkillInfo[];
- command?: "new" | "resume" | "continue" | "mcp" | "exit";
+ permissions?: UserToolPermission[];
+ alwaysAllows?: PermissionScope[];
+ command?: "new" | "resume" | "continue" | "undo" | "mcp" | "exit";
+};
+
+export type PromptDraft = {
+ nonce: number;
+ text: string;
+ imageUrls: string[];
};
type Props = {
@@ -68,29 +89,16 @@ type Props = {
loadingText?: string | null;
disabled?: boolean;
placeholder?: string;
- runningProcesses?: Map | null;
+ runningProcesses?: SessionEntry["processes"];
+ promptDraft?: PromptDraft | null;
onSubmit: (submission: PromptSubmission) => void;
onModelConfigChange: (selection: ModelConfigSelection) => string | Promise;
+ onRawModeChange?: (mode: string) => void;
onInterrupt: () => void;
onToggleProcessStdout?: () => void;
};
const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-export const MODEL_COMMAND_MODELS = ["deepseek-v4-pro", "deepseek-v4-flash"] as const;
-
-type ThinkingModeOption = {
- label: string;
- thinkingEnabled: boolean;
- reasoningEffort?: ReasoningEffort;
-};
-
-export const MODEL_COMMAND_THINKING_OPTIONS: ThinkingModeOption[] = [
- { label: "Thinking mode [max]", thinkingEnabled: true, reasoningEffort: "max" },
- { label: "Thinking mode [high]", thinkingEnabled: true, reasoningEffort: "high" },
- { label: "No thinking", thinkingEnabled: false },
-];
-
-type ModelDropdownStep = "model" | "thinking";
const PromptPrefixLine = React.memo(function PromptPrefixLine({ busy }: { busy: boolean }): React.ReactElement {
const [spinnerIndex, setSpinnerIndex] = useState(0);
@@ -121,10 +129,12 @@ export const PromptInput = React.memo(function PromptInput({
disabled,
placeholder,
runningProcesses,
+ promptDraft,
onSubmit,
onModelConfigChange,
onInterrupt,
onToggleProcessStdout,
+ onRawModeChange,
}: Props): React.ReactElement {
const { exit } = useApp();
const { stdout } = useStdout();
@@ -135,12 +145,9 @@ export const PromptInput = React.memo(function PromptInput({
const [pendingExit, setPendingExit] = useState(false);
const [menuIndex, setMenuIndex] = useState(0);
const [showSkillsDropdown, setShowSkillsDropdown] = useState(false);
- const [skillsDropdownIndex, setSkillsDropdownIndex] = useState(0);
- const [modelDropdownStep, setModelDropdownStep] = useState(null);
- const [modelDropdownIndex, setModelDropdownIndex] = useState(0);
- const [pendingModel, setPendingModel] = useState(null);
+ const [openRawModelDropdown, setOpenRawModelDropdown] = useState(false);
+ const [showModelDropdown, setShowModelDropdown] = useState(false);
const [fileMentionItems, setFileMentionItems] = useState(() => scanFileMentionItems(projectRoot));
- const [fileMentionIndex, setFileMentionIndex] = useState(0);
const [dismissedFileMentionKey, setDismissedFileMentionKey] = useState(null);
const [historyCursor, setHistoryCursor] = useState(-1);
const [draftBeforeHistory, setDraftBeforeHistory] = useState(null);
@@ -149,6 +156,13 @@ export const PromptInput = React.memo(function PromptInput({
const undoRedoRef = React.useRef(createPromptUndoRedoState());
const wasBusyRef = React.useRef(busy);
const hadFileMentionTokenRef = React.useRef(false);
+ const appliedDraftNonceRef = React.useRef(null);
+ const pastesRef = React.useRef>(new Map());
+ const pasteCounterRef = React.useRef(0);
+ // Track expanded paste regions for toggle (Ctrl+O expand / collapse).
+ const expandedRegionsRef = React.useRef>(
+ new Map()
+ );
const fileMentionToken = getCurrentFileMentionToken(buffer);
const hasFileMentionToken = fileMentionToken !== null;
@@ -159,33 +173,42 @@ export const PromptInput = React.memo(function PromptInput({
);
const showFileMentionMenu =
!showSkillsDropdown &&
- !modelDropdownStep &&
+ !showModelDropdown &&
fileMentionToken !== null &&
fileMentionKey !== dismissedFileMentionKey;
const slashItems = React.useMemo(() => buildSlashCommands(skills), [skills]);
const slashToken = getCurrentSlashToken(buffer);
const slashMenu = React.useMemo(
() =>
- showSkillsDropdown || modelDropdownStep || showFileMentionMenu
+ showSkillsDropdown || showModelDropdown || showFileMentionMenu
? []
: slashToken
? filterSlashCommands(slashItems, slashToken)
: [],
- [showSkillsDropdown, modelDropdownStep, showFileMentionMenu, slashToken, slashItems]
+ [showSkillsDropdown, showModelDropdown, showFileMentionMenu, slashToken, slashItems]
);
const showMenu = slashMenu.length > 0;
const promptHistoryKey = React.useMemo(() => promptHistory.join("\0"), [promptHistory]);
const hasRunningProcess = runningProcesses && runningProcesses.size > 0;
- const processHint = hasRunningProcess ? " · ctrl+o view output" : "";
+ const hasCollapsedMarkers = hasActivePasteMarkers(buffer.text, pastesRef.current);
+ const hasExpandedRegions = expandedRegionsRef.current.size > 0;
+ const processOrPasteHint = hasRunningProcess
+ ? " · ctrl+o view output"
+ : hasCollapsedMarkers
+ ? " · ctrl+o expand"
+ : hasExpandedRegions
+ ? " · ctrl+o collapse"
+ : "";
const footerText = statusMessage
? statusMessage
: busy
? loadingText && loadingText.trim()
- ? `${loadingText}${processHint}`
- : `esc to interrupt · ctrl+c to cancel input${processHint}`
- : `enter send · shift+enter newline · @ files · ctrl+v image · / commands · ctrl+d exit${processHint}`;
+ ? `${loadingText}${processOrPasteHint}`
+ : `esc to interrupt · ctrl+c to cancel input${processOrPasteHint}`
+ : `enter send · shift+enter newline · @ files · ctrl+v image · / commands · ctrl+d exit${processOrPasteHint}`;
useTerminalFocusReporting(stdout, !disabled);
useTerminalExtendedKeys(stdout, !disabled);
+ useBracketedPaste(stdout, !disabled);
useHiddenTerminalCursor(stdout, !disabled);
const refreshFileMentionItems = React.useCallback(() => {
@@ -226,33 +249,6 @@ export const PromptInput = React.memo(function PromptInput({
}
}, [fileMentionKey]);
- useEffect(() => {
- if (!showFileMentionMenu) {
- setFileMentionIndex(0);
- return;
- }
- if (fileMentionIndex >= fileMentionMatches.length) {
- setFileMentionIndex(Math.max(0, fileMentionMatches.length - 1));
- }
- }, [fileMentionMatches.length, fileMentionIndex, showFileMentionMenu]);
-
- useEffect(() => {
- if (skillsDropdownIndex >= skills.length) {
- setSkillsDropdownIndex(Math.max(0, skills.length - 1));
- }
- }, [skills.length, skillsDropdownIndex]);
-
- useEffect(() => {
- if (!modelDropdownStep) {
- return;
- }
- const optionCount =
- modelDropdownStep === "model" ? MODEL_COMMAND_MODELS.length : MODEL_COMMAND_THINKING_OPTIONS.length;
- if (modelDropdownIndex >= optionCount) {
- setModelDropdownIndex(Math.max(0, optionCount - 1));
- }
- }, [modelDropdownIndex, modelDropdownStep]);
-
useEffect(() => {
if (!statusMessage) {
return;
@@ -261,6 +257,23 @@ export const PromptInput = React.memo(function PromptInput({
return () => clearTimeout(timer);
}, [statusMessage]);
+ useEffect(() => {
+ if (!promptDraft || appliedDraftNonceRef.current === promptDraft.nonce) {
+ return;
+ }
+ appliedDraftNonceRef.current = promptDraft.nonce;
+ setBuffer({ text: promptDraft.text, cursor: promptDraft.text.length });
+ setImageUrls(promptDraft.imageUrls);
+ setSelectedSkills([]);
+ setShowSkillsDropdown(false);
+ setOpenRawModelDropdown(false);
+ setHistoryCursor(-1);
+ setDraftBeforeHistory(null);
+ clearPromptUndoRedoState(undoRedoRef.current);
+ pastesRef.current.clear();
+ expandedRegionsRef.current.clear();
+ }, [promptDraft]);
+
useEffect(() => {
setHistoryCursor(-1);
setDraftBeforeHistory(null);
@@ -282,16 +295,7 @@ export const PromptInput = React.memo(function PromptInput({
}
if (key.escape) {
- if (modelDropdownStep) {
- closeModelDropdown();
- return;
- }
- if (showSkillsDropdown) {
- setShowSkillsDropdown(false);
- return;
- }
- if (showFileMentionMenu && fileMentionKey) {
- setDismissedFileMentionKey(fileMentionKey);
+ if (showFileMentionMenu) {
return;
}
if (busy) {
@@ -305,7 +309,7 @@ export const PromptInput = React.memo(function PromptInput({
if (runningProcesses && runningProcesses.size > 0 && onToggleProcessStdout) {
onToggleProcessStdout();
} else {
- setStatusMessage("No running process to inspect");
+ expandPasteMarkerAtCursor();
}
return;
}
@@ -333,6 +337,8 @@ export const PromptInput = React.memo(function PromptInput({
} else if (!isEmpty(buffer)) {
setBuffer(EMPTY_BUFFER);
clearUndoRedoStacks();
+ pastesRef.current.clear();
+ expandedRegionsRef.current.clear();
} else {
setStatusMessage("press ctrl+d to exit");
}
@@ -343,55 +349,17 @@ export const PromptInput = React.memo(function PromptInput({
setPendingExit(false);
}
- if (historyCursor !== -1 && !key.upArrow && !key.downArrow) {
- exitHistoryBrowsing();
+ if (openRawModelDropdown || showSkillsDropdown || showModelDropdown) {
+ return;
}
- if (showSkillsDropdown) {
- if (skills.length === 0) {
- setShowSkillsDropdown(false);
- } else {
- if (key.upArrow) {
- setSkillsDropdownIndex((idx) => (idx - 1 + skills.length) % skills.length);
- return;
- }
- if (key.downArrow) {
- setSkillsDropdownIndex((idx) => (idx + 1) % skills.length);
- return;
- }
- if ((input === " " && !key.ctrl && !key.meta) || (key.return && !key.shift && !key.meta)) {
- const skill = skills[skillsDropdownIndex];
- if (skill) {
- toggleSelectedSkill(skill);
- }
- return;
- }
- if (key.tab) {
- setShowSkillsDropdown(false);
- return;
- }
- }
+ if (historyCursor !== -1 && !key.upArrow && !key.downArrow) {
+ exitHistoryBrowsing();
}
- if (modelDropdownStep) {
- const optionCount =
- modelDropdownStep === "model" ? MODEL_COMMAND_MODELS.length : MODEL_COMMAND_THINKING_OPTIONS.length;
- if (key.upArrow) {
- setModelDropdownIndex((idx) => (idx - 1 + optionCount) % optionCount);
- return;
- }
- if (key.downArrow) {
- setModelDropdownIndex((idx) => (idx + 1) % optionCount);
- return;
- }
- if ((input === " " && !key.ctrl && !key.meta) || (key.return && !key.shift && !key.meta)) {
- selectModelDropdownItem();
- return;
- }
- if (key.tab) {
- closeModelDropdown();
- return;
- }
+ if (key.paste) {
+ handlePaste(input);
+ return;
}
if (key.ctrl && (input === "v" || input === "V")) {
@@ -426,32 +394,9 @@ export const PromptInput = React.memo(function PromptInput({
const isPlainReturn = returnAction === "submit";
if (showFileMentionMenu) {
- if (key.upArrow) {
- if (fileMentionMatches.length > 0) {
- setFileMentionIndex((idx) => (idx - 1 + fileMentionMatches.length) % fileMentionMatches.length);
- }
- return;
- }
- if (key.downArrow) {
- if (fileMentionMatches.length > 0) {
- setFileMentionIndex((idx) => (idx + 1) % fileMentionMatches.length);
- }
+ if (key.upArrow || key.downArrow || key.tab || returnAction === "submit") {
return;
}
- if (key.tab || returnAction === "submit") {
- const selected = fileMentionMatches[fileMentionIndex];
- if (selected && fileMentionToken) {
- insertFileMentionSelection(selected);
- return;
- }
- if (key.tab) {
- setDismissedFileMentionKey(fileMentionKey);
- return;
- }
- if (fileMentionKey) {
- setDismissedFileMentionKey(fileMentionKey);
- }
- }
}
if (showMenu) {
@@ -488,12 +433,12 @@ export const PromptInput = React.memo(function PromptInput({
}
if (key.delete) {
- updateBuffer((s) => deleteForward(s));
+ updateBuffer((s) => deletePasteMarkerForward(s, pastesRef.current) ?? deleteForward(s));
return;
}
if (key.backspace) {
- updateBuffer((s) => backspace(s));
+ updateBuffer((s) => deletePasteMarkerBackward(s, pastesRef.current) ?? backspace(s));
return;
}
@@ -583,6 +528,8 @@ export const PromptInput = React.memo(function PromptInput({
}
if (key.ctrl && (input === "u" || input === "U")) {
updateBuffer(() => EMPTY_BUFFER);
+ pastesRef.current.clear();
+ expandedRegionsRef.current.clear();
return;
}
if (key.ctrl && (input === "w" || input === "W")) {
@@ -660,6 +607,81 @@ export const PromptInput = React.memo(function PromptInput({
});
}
+ function handlePaste(pastedText: string): void {
+ const totalChars = pastedText.length;
+
+ if (totalChars <= 1000) {
+ const newlineCount = (pastedText.match(/\n/g) ?? []).length;
+ if (newlineCount <= 9) {
+ const clean = pastedText
+ .replace(/\r\n|\r/g, "\n")
+ .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "")
+ .replace(/\t/g, " ");
+ updateBuffer((s) => insertText(s, clean));
+ return;
+ }
+ }
+
+ // Large paste: store raw text, insert marker with line/char count.
+ const lineCount = (pastedText.match(/\n/g) ?? []).length + 1;
+ pasteCounterRef.current += 1;
+ const pasteId = pasteCounterRef.current;
+ pastesRef.current.set(pasteId, pastedText);
+
+ const marker =
+ lineCount > 10 ? `[paste #${pasteId} +${lineCount} lines]` : `[paste #${pasteId} ${totalChars} chars]`;
+
+ updateBuffer((s) => insertText(s, marker));
+ }
+
+ function expandPasteMarkerAtCursor(): void {
+ // First, try to collapse an already-expanded region at the cursor.
+ for (const [id, region] of expandedRegionsRef.current) {
+ if (buffer.cursor >= region.start && buffer.cursor <= region.end) {
+ // Collapse back to marker.
+ expandedRegionsRef.current.delete(id);
+ pastesRef.current.set(id, region.content);
+ setTimeout(() => {
+ updateBuffer((s) => {
+ const text = s.text.slice(0, region.start) + region.marker + s.text.slice(region.end);
+ return { text, cursor: region.start + region.marker.length };
+ });
+ }, 0);
+ return;
+ }
+ }
+
+ // No expanded region at cursor — try to expand a paste marker.
+ const marker = findPasteMarkerContaining(buffer);
+ if (!marker) {
+ setStatusMessage("No paste marker at cursor");
+ return;
+ }
+ const content = pastesRef.current.get(marker.id);
+ if (!content) {
+ setStatusMessage("Paste content not found");
+ return;
+ }
+
+ const pasteId = marker.id;
+ const originalMarker = buffer.text.slice(marker.start, marker.end);
+ pastesRef.current.delete(pasteId);
+
+ setTimeout(() => {
+ updateBuffer((s) => {
+ const text = s.text.slice(0, marker.start) + cleanPasteContent(content) + s.text.slice(marker.end);
+ const newEnd = marker.start + content.length;
+ expandedRegionsRef.current.set(pasteId, {
+ start: marker.start,
+ end: newEnd,
+ content,
+ marker: originalMarker,
+ });
+ return { text, cursor: marker.start };
+ });
+ }, 0);
+ }
+
function navigateHistory(direction: -1 | 1): void {
if (promptHistory.length === 0) {
return;
@@ -694,6 +716,17 @@ export const PromptInput = React.memo(function PromptInput({
setDismissedFileMentionKey(null);
}
+ function resetPromptInput(): void {
+ setBuffer(EMPTY_BUFFER);
+ clearUndoRedoStacks();
+ setImageUrls([]);
+ setSelectedSkills([]);
+ setShowSkillsDropdown(false);
+ pastesRef.current.clear();
+ expandedRegionsRef.current.clear();
+ pasteCounterRef.current = 0;
+ }
+
function handleSlashSelection(item: SlashCommandItem): void {
if (busy && item.kind !== "exit") {
setStatusMessage("wait for the current response or press esc to interrupt");
@@ -713,52 +746,43 @@ export const PromptInput = React.memo(function PromptInput({
}
if (item.kind === "model") {
clearSlashToken();
- openModelDropdown();
+ setShowSkillsDropdown(false);
+ setShowModelDropdown(true);
+ return;
+ }
+ if (item.kind === "raw") {
+ clearSlashToken();
+ setOpenRawModelDropdown(true);
return;
}
if (item.kind === "new") {
onSubmit({ text: "", imageUrls: [], command: "new" });
- setBuffer(EMPTY_BUFFER);
- clearUndoRedoStacks();
- setImageUrls([]);
- setSelectedSkills([]);
- setShowSkillsDropdown(false);
+ resetPromptInput();
return;
}
if (item.kind === "init") {
onSubmit(buildInitPromptSubmission(selectedSkills));
- setBuffer(EMPTY_BUFFER);
- clearUndoRedoStacks();
- setImageUrls([]);
- setSelectedSkills([]);
- setShowSkillsDropdown(false);
+ resetPromptInput();
return;
}
if (item.kind === "resume") {
onSubmit({ text: "", imageUrls: [], command: "resume" });
- setBuffer(EMPTY_BUFFER);
- clearUndoRedoStacks();
- setImageUrls([]);
- setSelectedSkills([]);
- setShowSkillsDropdown(false);
+ resetPromptInput();
return;
}
if (item.kind === "continue") {
onSubmit({ text: "/continue", imageUrls: [], command: "continue" });
- setBuffer(EMPTY_BUFFER);
- clearUndoRedoStacks();
- setImageUrls([]);
- setSelectedSkills([]);
- setShowSkillsDropdown(false);
+ resetPromptInput();
+ return;
+ }
+ if (item.kind === "undo") {
+ onSubmit({ text: "/undo", imageUrls: [], command: "undo" });
+ resetPromptInput();
return;
}
if (item.kind === "mcp") {
onSubmit({ text: "/mcp", imageUrls: [], command: "mcp" });
- setBuffer(EMPTY_BUFFER);
- clearUndoRedoStacks();
- setImageUrls([]);
- setSelectedSkills([]);
- setShowSkillsDropdown(false);
+ resetPromptInput();
return;
}
if (item.kind === "exit") {
@@ -789,15 +813,11 @@ export const PromptInput = React.memo(function PromptInput({
}
onSubmit({
- text: buffer.text,
+ text: expandPasteMarkers(buffer.text, pastesRef.current),
imageUrls,
selectedSkills,
});
- setBuffer(EMPTY_BUFFER);
- clearUndoRedoStacks();
- setImageUrls([]);
- setSelectedSkills([]);
- setShowSkillsDropdown(false);
+ resetPromptInput();
}
function addSelectedSkill(skill: SkillInfo): void {
@@ -814,65 +834,14 @@ export const PromptInput = React.memo(function PromptInput({
clearUndoRedoStacks();
}
- function openModelDropdown(): void {
- const currentModelIndex = MODEL_COMMAND_MODELS.findIndex((model) => model === modelConfig.model);
- setPendingModel(null);
- setModelDropdownStep("model");
- setModelDropdownIndex(currentModelIndex >= 0 ? currentModelIndex : 0);
- setShowSkillsDropdown(false);
- }
-
- function closeModelDropdown(): void {
- setModelDropdownStep(null);
- setPendingModel(null);
- }
-
- function selectModelDropdownItem(): void {
- if (modelDropdownStep === "model") {
- const model = MODEL_COMMAND_MODELS[modelDropdownIndex] ?? modelConfig.model;
- setPendingModel(model);
- setModelDropdownStep("thinking");
- setModelDropdownIndex(getThinkingOptionIndex(modelConfig));
- return;
- }
-
- const option = MODEL_COMMAND_THINKING_OPTIONS[modelDropdownIndex] ?? MODEL_COMMAND_THINKING_OPTIONS[0];
- const selection: ModelConfigSelection = {
- model: pendingModel ?? modelConfig.model,
- thinkingEnabled: option.thinkingEnabled,
- reasoningEffort: option.reasoningEffort ?? modelConfig.reasoningEffort,
- };
- closeModelDropdown();
- Promise.resolve(onModelConfigChange(selection))
- .then((message) => {
- if (message) {
- setStatusMessage(message);
- }
- })
- .catch((error) => {
- const message = error instanceof Error ? error.message : String(error);
- setStatusMessage(`Failed to update model settings: ${message}`);
- });
- }
-
- const modelDropdownItems =
- modelDropdownStep === "model"
- ? MODEL_COMMAND_MODELS.map((model) => ({
- label: model,
- selected: model === (pendingModel ?? modelConfig.model),
- description: model === modelConfig.model ? "current model" : "",
- }))
- : MODEL_COMMAND_THINKING_OPTIONS.map((option) => ({
- label: option.label,
- selected: getThinkingOptionIndex(modelConfig) === MODEL_COMMAND_THINKING_OPTIONS.indexOf(option),
- description: option.thinkingEnabled ? `reasoningEffort: ${option.reasoningEffort}` : "thinking disabled",
- }));
-
const showFooterText = useMemo(
- () => showMenu || showSkillsDropdown || modelDropdownStep !== null || showFileMentionMenu,
- [showMenu, showSkillsDropdown, modelDropdownStep, showFileMentionMenu]
+ () => showMenu || showSkillsDropdown || openRawModelDropdown || showModelDropdown || showFileMentionMenu,
+ [showMenu, showSkillsDropdown, showModelDropdown, openRawModelDropdown, showFileMentionMenu]
);
+ const matchedCommand = slashToken ? findExactSlashCommand(slashItems, slashToken) : null;
+ const inlineHint = matchedCommand?.args ? ` ${matchedCommand.args.join(ARGS_SEPARATOR)}` : "";
+
return (
{imageUrls.length > 0 ? (
@@ -899,77 +868,43 @@ export const PromptInput = React.memo(function PromptInput({
borderDimColor
>
- {renderBufferWithCursor(buffer, !disabled && hasTerminalFocus, placeholder)}
+ {renderBufferWithCursor(buffer, !disabled && hasTerminalFocus, placeholder, pastesRef.current)}
+ {inlineHint ? {inlineHint} : null}
- {showSkillsDropdown ? (
- ({
- key: skill.path || skill.name,
- label: skill.name,
- description: skill.path,
- selected: isSkillSelected(selectedSkills, skill),
- statusIndicator: skill.isLoaded ? { symbol: "✓", color: "green" } : undefined,
- }))}
- activeIndex={skillsDropdownIndex}
- activeColor="#229ac3"
- maxVisible={6}
- />
- ) : null}
- {modelDropdownStep ? (
- onRawModeChange?.(mode)}
+ screenWidth={screenWidth}
+ />
+
+ setShowModelDropdown(false)}
+ onModelConfigChange={onModelConfigChange}
+ onStatusMessage={setStatusMessage}
+ />
+ {
+ if (fileMentionKey) {
+ setDismissedFileMentionKey(fileMentionKey);
}
- items={modelDropdownItems.map((item) => ({
- key: item.label,
- label: item.label,
- description: item.description,
- selected: item.selected,
- }))}
- activeIndex={modelDropdownIndex}
- activeColor="#229ac3"
- maxVisible={6}
- />
- ) : null}
- {showFileMentionMenu ? (
- ({
- key: item.path,
- label: item.path,
- description: item.type === "directory" ? "directory" : "file",
- }))}
- activeIndex={fileMentionIndex}
- activeColor="#229ac3"
- maxVisible={8}
- renderItem={(item, isActive) => (
-
- {isActive ? "> " : " "}
-
-
- {item.label}
-
-
- {item.description ? (
-
- {item.description}
-
- ) : null}
-
- )}
- />
- ) : null}
+ }}
+ onSelect={insertFileMentionSelection}
+ />
{!showFooterText && (
@@ -997,10 +932,6 @@ export function formatSelectedSkillsStatus(skills: SkillInfo[]): string {
return `⚡ ${names.join(", ")}`;
}
-export function isSkillSelected(skills: SkillInfo[], skill: SkillInfo): boolean {
- return skills.some((item) => item.name === skill.name);
-}
-
export function addUniqueSkill(skills: SkillInfo[], skill: SkillInfo): SkillInfo[] {
if (isSkillSelected(skills, skill)) {
return skills;
@@ -1020,18 +951,6 @@ export function buildInitPromptSubmission(selectedSkills: SkillInfo[]): PromptSu
};
}
-export function getThinkingOptionIndex(
- config: Pick
-): number {
- const index = MODEL_COMMAND_THINKING_OPTIONS.findIndex((option) => {
- if (!config.thinkingEnabled) {
- return !option.thinkingEnabled;
- }
- return option.thinkingEnabled && option.reasoningEffort === config.reasoningEffort;
- });
- return index >= 0 ? index : 0;
-}
-
export function removeCurrentSlashToken(state: PromptBufferState): PromptBufferState {
let start = state.cursor;
while (start > 0 && !/\s/.test(state.text[start - 1] ?? "")) {
@@ -1063,12 +982,15 @@ export function getPromptReturnKeyAction(key: Pick
+): string {
const text = state.text || "";
const cursor = Math.max(0, Math.min(state.cursor, text.length));
- const before = text.slice(0, cursor);
- const at = text[cursor];
- const after = text.slice(cursor + 1);
+ const validIds = validPastes ?? new Map();
if (text.length === 0 && placeholder) {
if (!isFocused) {
@@ -1077,16 +999,107 @@ export function renderBufferWithCursor(state: PromptBufferState, isFocused: bool
return renderCursorCell(" ") + chalk.dim(` ${placeholder}`);
}
+ if (text.length === 0) {
+ return isFocused ? renderCursorCell(" ") : "";
+ }
+
if (!isFocused) {
- return text.endsWith("\n") ? `${text} ` : text;
+ return highlightPasteMarkersInText(text, validIds);
}
- if (typeof at === "undefined") {
- return before + renderCursorCell(" ");
+ return renderFocusedText(text, cursor, validIds);
+}
+
+function highlightPasteMarkersInText(s: string, validIds: Map): string {
+ if (!s.includes("[paste #")) return s;
+ PASTE_MARKER_REGEX.lastIndex = 0;
+ let result = "";
+ let pos = 0;
+ let match: RegExpExecArray | null;
+ while ((match = PASTE_MARKER_REGEX.exec(s)) !== null) {
+ result += s.slice(pos, match.index);
+ const id = Number.parseInt(match[1]!, 10);
+ result += validIds.has(id) ? chalk.yellow(match[0]) : match[0];
+ pos = match.index + match[0].length;
}
+ result += s.slice(pos);
+ return result.endsWith("\n") ? `${result} ` : result;
+}
+
+/**
+ * Render focused text with paste-marker highlighting and cursor insertion.
+ * Scans through the entire string in one pass, so the cursor can land
+ * anywhere (including inside or at the boundary of a paste marker) and the
+ * marker will still be highlighted correctly.
+ */
+function renderFocusedText(text: string, cursor: number, validIds: Map): string {
+ let result = "";
+ let pos = 0;
+ PASTE_MARKER_REGEX.lastIndex = 0;
+ let match: RegExpExecArray | null;
+
+ while ((match = PASTE_MARKER_REGEX.exec(text)) !== null) {
+ const markerStart = match.index;
+ const markerEnd = match.index + match[0].length;
+ const id = Number.parseInt(match[1]!, 10);
+ const isReal = validIds.has(id);
+
+ // 1. Non-marker segment before this marker.
+ result += renderTextSegmentWithCursor(text, pos, markerStart, cursor, false);
+ pos = markerStart;
+
+ // 2. Marker segment — highlighted only if it corresponds to a real paste.
+ result += renderTextSegmentWithCursor(text, pos, markerEnd, cursor, isReal);
+ pos = markerEnd;
+ }
+
+ // 3. Remainder after the last marker.
+ result += renderTextSegmentWithCursor(text, pos, text.length, cursor, false);
+
+ return result;
+}
+
+/**
+ * Render a segment of `text` from `start` to `end`.
+ * The cursor (if it falls inside this segment) is rendered as an inverse-video cell.
+ */
+function renderTextSegmentWithCursor(
+ text: string,
+ start: number,
+ end: number,
+ cursor: number,
+ highlighted: boolean
+): string {
+ if (start >= end) return "";
+
+ const segText = text.slice(start, end);
+ const cursorRel = cursor - start; // relative cursor position inside this segment
+
+ // Cursor not in this segment – just return the text.
+ if (cursorRel < 0 || cursorRel > segText.length) {
+ return highlighted ? chalk.yellow(segText) : segText;
+ }
+
+ // Cursor is exactly at `end` (which equals `segText.length`).
+ if (cursorRel === segText.length) {
+ return highlighted ? chalk.yellow(segText) + renderCursorCell(" ") : segText + renderCursorCell(" ");
+ }
+
+ // Cursor is somewhere inside the segment.
+ const at = segText[cursorRel];
+
if (at === "\n") {
+ // Render newline as a space in the cursor cell, then output the actual newline.
+ const before = segText.slice(0, cursorRel);
+ const after = segText.slice(cursorRel + 1);
return before + renderCursorCell(" ") + "\n" + after;
}
+
+ const before = segText.slice(0, cursorRel);
+ const after = segText.slice(cursorRel + 1);
+ if (highlighted) {
+ return chalk.yellow(before) + renderCursorCell(at) + chalk.yellow(after);
+ }
return before + renderCursorCell(at) + after;
}
diff --git a/src/ui/SessionList.tsx b/src/ui/SessionList.tsx
index fdbd1fe..82ca797 100644
--- a/src/ui/SessionList.tsx
+++ b/src/ui/SessionList.tsx
@@ -1,32 +1,67 @@
-import React, { useState, useMemo } from "react";
+import React, { useState, useMemo, useCallback } from "react";
import { Box, Text, useInput, useWindowSize } from "ink";
-import type { SessionEntry } from "../session";
+import type { SessionEntry, SessionStatus } from "../session";
+import { truncate } from "./components/MessageView/utils";
type Props = {
sessions: SessionEntry[];
onSelect: (sessionId: string) => void;
onCancel: () => void;
+ onDelete?: (sessionId: string) => void;
};
-export function SessionList({ sessions, onSelect, onCancel }: Props): React.ReactElement {
+/**
+ * Filter sessions by a search query.
+ * Matches against summary, status, and failReason fields (case-insensitive).
+ * Returns all sessions when query is empty.
+ */
+export function filterSessions(sessions: SessionEntry[], query: string): SessionEntry[] {
+ if (!query.trim()) {
+ return sessions;
+ }
+
+ const lowerQuery = query.toLowerCase().trim();
+ return sessions.filter((session) => {
+ if (session.summary && session.summary.toLowerCase().includes(lowerQuery)) {
+ return true;
+ }
+ if (session.status.toLowerCase().includes(lowerQuery)) {
+ return true;
+ }
+ if (session.failReason && session.failReason.toLowerCase().includes(lowerQuery)) {
+ return true;
+ }
+ if (session.assistantReply && session.assistantReply.toLowerCase().includes(lowerQuery)) {
+ return true;
+ }
+ return false;
+ });
+}
+
+export function SessionList({ sessions, onSelect, onCancel, onDelete }: Props): React.ReactElement {
const [index, setIndex] = useState(0);
+ const [searchQuery, setSearchQuery] = useState("");
+ const [confirmDeleteSessionId, setConfirmDeleteSessionId] = useState(null);
const { columns, rows } = useWindowSize();
+ // Filter sessions by search query
+ const filteredSessions = useMemo(() => filterSessions(sessions, searchQuery), [sessions, searchQuery]);
+
+ // Reset index when filtered list changes (e.g., query changes)
+ const safeIndex = useMemo(() => {
+ if (filteredSessions.length === 0) return 0;
+ return Math.max(0, Math.min(index, filteredSessions.length - 1));
+ }, [index, filteredSessions.length]);
+
// Dynamically calculate the number of visible sessions based on terminal height
const maxVisibleSessions = useMemo(() => {
- // Subtract space used by borders, header, footer, scroll indicator, etc.
- // Outer container height=rows-1, outer border 2 + header 1 + inner border 2 + footer 1 + scroll indicator 1 = 8
- const reservedLines = 8;
+ // Subtract space used by borders, header (2 lines with search bar), footer, scroll indicator, etc.
+ // Outer container height=rows-1, outer border 2 + header 2 + search bar 1 + inner border 2 + footer 1 + scroll indicator 1 = 9
+ const reservedLines = searchQuery ? 12 : 9;
const linesPerSession = 3; // height=2 + marginBottom=1
const availableLines = Math.max(0, Math.min(rows, 30) - reservedLines);
return Math.max(1, Math.floor(availableLines / linesPerSession));
- }, [rows]);
-
- // Ensure index stays within valid range
- const safeIndex = useMemo(() => {
- if (sessions.length === 0) return 0;
- return Math.max(0, Math.min(index, sessions.length - 1));
- }, [index, sessions.length]);
+ }, [rows, searchQuery]);
// Calculate scroll offset to keep the selected item visible
const scrollOffset = useMemo(() => {
@@ -36,23 +71,84 @@ export function SessionList({ sessions, onSelect, onCancel }: Props): React.Reac
// Get the currently visible session list
const visibleSessions = useMemo(() => {
- return sessions.slice(scrollOffset, scrollOffset + maxVisibleSessions);
- }, [sessions, scrollOffset, maxVisibleSessions]);
+ return filteredSessions.slice(scrollOffset, scrollOffset + maxVisibleSessions);
+ }, [filteredSessions, scrollOffset, maxVisibleSessions]);
+
+ // Handle backspace for search query
+ const handleBackspace = useCallback(() => {
+ setSearchQuery((prev) => prev.slice(0, -1));
+ setIndex(0);
+ }, []);
+
+ const selectedSession = filteredSessions[safeIndex];
useInput((input, key) => {
- if (key.escape || (key.ctrl && (input === "c" || input === "C"))) {
+ // If in delete confirmation mode, handle confirm/cancel
+ if (confirmDeleteSessionId) {
+ if (key.return) {
+ onDelete?.(confirmDeleteSessionId);
+ setConfirmDeleteSessionId(null);
+ return;
+ }
+ if (key.escape) {
+ setConfirmDeleteSessionId(null);
+ return;
+ }
+ return;
+ }
+
+ // ESC: clear search first, then cancel
+ if (key.escape) {
+ if (searchQuery) {
+ setSearchQuery("");
+ setIndex(0);
+ return;
+ }
onCancel();
return;
}
- if (sessions.length === 0) {
+
+ // Ctrl+C also cancels
+ if (key.ctrl && (input === "c" || input === "C")) {
+ onCancel();
+ return;
+ }
+
+ // Delete key: remove search character, or start delete confirmation
+ if (key.delete || key.backspace) {
+ if (searchQuery) {
+ // remove last search character
+ handleBackspace();
+ return;
+ }
+ // No search query: start delete confirmation if session is selected
+ if (selectedSession && onDelete) {
+ setConfirmDeleteSessionId(selectedSession.id);
+ return;
+ }
+ }
+
+ // Printable character: append to search query
+ if (input && input.length > 0 && !key.meta && !key.ctrl && !key.tab && !key.return) {
+ // Ignore if it's a named key that happens to have input (safety check)
+ if (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow) {
+ return;
+ }
+ setSearchQuery((prev) => prev + input);
+ setIndex(0);
+ return;
+ }
+
+ if (filteredSessions.length === 0) {
return;
}
+
if (key.upArrow) {
setIndex((i) => Math.max(0, i - 1));
return;
}
if (key.downArrow) {
- setIndex((i) => Math.min(sessions.length - 1, i + 1));
+ setIndex((i) => Math.min(filteredSessions.length - 1, i + 1));
return;
}
if (key.pageUp) {
@@ -60,7 +156,7 @@ export function SessionList({ sessions, onSelect, onCancel }: Props): React.Reac
return;
}
if (key.pageDown) {
- setIndex((i) => Math.min(sessions.length - 1, i + maxVisibleSessions));
+ setIndex((i) => Math.min(filteredSessions.length - 1, i + maxVisibleSessions));
return;
}
if (key.home) {
@@ -68,17 +164,19 @@ export function SessionList({ sessions, onSelect, onCancel }: Props): React.Reac
return;
}
if (key.end) {
- setIndex(sessions.length - 1);
+ setIndex(filteredSessions.length - 1);
return;
}
if (key.return) {
- const session = sessions[safeIndex];
+ const session = filteredSessions[safeIndex];
if (session) {
onSelect(session.id);
}
}
});
+ const hasActiveSearch = searchQuery.trim().length > 0;
+
if (sessions.length === 0) {
return (
@@ -99,15 +197,24 @@ export function SessionList({ sessions, onSelect, onCancel }: Props): React.Reac
>
{/* Header row */}
-
-
- Resume a session
-
-
- {" "}
- ({sessions.length} total)
-
+
+
+
+ Resume a session
+
+
+ {" "}
+ ({sessions.length} total
+ {hasActiveSearch ? `, ${filteredSessions.length} matched` : ""})
+
+
+ {/* Search bar */}
+
+ {searchQuery ? `Search: ${searchQuery}` : "Type to search\u2026"}
+ {searchQuery ? | : null}
+
+
{/* Session list */}
- {visibleSessions.map((session, i) => {
- const actualIndex = scrollOffset + i;
- return (
-
-
- {actualIndex === safeIndex ? "> " : " "}
-
-
-
-
- {formatSessionTitle(session.summary || "Untitled")}
-
- ({session.status})
+ {filteredSessions.length === 0 ? (
+
+ No sessions match "{searchQuery}".
+
+ ) : (
+ visibleSessions.map((session, i) => {
+ const actualIndex = scrollOffset + i;
+ const isSelected = actualIndex === safeIndex;
+ const isConfirming = confirmDeleteSessionId === session.id;
+ return (
+
+
+ {isSelected ? "> " : " "}
-
- {formatTimestamp(session.updateTime)}
+
+
+
+ {formatSessionTitle(session.summary || "Untitled")}
+
+ {isConfirming ? (
+ [Delete? Enter=yes, Esc=no]
+ ) : (
+ ({formatSessionStatus(session.status)})
+ )}
+
+
+ {formatTimestamp(session.updateTime)}
+
-
- );
- })}
- {scrollOffset > 0 || scrollOffset + maxVisibleSessions < sessions.length ? (
+ );
+ })
+ )}
+ {scrollOffset > 0 || scrollOffset + maxVisibleSessions < filteredSessions.length ? (
- {scrollOffset > 0 ? … {scrollOffset} newer sessions above. : null}
- {scrollOffset + maxVisibleSessions < sessions.length ? (
- … {sessions.length - scrollOffset - maxVisibleSessions} older sessions below.
+ {scrollOffset > 0 ? … {scrollOffset} sessions above. : null}
+ {scrollOffset + maxVisibleSessions < filteredSessions.length ? (
+ … {filteredSessions.length - scrollOffset - maxVisibleSessions} sessions below.
) : null}
) : null}
{/* Footer */}
-
- ↑/↓ navigate · PgUp/PgDn page · Enter select · Esc cancel
+
+ {confirmDeleteSessionId ? (
+
+ Delete this session?
+
+ Enter
+
+ to confirm ·
+
+ Esc
+
+ to cancel
+
+ ) : hasActiveSearch ? (
+
+ Esc clear search ·
+ ↑/↓ navigate · Enter select · Esc again to cancel
+
+ ) : (
+
+
+ Type to search · ↑/↓ navigate · PgUp/PgDn page · Enter select · Esc cancel · Del delete
+
+
+ )}
@@ -179,9 +318,21 @@ export function formatSessionTitle(value: string, max = 70): string {
return truncate(value.replace(/\r?\n/g, " ").replace(/\s+/g, " ").trim(), max);
}
-function truncate(value: string, max: number): string {
- if (value.length <= max) {
- return value;
+export function formatSessionStatus(status: SessionStatus): string {
+ switch (status) {
+ case "completed":
+ return "done";
+ case "processing":
+ return "running";
+ case "pending":
+ return "pending";
+ case "waiting_for_user":
+ return "waiting";
+ case "failed":
+ return "failed";
+ case "interrupted":
+ return "stopped";
+ default:
+ return status;
}
- return `${value.slice(0, max)}…`;
}
diff --git a/src/ui/SlashCommandMenu.tsx b/src/ui/SlashCommandMenu.tsx
index 436be83..df599b5 100644
--- a/src/ui/SlashCommandMenu.tsx
+++ b/src/ui/SlashCommandMenu.tsx
@@ -1,7 +1,9 @@
import { formatSlashCommandDescription, formatSlashCommandLabel } from "./slashCommands";
import type { SlashCommandItem } from "./slashCommands";
+import { ARGS_SEPARATOR } from "./constants";
import React from "react";
import { Box, Text } from "ink";
+import type { SkillInfo } from "../session";
type SlashCommandMenuProps = {
items: SlashCommandItem[];
@@ -9,7 +11,9 @@ type SlashCommandMenuProps = {
width: number;
maxVisible?: number;
};
-
+export function isSkillSelected(skills: SkillInfo[], skill: SkillInfo): boolean {
+ return skills.some((item) => item.name === skill.name);
+}
const SlashCommandMenu = React.memo(function SlashCommandMenu({
items,
activeIndex,
@@ -21,7 +25,9 @@ const SlashCommandMenu = React.memo(function SlashCommandMenu({
if (items.length === 0) {
return 0;
}
- const longestLabel = Math.max(...items.map((s) => s.label.length));
+ const longestLabel = Math.max(
+ ...items.map((s) => s.label.length + (s.args ? s.args?.join(ARGS_SEPARATOR)?.length + 4 : 0))
+ );
const contentWidth = longestLabel + 2; // +2 for prefix "> " or " "
const maxAllowed = Math.max(10, (width - 2) >> 1); // 容器50%宽度（减去gap），至少保留10列
return Math.min(contentWidth, maxAllowed);
@@ -49,11 +55,12 @@ const SlashCommandMenu = React.memo(function SlashCommandMenu({
const actualIndex = visibleStart + idx;
return (
-
+
{actualIndex === activeIndex ? "> " : " "}
{formatSlashCommandLabel(item)}
+ {item.args ? {item.args.join(ARGS_SEPARATOR)} : null}
diff --git a/src/ui/UndoSelector.tsx b/src/ui/UndoSelector.tsx
new file mode 100644
index 0000000..fad3e17
--- /dev/null
+++ b/src/ui/UndoSelector.tsx
@@ -0,0 +1,195 @@
+import React, { useMemo, useState } from "react";
+import { Box, Text, useInput, useWindowSize } from "ink";
+import type { UndoTarget } from "../session";
+
+export type UndoRestoreMode = "code-and-conversation" | "conversation";
+
+type Props = {
+ targets: UndoTarget[];
+ onSelect: (target: UndoTarget, mode: UndoRestoreMode) => void;
+ onCancel: () => void;
+};
+
+type Phase = "message" | "mode";
+
+const MAX_VISIBLE_TARGETS = 7;
+
+export function UndoSelector({ targets, onSelect, onCancel }: Props): React.ReactElement {
+ const [phase, setPhase] = useState("message");
+ const [targetIndex, setTargetIndex] = useState(Math.max(0, targets.length - 1));
+ const [modeIndex, setModeIndex] = useState(0);
+ const { columns, rows } = useWindowSize();
+
+ const safeTargetIndex = useMemo(() => {
+ if (targets.length === 0) {
+ return 0;
+ }
+ return Math.max(0, Math.min(targetIndex, targets.length - 1));
+ }, [targetIndex, targets.length]);
+
+ const selectedTarget = targets[safeTargetIndex] ?? null;
+ const maxVisible = Math.max(1, Math.min(MAX_VISIBLE_TARGETS, rows - 8));
+ const scrollOffset = Math.max(0, Math.min(safeTargetIndex - Math.floor(maxVisible / 2), targets.length - maxVisible));
+ const visibleTargets = targets.slice(scrollOffset, scrollOffset + maxVisible);
+
+ useInput((input, key) => {
+ if (key.escape || (key.ctrl && (input === "c" || input === "C"))) {
+ if (phase === "mode") {
+ setPhase("message");
+ return;
+ }
+ onCancel();
+ return;
+ }
+
+ if (targets.length === 0) {
+ return;
+ }
+
+ if (phase === "message") {
+ if (key.upArrow) {
+ setTargetIndex((index) => Math.max(0, index - 1));
+ return;
+ }
+ if (key.downArrow) {
+ setTargetIndex((index) => Math.min(targets.length - 1, index + 1));
+ return;
+ }
+ if (key.home) {
+ setTargetIndex(0);
+ return;
+ }
+ if (key.end) {
+ setTargetIndex(targets.length - 1);
+ return;
+ }
+ if (key.return) {
+ setModeIndex(selectedTarget?.canRestoreCode ? 0 : 1);
+ setPhase("mode");
+ }
+ return;
+ }
+
+ if (key.upArrow || key.downArrow) {
+ setModeIndex((index) => (index === 0 ? 1 : 0));
+ return;
+ }
+ if (key.return && selectedTarget) {
+ onSelect(selectedTarget, modeIndex === 0 ? "code-and-conversation" : "conversation");
+ }
+ });
+
+ if (targets.length === 0) {
+ return (
+
+ Nothing to undo yet.
+ Press Esc to go back.
+
+ );
+ }
+
+ return (
+
+
+
+
+ Undo
+
+ restore to the point before a prompt
+
+ {phase === "message" ? (
+
+ {visibleTargets.map((target, visibleIndex) => {
+ const actualIndex = scrollOffset + visibleIndex;
+ const isActive = actualIndex === safeTargetIndex;
+ return (
+
+ {isActive ? "> " : " "}
+
+
+ {formatUndoMessage(target.message.content)}
+
+
+ {formatTimestamp(target.message.createTime)}
+ {target.canRestoreCode ? " · code checkpoint available" : " · conversation only"}
+
+
+
+ );
+ })}
+
+ ) : (
+
+ Selected prompt:
+ {formatUndoMessage(selectedTarget?.message.content ?? "")}
+
+
+ {modeIndex === 0 ? "> " : " "}Restore code and conversation
+
+
+ {" "}
+ {selectedTarget?.canRestoreCode
+ ? "Restore files from the recorded Git checkpoint, then fork the conversation."
+ : "No code checkpoint is recorded for this prompt."}
+
+
+ {modeIndex === 1 ? "> " : " "}Restore conversation
+
+ {" "}Fork the conversation without changing files.
+
+
+ )}
+
+
+ {phase === "message"
+ ? "↑/↓ navigate · Enter choose · Esc cancel"
+ : "↑/↓ choose restore mode · Enter restore · Esc back"}
+
+
+
+
+ );
+}
+
+function formatUndoMessage(content: unknown): string {
+ const text = typeof content === "string" && content.trim() ? content.trim() : "(empty message)";
+ const singleLine = text.replace(/\r?\n/g, " ").replace(/\s+/g, " ");
+ return singleLine.length > 90 ? `${singleLine.slice(0, 89)}…` : singleLine;
+}
+
+function formatTimestamp(value: string): string {
+ const date = new Date(value);
+ if (Number.isNaN(date.valueOf())) {
+ return value;
+ }
+ return date.toLocaleString();
+}
diff --git a/src/ui/WelcomeScreen.tsx b/src/ui/WelcomeScreen.tsx
index 3d82eed..7e740d1 100644
--- a/src/ui/WelcomeScreen.tsx
+++ b/src/ui/WelcomeScreen.tsx
@@ -7,12 +7,12 @@ import type { ResolvedDeepcodingSettings } from "../settings";
import { buildSlashCommands, BUILTIN_SLASH_COMMANDS, formatSlashCommandDescription } from "./slashCommands";
import { ThemedGradient } from "./ThemedGradient";
import { AsciiLogo } from "../AsciiArt";
+import { useAppContext } from "./contexts";
type WelcomeScreenProps = {
projectRoot: string;
settings: ResolvedDeepcodingSettings;
skills: SkillInfo[];
- version: string;
width: number;
};
@@ -28,13 +28,8 @@ const SHORTCUT_TIPS = [
{ label: "Ctrl+D twice", description: "Quit Deep Code CLI" },
];
-export function WelcomeScreen({
- projectRoot,
- settings,
- skills,
- version,
- width,
-}: WelcomeScreenProps): React.ReactElement {
+export function WelcomeScreen({ projectRoot, settings, skills, width }: WelcomeScreenProps): React.ReactElement {
+ const { version } = useAppContext();
const tips = useMemo(() => buildWelcomeTips(skills), [skills]);
const [tipIndex] = useState(() => randomTipIndex(tips.length));
const compact = width < TITLE_PANEL_WIDTH + 42;
diff --git a/src/ui/components/FileMentionMenu/index.tsx b/src/ui/components/FileMentionMenu/index.tsx
new file mode 100644
index 0000000..ce9a8ee
--- /dev/null
+++ b/src/ui/components/FileMentionMenu/index.tsx
@@ -0,0 +1,117 @@
+import React, { useEffect, useState } from "react";
+import { Box, Text } from "ink";
+import { useInput } from "ink";
+import DropdownMenu from "../../DropdownMenu";
+import type { FileMentionItem, FileMentionToken } from "../../fileMentions";
+
+type Props = {
+ open: boolean;
+ width: number;
+ token: FileMentionToken | null;
+ items: FileMentionItem[];
+ onClose: () => void;
+ onSelect: (item: FileMentionItem) => void;
+};
+
+const FileMentionMenu: React.FC = ({ open, width, token, items, onClose, onSelect }) => {
+ const [activeIndex, setActiveIndex] = useState(0);
+
+ // Reset index when opened
+ useEffect(() => {
+ if (open) {
+ setActiveIndex(0);
+ }
+ }, [open]);
+
+ // Validate activeIndex bounds
+ useEffect(() => {
+ if (!open) {
+ return;
+ }
+ if (items.length === 0) {
+ setActiveIndex(0);
+ return;
+ }
+ if (activeIndex >= items.length) {
+ setActiveIndex(Math.max(0, items.length - 1));
+ }
+ }, [activeIndex, items.length, open]);
+
+ useInput(
+ (input, key) => {
+ if (!open) {
+ return;
+ }
+
+ if (key.escape) {
+ onClose();
+ return;
+ }
+
+ if (key.upArrow) {
+ if (items.length > 0) {
+ setActiveIndex((idx) => (idx - 1 + items.length) % items.length);
+ }
+ return;
+ }
+
+ if (key.downArrow) {
+ if (items.length > 0) {
+ setActiveIndex((idx) => (idx + 1) % items.length);
+ }
+ return;
+ }
+
+ if (key.tab || (key.return && !key.shift && !key.meta)) {
+ const selected = items[activeIndex];
+ if (selected) {
+ onSelect(selected);
+ return;
+ }
+ if (key.tab) {
+ onClose();
+ }
+ return;
+ }
+ },
+ { isActive: open }
+ );
+
+ if (!open) {
+ return null;
+ }
+
+ return (
+ ({
+ key: item.path,
+ label: item.path,
+ description: item.type === "directory" ? "directory" : "file",
+ }))}
+ activeIndex={activeIndex}
+ activeColor="#229ac3"
+ maxVisible={8}
+ renderItem={(item, isActive) => (
+
+ {isActive ? "> " : " "}
+
+
+ {item.label}
+
+
+ {item.description ? (
+
+ {item.description}
+
+ ) : null}
+
+ )}
+ />
+ );
+};
+
+export default FileMentionMenu;
diff --git a/src/ui/components/MessageView/index.tsx b/src/ui/components/MessageView/index.tsx
new file mode 100644
index 0000000..9c31551
--- /dev/null
+++ b/src/ui/components/MessageView/index.tsx
@@ -0,0 +1,216 @@
+import React from "react";
+import { Box, Text } from "ink";
+import { renderMarkdown, renderMarkdownSegments } from "./markdown";
+import {
+ buildThinkingSummary,
+ buildToolSummary,
+ formatStatusName,
+ formatToolStatusParams,
+ getToolDiffPreviewLines,
+ getUpdatePlanPreviewLines,
+} from "./utils";
+import type { DiffPreviewLine, MessageViewProps } from "./types";
+import { RawMode, useRawModeContext } from "../../contexts";
+
+export function MessageView({ message, collapsed, width = 80 }: MessageViewProps): React.ReactElement | null {
+ const { mode } = useRawModeContext();
+ if (!message.visible) {
+ return null;
+ }
+
+ if (message.role === "user") {
+ const text = message.content || "(no content)";
+ return (
+
+
+ {`>`}
+
+
+ {text}
+ {Array.isArray(message.contentParams) && message.contentParams.length > 0 ? (
+ {` 📎 ${message.contentParams.length} image attachment(s)`}
+ ) : null}
+
+
+ );
+ }
+
+ if (message.role === "assistant") {
+ const isThinking = Boolean(message.meta?.asThinking);
+ const content = (message.content || "").trim();
+
+ if (isThinking) {
+ const summary = buildThinkingSummary(content, message.messageParams, mode);
+ if (collapsed !== false) {
+ return (
+
+
+
+ );
+ }
+ return (
+
+
+
+ {content ? {renderMarkdown(content)} : null}
+
+
+ );
+ }
+
+ const containerWidth = Math.max(1, width - 2);
+ const contentWidth = Math.max(1, width - 4);
+
+ return (
+
+
+ ✦
+
+
+ {content
+ ? renderMarkdownSegments(content, Math.max(20, contentWidth - 4)).map((seg, i) => {
+ if (seg.kind === "table") {
+ return (
+
+ {seg.body.split("\n").map((line, lineIndex) => (
+
+ {line}
+
+ ))}
+
+ );
+ }
+ return {seg.body};
+ })
+ : null}
+
+
+ );
+ }
+
+ if (message.role === "tool") {
+ const summary = buildToolSummary(message);
+ const diffLines = getToolDiffPreviewLines(summary);
+ const planLines = getUpdatePlanPreviewLines(summary);
+ return (
+
+
+ {diffLines.length > 0 ? : null}
+ {planLines.length > 0 ? : null}
+
+ );
+ }
+
+ if (message.role === "system") {
+ // Render model change messages in the same style as user commands.
+ if (message.meta?.isModelChange) {
+ return (
+
+
+ {`>`}
+
+
+ {message.content}
+
+
+ );
+ }
+
+ if (message.meta?.skill) {
+ return (
+
+ ⚡ Loaded skill: {message.meta.skill.name}
+
+ );
+ }
+ if (message.meta?.isSummary) {
+ return (
+
+
+ (conversation summary inserted)
+
+
+ );
+ }
+ return null;
+ }
+
+ return null;
+}
+
+function StatusLine({
+ bulletColor,
+ name,
+ params,
+ width,
+}: {
+ bulletColor: "gray" | "green" | "red";
+ name: string;
+ params: string;
+ width: number;
+}): React.ReactElement {
+ const { mode } = useRawModeContext();
+ const containerWidth = Math.max(1, width - 2);
+ const contentWidth = Math.max(1, width - 4);
+ return (
+
+
+
+ ✧
+
+
+
+
+
+ {name}
+
+ {params ? (
+
+ {` ${params}`}
+
+ ) : null}
+
+
+
+ );
+}
+
+function DiffPreview({ lines }: { lines: DiffPreviewLine[] }): React.ReactElement {
+ return (
+
+ └ Changes
+
+ {lines.map((line, index) => (
+
+
+ {line.marker}
+
+
+ {line.content}
+
+
+ ))}
+
+
+ );
+}
+
+function PlanPreview({ lines }: { lines: string[] }): React.ReactElement {
+ return (
+
+ └ Plan
+
+ {lines.map((line, index) => (
+
+ {line}
+
+ ))}
+
+
+ );
+}
diff --git a/src/ui/components/MessageView/markdown.ts b/src/ui/components/MessageView/markdown.ts
new file mode 100644
index 0000000..3ebb58b
--- /dev/null
+++ b/src/ui/components/MessageView/markdown.ts
@@ -0,0 +1,405 @@
+import chalk from "chalk";
+
+/**
+ * A rendered piece of markdown. Consumers should use `wrap="truncate-end"` for
+ * `table` segments and the default wrap mode for `text` segments so that Ink
+ * never breaks box-drawing lines at cell boundary spaces.
+ */
+export type MarkdownSegment =
+ | { kind: "text"; body: string }
+ | { kind: "table"; body: string }
+ | { kind: "code"; body: string; lang: string };
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/** Render markdown to a single string (backward-compatible). */
+export function renderMarkdown(text: string, maxWidth?: number): string {
+ return renderMarkdownSegments(text, maxWidth)
+ .map((s) => s.body)
+ .reduce((out, body) => {
+ if (!out) return body;
+ if (!body) return out;
+ return out.endsWith("\n") || body.startsWith("\n") ? out + body : `${out}\n${body}`;
+ }, "");
+}
+
+/** Render markdown, returning typed segments so the caller can choose the
+ right `` per segment. */
+export function renderMarkdownSegments(text: string, maxWidth?: number): MarkdownSegment[] {
+ if (!text) return [];
+
+ const segments: MarkdownSegment[] = [];
+ const fenceSegments = splitByFences(text);
+
+ for (const seg of fenceSegments) {
+ if (seg.kind === "code") {
+ const langTag = seg.lang ? chalk.dim(`[${seg.lang}]`) + "\n" : "";
+ segments.push({ kind: "code", body: langTag + chalk.cyan(seg.body), lang: seg.lang });
+ continue;
+ }
+ const blocks = splitTableBlocks(seg.body);
+ for (const b of blocks) {
+ if (b.kind === "table") {
+ segments.push({ kind: "table", body: renderTableBorder(b.rows, maxWidth) });
+ } else {
+ const body = b.body
+ .split("\n")
+ .map((line) => renderInlineLine(line))
+ .join("\n");
+ if (body) segments.push({ kind: "text", body });
+ }
+ }
+ }
+
+ return segments;
+}
+
+// ---------------------------------------------------------------------------
+// Code fences
+// ---------------------------------------------------------------------------
+
+type FenceSegment = { kind: "text"; body: string } | { kind: "code"; lang: string; body: string };
+
+function splitByFences(text: string): FenceSegment[] {
+ const segments: FenceSegment[] = [];
+ const lines = text.split(/\r?\n/);
+ let buffer: string[] = [];
+ let inFence = false;
+ let fenceLang = "";
+ let fenceBody: string[] = [];
+
+ const flushText = () => {
+ if (buffer.length > 0) {
+ segments.push({ kind: "text", body: buffer.join("\n") });
+ buffer = [];
+ }
+ };
+
+ for (const line of lines) {
+ const m = /^\s*```(\w*)\s*$/.exec(line);
+ if (m) {
+ if (!inFence) {
+ flushText();
+ inFence = true;
+ fenceLang = m[1] ?? "";
+ fenceBody = [];
+ } else {
+ segments.push({ kind: "code", lang: fenceLang, body: fenceBody.join("\n") });
+ inFence = false;
+ }
+ continue;
+ }
+ (inFence ? fenceBody : buffer).push(line);
+ }
+
+ if (inFence) {
+ segments.push({ kind: "code", lang: fenceLang, body: fenceBody.join("\n") });
+ } else {
+ flushText();
+ }
+
+ return segments;
+}
+
+// ---------------------------------------------------------------------------
+// Table parsing
+// ---------------------------------------------------------------------------
+
+type TableBlock = { kind: "text"; body: string } | { kind: "table"; rows: string[][] };
+
+function splitTableBlocks(text: string): TableBlock[] {
+ const lines = text.split(/\r?\n/);
+ const blocks: TableBlock[] = [];
+ let buffer: string[] = [];
+ let tableRows: string[][] = [];
+ let inTable = false;
+
+ const flushText = () => {
+ if (buffer.length > 0) {
+ blocks.push({ kind: "text", body: buffer.join("\n") });
+ buffer = [];
+ }
+ };
+ const flushTable = () => {
+ if (tableRows.length >= 2) {
+ blocks.push({ kind: "table", rows: tableRows });
+ } else if (tableRows.length > 0) {
+ buffer.push(...tableRows.map((r) => r.join(" | ")));
+ }
+ tableRows = [];
+ };
+
+ const sepRe = /^\|?\s*:?[-]{3,}:?\s*(\|\s*:?[-]{3,}:?\s*)*\|?\s*$/;
+ const parseRow = (row: string) => {
+ let body = row.trim();
+ if (body.startsWith("|")) body = body.slice(1);
+ if (body.endsWith("|")) body = body.slice(0, -1);
+ return body.split("|").map((s) => s.trim());
+ };
+
+ for (let i = 0; i < lines.length; i++) {
+ const line = lines[i];
+ const trimmed = line.trim();
+ const nextTrimmed = (lines[i + 1] ?? "").trim();
+
+ // skip separator line
+ if (inTable && sepRe.test(trimmed) && tableRows.length === 1) continue;
+
+ const isRow = /^\|.+\|$/.test(trimmed);
+ const isHeader = isRow && i + 1 < lines.length && sepRe.test(nextTrimmed);
+
+ if (isHeader && !inTable) {
+ flushText();
+ inTable = true;
+ tableRows = [parseRow(trimmed)];
+ continue;
+ }
+
+ if (isRow && inTable) {
+ tableRows.push(parseRow(trimmed));
+ continue;
+ }
+
+ if (inTable && !isRow) {
+ flushTable();
+ inTable = false;
+ }
+ buffer.push(line);
+ }
+
+ return inTable ? [...blocks, ...flushTableResult(tableRows)] : [...blocks, ...flushTextOnly(buffer, tableRows)];
+}
+
+function flushTableResult(rows: string[][]): TableBlock[] {
+ if (rows.length >= 2) return [{ kind: "table", rows }];
+ if (rows.length > 0) return [{ kind: "text", body: rows.map((r) => r.join(" | ")).join("\n") }];
+ return [];
+}
+
+function flushTextOnly(buffer: string[], tableRows: string[][]): TableBlock[] {
+ const result: TableBlock[] = [];
+ if (buffer.length > 0) result.push({ kind: "text", body: buffer.join("\n") });
+ if (tableRows.length >= 2) result.push({ kind: "table", rows: tableRows });
+ else if (tableRows.length > 0) result.push({ kind: "text", body: tableRows.map((r) => r.join(" | ")).join("\n") });
+ return result;
+}
+
+// ---------------------------------------------------------------------------
+// Terminal visual width (CJK / emoji = 2 cols, ASCII = 1)
+// ---------------------------------------------------------------------------
+
+function visualWidth(text: string): number {
+ let w = 0;
+ for (const ch of text) {
+ if (ch.length >= 2) {
+ w += 2;
+ continue;
+ }
+ const code = ch.codePointAt(0) ?? ch.charCodeAt(0);
+ w += isWideChar(code) ? 2 : 1;
+ }
+ return w;
+}
+
+function isWideChar(code: number): boolean {
+ return (
+ (code >= 0x1100 && code <= 0x115f) || // Hangul Jamo
+ (code >= 0x2329 && code <= 0x232a) || // Misc technical
+ (code >= 0x2e80 && code <= 0xa4cf) || // CJK Radicals, Kangxi, CJK all
+ (code >= 0xac00 && code <= 0xd7af) || // Hangul Syllables
+ (code >= 0xf900 && code <= 0xfaff) || // CJK Compat
+ (code >= 0xfe10 && code <= 0xfe6f) || // CJK Compat Forms
+ (code >= 0xff00 && code <= 0xffe6) || // Fullwidth
+ (code >= 0x20000 && code <= 0x3fffd) || // CJK Ext B+
+ (code >= 0x1f300 && code <= 0x1faff) || // Emoji & pictographs
+ (code >= 0x2600 && code <= 0x27bf) || // Misc Symbols
+ (code >= 0x2300 && code <= 0x23ff) || // Misc Technical
+ (code >= 0x2b00 && code <= 0x2bff) || // Misc Symbols & Arrows
+ (code >= 0x1f000 && code <= 0x1f02f) // Mahjong & Domino
+ );
+}
+
+// ---------------------------------------------------------------------------
+// Table rendering
+// ---------------------------------------------------------------------------
+
+function renderTableBorder(rows: string[][], maxWidth?: number): string {
+ if (rows.length === 0) return "";
+
+ const colCount = rows[0].length;
+ const normalizedRows = rows.map((row) =>
+ Array.from({ length: colCount }, (_, i) => {
+ return row[i] ?? "";
+ })
+ );
+ const calcW = (cs: number[]) => cs.reduce((a, b) => a + b + 2, 0) + cs.length + 1;
+
+ // Natural width per column, measured as terminal cells rather than UTF-16 units.
+ const natural: number[] = Array.from({ length: colCount }, (_, i) => {
+ const texts = normalizedRows.map((r) => r[i] ?? "");
+ const maxLine = Math.max(4, ...texts.map((t) => visualWidth(t)));
+ return maxLine;
+ });
+
+ // Keep minimums small so long CJK text or unbroken tokens can wrap by character.
+ const minWidths: number[] = Array.from({ length: colCount }, (_, i) => {
+ const headerWidth = visualWidth(normalizedRows[0]?.[i] ?? "");
+ const labelColumn = natural[i] <= 12;
+ const minReadable = labelColumn ? natural[i] : Math.max(4, Math.min(headerWidth, 12));
+ return Math.min(natural[i], minReadable);
+ });
+
+ let colWidths: number[];
+ const totalNatural = calcW(natural);
+ const totalMin = calcW(minWidths);
+
+ const effectiveMax = maxWidth ?? 120; // default to a generous terminal width
+
+ if (totalNatural <= effectiveMax) {
+ // Content fits comfortably — use natural widths and grow to fill available space
+ colWidths = [...natural];
+ const slack = effectiveMax - totalNatural;
+ if (slack > 0) {
+ // Distribute slack proportionally to content columns (skip tiny label columns)
+ const isLabel = colWidths.map((w) => w <= 8);
+ const candidates = colWidths.map((w, i) => (isLabel[i] ? 0 : w));
+ const totalWeight = candidates.reduce((a, b) => a + b, 0);
+ if (totalWeight > 0) {
+ for (let ci = 0; ci < colCount; ci++) {
+ if (candidates[ci] > 0) {
+ colWidths[ci] += Math.floor((slack * candidates[ci]) / totalWeight);
+ }
+ }
+ }
+ }
+ } else if (totalMin >= effectiveMax) {
+ colWidths = [...minWidths];
+ while (calcW(colWidths) > effectiveMax && colWidths.some((w) => w > 1)) {
+ const widest = colWidths.reduce((maxIdx, width, idx) => (width > colWidths[maxIdx] ? idx : maxIdx), 0);
+ colWidths[widest]--;
+ }
+ } else {
+ // Need to compress — start from mins, share remaining budget proportionally
+ const budget = effectiveMax - totalMin;
+ const deficits = natural.map((n, i) => Math.max(0, n - minWidths[i]));
+ const totalDeficit = deficits.reduce((a, b) => a + b, 0);
+ colWidths = [...minWidths];
+ if (totalDeficit > 0) {
+ for (let ci = 0; ci < colCount; ci++) {
+ colWidths[ci] += Math.floor((budget * deficits[ci]) / totalDeficit);
+ }
+ }
+ // Distribute any leftover due to flooring
+ let used = calcW(colWidths);
+ const deficitByIdx = colWidths.map((w, i) => ({ i, gap: natural[i] - w }));
+ deficitByIdx.sort((a, b) => b.gap - a.gap);
+ for (const { i } of deficitByIdx) {
+ if (used >= effectiveMax) break;
+ if (colWidths[i] < natural[i]) {
+ colWidths[i]++;
+ used = calcW(colWidths);
+ }
+ }
+ }
+
+ // Word-wrap a single cell
+ const wrapCell = (text: string, width: number): string[] => {
+ if (!text) return [""];
+ const lines: string[] = [];
+ let cur = "";
+ const flush = () => {
+ if (cur.trim()) lines.push(cur.replace(/\s+$/, ""));
+ cur = "";
+ };
+
+ for (const ch of text) {
+ const cw = visualWidth(ch);
+ if (visualWidth(cur) + cw > width) {
+ const lastSpace = cur.lastIndexOf(" ");
+ if (lastSpace > width / 3) {
+ const carry = cur.slice(lastSpace + 1);
+ cur = cur.slice(0, lastSpace);
+ flush();
+ cur = carry + ch;
+ } else {
+ flush();
+ cur = ch;
+ }
+ } else {
+ cur += ch;
+ }
+ }
+ if (cur.trim()) lines.push(cur.replace(/\s+$/, ""));
+ return lines.length > 0 ? lines : [""];
+ };
+
+ const wrapped = normalizedRows.map((r) => r.map((c, ci) => wrapCell(c, colWidths[ci])));
+ const heights = wrapped.map((wr) => Math.max(1, ...wr.map((lines) => lines.length)));
+
+ const pad = (s: string, w: number) => s + " ".repeat(Math.max(0, w - visualWidth(s)));
+
+ const top = "┌" + colWidths.map((w) => "─".repeat(w + 2)).join("┬") + "┐";
+ const hdr = "├" + colWidths.map((w) => "─".repeat(w + 2)).join("┼") + "┤";
+ const sep = "├" + colWidths.map((w) => "─".repeat(w + 2)).join("┼") + "┤";
+ const bot = "└" + colWidths.map((w) => "─".repeat(w + 2)).join("┴") + "┘";
+
+ const out: string[] = [top];
+
+ for (let ri = 0; ri < wrapped.length; ri++) {
+ const h = heights[ri];
+ for (let li = 0; li < h; li++) {
+ const line = wrapped[ri].map((cellLines, ci) => " " + pad(cellLines[li] ?? "", colWidths[ci]) + " ");
+ out.push("│" + line.join("│") + "│");
+ }
+ if (ri === 0 && rows.length > 1) out.push(hdr);
+ else if (ri < rows.length - 1) out.push(sep);
+ }
+
+ out.push(bot);
+ return out.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Inline formatting (headings, lists, quotes, bold/italic/code)
+// ---------------------------------------------------------------------------
+
+function renderInlineLine(line: string): string {
+ const headingMatch = /^(\s*)(#{1,6})\s+(.*)$/.exec(line);
+ if (headingMatch) {
+ const [, lead, hashes, content] = headingMatch;
+ const styled = hashes.length <= 2 ? chalk.bold.cyanBright(content) : chalk.bold.cyan(content);
+ return `${lead}${chalk.dim(hashes)} ${styled}`;
+ }
+
+ const listMatch = /^(\s*)([-*+])\s+(.*)$/.exec(line);
+ if (listMatch) {
+ const [, lead, bullet, content] = listMatch;
+ return `${lead}${chalk.yellow(bullet)} ${renderInlineSpans(content)}`;
+ }
+
+ const numListMatch = /^(\s*)(\d+\.)\s+(.*)$/.exec(line);
+ if (numListMatch) {
+ const [, lead, marker, content] = numListMatch;
+ return `${lead}${chalk.yellow(marker)} ${renderInlineSpans(content)}`;
+ }
+
+ const quoteMatch = /^(\s*)>\s?(.*)$/.exec(line);
+ if (quoteMatch) {
+ const [, lead, content] = quoteMatch;
+ return `${lead}${chalk.dim("│ ")}${chalk.italic(renderInlineSpans(content))}`;
+ }
+
+ return renderInlineSpans(line);
+}
+
+function renderInlineSpans(text: string): string {
+ if (!text) return text;
+ let result = text;
+ result = result.replace(/`([^`]+)`/g, (_, inner) => chalk.cyan(inner));
+ result = result.replace(/\*\*([^*]+)\*\*/g, (_, inner) => chalk.bold(inner));
+ result = result.replace(/(? chalk.italic(inner));
+ result = result.replace(/_([^_\n]+)_/g, (_, inner) => chalk.italic(inner));
+ return result;
+}
diff --git a/src/ui/components/MessageView/types.ts b/src/ui/components/MessageView/types.ts
new file mode 100644
index 0000000..743eb2d
--- /dev/null
+++ b/src/ui/components/MessageView/types.ts
@@ -0,0 +1,19 @@
+import type { SessionMessage } from "../../../session";
+
+export type MessageViewProps = {
+ message: SessionMessage;
+ collapsed?: boolean;
+ width?: number;
+};
+export type ToolSummary = {
+ name: string;
+ params: string;
+ ok: boolean;
+ metadata: Record | null;
+};
+
+export type DiffPreviewLine = {
+ marker: string;
+ content: string;
+ kind: "added" | "removed" | "context";
+};
diff --git a/src/ui/components/MessageView/utils.ts b/src/ui/components/MessageView/utils.ts
new file mode 100644
index 0000000..af5391d
--- /dev/null
+++ b/src/ui/components/MessageView/utils.ts
@@ -0,0 +1,286 @@
+import type { DiffPreviewLine, ToolSummary } from "./types";
+import type { SessionMessage } from "../../../session";
+import { RawMode } from "../../contexts";
+import chalk from "chalk";
+
+/** Type guard that checks whether a value is a plain object (not null, not an array). */
+export function isPlainRecord(value: unknown): value is Record {
+ return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+/** Capitalizes the first character of a tool status name, falling back to "Tool". */
+export function formatStatusName(value: string): string {
+ return value ? `${value.charAt(0).toUpperCase()}${value.slice(1)}` : "Tool";
+}
+
+/** Truncates a string to the given maximum length, appending an ellipsis when truncated. */
+export function truncate(value: string, max: number): string {
+ if (value.length <= max) {
+ return value;
+ }
+ return `${value.slice(0, max)}…`;
+}
+
+/** Returns the first non-empty line from a multi-line string, normalizing whitespace. */
+export function firstNonEmptyLine(value: string): string {
+ for (const line of value.split(/\r?\n/)) {
+ const trimmed = line.trim().replace(/\s+/g, " ");
+ if (trimmed) {
+ return trimmed;
+ }
+ }
+ return "";
+}
+
+/**
+ * Builds a one-line summary of thinking / reasoning content.
+ * Falls back to "(reasoning...)" when only reasoning_content params are present.
+ */
+export function buildThinkingSummary(content: string, messageParams: unknown | null, mode?: RawMode): string {
+ if (content) {
+ const normalized = content.replace(/\r?\n/g, " ").replace(/\s+/g, " ");
+ let result = truncate(normalized, 100);
+ if (result.endsWith(":") || result.endsWith("：")) {
+ result = result.slice(0, -1);
+ }
+ return result;
+ }
+
+ const params = messageParams as { reasoning_content?: unknown } | null | undefined;
+ if (typeof params?.reasoning_content === "string" && params.reasoning_content.trim()) {
+ return mode !== RawMode.Lite ? params?.reasoning_content || "" : "(reasoning...)";
+ }
+
+ return "";
+}
+
+/** Formats a tool's parameters for status display, preserving full bash commands but truncating others. */
+export function formatToolStatusParams(summary: ToolSummary): string {
+ const params = firstNonEmptyLine(summary.params);
+ return summary.name.toLowerCase() === "bash" ? params : truncate(params, 120);
+}
+
+/** Builds a structured summary (name, params, ok, metadata) from a tool session message. */
+export function buildToolSummary(message: SessionMessage): ToolSummary {
+ const payload = parseToolPayload(message.content);
+ const metaFunctionName =
+ message.meta?.function && typeof (message.meta.function as { name?: unknown }).name === "string"
+ ? (message.meta.function as { name: string }).name
+ : null;
+ const name = payload.name || metaFunctionName || "tool";
+ const params =
+ name === "AskUserQuestion"
+ ? extractAskUserQuestionParams(message) || getMetaParams(message)
+ : getMetaParams(message);
+
+ return {
+ name,
+ params,
+ ok: payload.ok !== false,
+ metadata: payload.metadata,
+ };
+}
+
+/** Extracts the paramsMd field from a session message's metadata, trimmed. */
+export function getMetaParams(message: SessionMessage): string {
+ return typeof message.meta?.paramsMd === "string" ? message.meta.paramsMd.trim() : "";
+}
+
+/**
+ * Extracts human-readable question text from an AskUserQuestion tool message.
+ * Tries the tool function arguments first, then falls back to parsing metadata params.
+ */
+export function extractAskUserQuestionParams(message: SessionMessage): string {
+ const fromFunction = extractQuestionsFromToolFunction(message.meta?.function);
+ if (fromFunction) {
+ return fromFunction;
+ }
+
+ const params = getMetaParams(message);
+ if (!params) {
+ return "";
+ }
+
+ try {
+ const parsed = JSON.parse(params);
+ return extractQuestionsFromValue(parsed);
+ } catch {
+ return "";
+ }
+}
+
+/**
+ * Extracts question strings from a tool function object by parsing its JSON arguments.
+ */
+export function extractQuestionsFromToolFunction(toolFunction: unknown): string {
+ if (!toolFunction || typeof toolFunction !== "object") {
+ return "";
+ }
+ const args = (toolFunction as { arguments?: unknown }).arguments;
+ if (typeof args !== "string" || !args.trim()) {
+ return "";
+ }
+ try {
+ const parsed = JSON.parse(args);
+ return extractQuestionsFromValue((parsed as { questions?: unknown })?.questions);
+ } catch {
+ return "";
+ }
+}
+
+/** Extracts and joins question strings from an array of question objects. */
+export function extractQuestionsFromValue(value: unknown): string {
+ if (!Array.isArray(value)) {
+ return "";
+ }
+ return value
+ .map((item) => {
+ if (!item || typeof item !== "object" || Array.isArray(item)) {
+ return "";
+ }
+ return typeof (item as { question?: unknown }).question === "string"
+ ? (item as { question: string }).question.trim()
+ : "";
+ })
+ .filter(Boolean)
+ .join(" / ");
+}
+
+/** Parses a tool's JSON payload, extracting name, ok flag, and metadata. */
+export function parseToolPayload(content: string | null): {
+ name: string | null;
+ ok: boolean;
+ metadata: Record | null;
+} {
+ if (!content) {
+ return { name: null, ok: true, metadata: null };
+ }
+
+ try {
+ const parsed = JSON.parse(content) as { name?: unknown; ok?: unknown; metadata?: unknown };
+ return {
+ name: typeof parsed.name === "string" && parsed.name.trim() ? parsed.name.trim() : null,
+ ok: parsed.ok !== false,
+ metadata: isPlainRecord(parsed.metadata) ? parsed.metadata : null,
+ };
+ } catch {
+ return { name: null, ok: true, metadata: null };
+ }
+}
+
+/**
+ * Returns structured diff preview lines for successful edit or write tool calls.
+ * Returns an empty array if the tool is not edit/write or has no diff_preview metadata.
+ */
+export function getToolDiffPreviewLines(summary: ToolSummary): DiffPreviewLine[] {
+ if (!summary.ok || !["edit", "write"].includes(summary.name.toLowerCase())) {
+ return [];
+ }
+ const diffPreview = summary.metadata?.diff_preview;
+ if (typeof diffPreview !== "string" || !diffPreview.trim()) {
+ return [];
+ }
+ return parseDiffPreview(diffPreview);
+}
+
+/** Parses a unified-diff-style preview string into an array of structured diff lines. */
+export function parseDiffPreview(diffPreview: string): DiffPreviewLine[] {
+ return diffPreview
+ .split("\n")
+ .filter((line) => line && !line.startsWith("--- ") && !line.startsWith("+++ ") && !line.startsWith("@@ "))
+ .map((line) => {
+ if (line.startsWith("+")) {
+ return { marker: "+", content: line.slice(1), kind: "added" };
+ }
+ if (line.startsWith("-")) {
+ return { marker: "-", content: line.slice(1), kind: "removed" };
+ }
+ return {
+ marker: " ",
+ content: line.startsWith(" ") ? line.slice(1) : line,
+ kind: "context",
+ };
+ });
+}
+
+export function renderMessageToStdout(message: SessionMessage, mode: RawMode): string {
+ if (!message.visible) {
+ return "";
+ }
+
+ if (message.role === "user") {
+ const text = message.content || "(no content)";
+ return chalk(`> ${text}`);
+ }
+
+ if (message.role === "assistant") {
+ const isThinking = Boolean(message.meta?.asThinking);
+ const content = (message.content || "").trim();
+
+ if (isThinking) {
+ const summary = buildThinkingSummary(content, message.messageParams, mode);
+ return `${chalk("✧")} ${chalk("Thinking")}${summary ? ` ${chalk(summary)}` : ""}`;
+ }
+
+ return `${chalk("✦")} ${content}`;
+ }
+
+ if (message.role === "tool") {
+ const payload = parseToolPayload(message.content);
+ const metaFunctionName =
+ message.meta?.function && typeof (message.meta.function as { name?: unknown }).name === "string"
+ ? (message.meta.function as { name: string }).name
+ : null;
+ const name = payload.name || metaFunctionName || "tool";
+ const metaParams = typeof message.meta?.paramsMd === "string" ? message.meta.paramsMd.trim() : "";
+ const params = name.toLowerCase() === "bash" ? metaParams : truncate(metaParams, 120);
+ const statusLine = `${chalk("✧")} ${chalk(formatStatusName(name))}${params ? ` ${chalk(params)}` : ""}`;
+
+ const metaResultMd = typeof message.meta?.resultMd === "string" ? message.meta.resultMd.trim() : "";
+ const result = metaResultMd ? `\n${chalk.dim(" └ Result")}\n${metaResultMd}` : "";
+
+ const summary: ToolSummary = {
+ name,
+ params,
+ ok: payload.ok !== false,
+ metadata: payload.metadata,
+ };
+ const planLines = getUpdatePlanPreviewLines(summary);
+ if (planLines.length > 0) {
+ const planText = planLines.map((line) => ` ${line}`).join("\n");
+ return `${statusLine}\n${chalk.dim(" └ Plan")}\n${planText}${result}`;
+ }
+
+ return `${statusLine}${result}`;
+ }
+
+ if (message.role === "system") {
+ if (message.meta?.isModelChange) {
+ return chalk(`> ${message.content}`);
+ }
+ if (message.meta?.skill && typeof message.meta.skill === "object") {
+ const skillName = (message.meta.skill as { name?: unknown }).name;
+ return chalk(`⚡ Loaded skill: ${typeof skillName === "string" ? skillName : ""}`);
+ }
+ if (message.meta?.isSummary) {
+ return chalk.dim.italic("(conversation summary inserted)");
+ }
+ return "";
+ }
+
+ return "";
+}
+
+export function getUpdatePlanPreviewLines(summary: ToolSummary): string[] {
+ if (!summary.ok || summary.name !== "UpdatePlan") {
+ return [];
+ }
+ const plan = summary.metadata?.plan;
+ if (typeof plan !== "string" || !plan.trim()) {
+ return [];
+ }
+ return plan
+ .split(/\r?\n/)
+ .map((line) => line.trimEnd())
+ .filter((line) => line.trim().length > 0);
+}
diff --git a/src/ui/components/ModelsDropdown/index.tsx b/src/ui/components/ModelsDropdown/index.tsx
new file mode 100644
index 0000000..bdd68ab
--- /dev/null
+++ b/src/ui/components/ModelsDropdown/index.tsx
@@ -0,0 +1,165 @@
+import React, { useEffect, useState } from "react";
+import { useInput } from "ink";
+import DropdownMenu from "../../DropdownMenu";
+import type { ModelConfigSelection, ReasoningEffort } from "../../../settings";
+
+type ModelStep = "model" | "thinking";
+
+type ThinkingModeOption = {
+ label: string;
+ thinkingEnabled: boolean;
+ reasoningEffort?: ReasoningEffort;
+};
+
+export const MODEL_COMMAND_MODELS = ["deepseek-v4-pro", "deepseek-v4-flash"] as const;
+
+export const MODEL_COMMAND_THINKING_OPTIONS: ThinkingModeOption[] = [
+ { label: "Thinking mode [max]", thinkingEnabled: true, reasoningEffort: "max" },
+ { label: "Thinking mode [high]", thinkingEnabled: true, reasoningEffort: "high" },
+ { label: "No thinking", thinkingEnabled: false },
+];
+
+function getThinkingOptionIndex(config: Pick): number {
+ const index = MODEL_COMMAND_THINKING_OPTIONS.findIndex((option) => {
+ if (!config.thinkingEnabled) {
+ return !option.thinkingEnabled;
+ }
+ return option.thinkingEnabled && option.reasoningEffort === config.reasoningEffort;
+ });
+ return index >= 0 ? index : 0;
+}
+
+type Props = {
+ open: boolean;
+ modelConfig: ModelConfigSelection;
+ width: number;
+ onClose: () => void;
+ onModelConfigChange: (selection: ModelConfigSelection) => string | Promise;
+ onStatusMessage?: (message: string | null) => void;
+};
+
+const ModelsDropdown: React.FC = ({
+ open,
+ modelConfig,
+ width,
+ onClose,
+ onModelConfigChange,
+ onStatusMessage,
+}) => {
+ const [step, setStep] = useState(null);
+ const [activeIndex, setActiveIndex] = useState(0);
+ const [pendingModel, setPendingModel] = useState(null);
+
+ // Initialize state when opened
+ useEffect(() => {
+ if (open) {
+ const currentIndex = MODEL_COMMAND_MODELS.findIndex((m) => m === modelConfig.model);
+ setPendingModel(null);
+ setStep("model");
+ setActiveIndex(currentIndex >= 0 ? currentIndex : 0);
+ } else {
+ setStep(null);
+ }
+ }, [open, modelConfig.model]);
+
+ // Validate activeIndex bounds
+ useEffect(() => {
+ if (!step) {
+ return;
+ }
+ const optionCount = step === "model" ? MODEL_COMMAND_MODELS.length : MODEL_COMMAND_THINKING_OPTIONS.length;
+ if (activeIndex >= optionCount) {
+ setActiveIndex(Math.max(0, optionCount - 1));
+ }
+ }, [activeIndex, step]);
+
+ function selectItem(): void {
+ if (step === "model") {
+ const model = MODEL_COMMAND_MODELS[activeIndex] ?? modelConfig.model;
+ setPendingModel(model);
+ setStep("thinking");
+ setActiveIndex(getThinkingOptionIndex(modelConfig));
+ return;
+ }
+
+ const option = MODEL_COMMAND_THINKING_OPTIONS[activeIndex] ?? MODEL_COMMAND_THINKING_OPTIONS[0]!;
+ const selection: ModelConfigSelection = {
+ model: pendingModel ?? modelConfig.model,
+ thinkingEnabled: option.thinkingEnabled,
+ reasoningEffort: option.reasoningEffort ?? modelConfig.reasoningEffort,
+ };
+ onClose();
+ Promise.resolve(onModelConfigChange(selection))
+ .then((message) => {
+ if (message) {
+ onStatusMessage?.(message);
+ }
+ })
+ .catch((error) => {
+ const msg = error instanceof Error ? error.message : String(error);
+ onStatusMessage?.(`Failed to update model settings: ${msg}`);
+ });
+ }
+
+ useInput(
+ (input, key) => {
+ if (!step) {
+ return;
+ }
+
+ const optionCount = step === "model" ? MODEL_COMMAND_MODELS.length : MODEL_COMMAND_THINKING_OPTIONS.length;
+
+ if (key.upArrow) {
+ setActiveIndex((idx) => (idx - 1 + optionCount) % optionCount);
+ return;
+ }
+ if (key.downArrow) {
+ setActiveIndex((idx) => (idx + 1) % optionCount);
+ return;
+ }
+ if ((input === " " && !key.ctrl && !key.meta) || (key.return && !key.shift && !key.meta)) {
+ selectItem();
+ return;
+ }
+ if (key.tab || key.escape) {
+ onClose();
+ return;
+ }
+ },
+ { isActive: open }
+ );
+
+ if (!open || !step) {
+ return null;
+ }
+
+ const items =
+ step === "model"
+ ? MODEL_COMMAND_MODELS.map((model) => ({
+ key: model,
+ label: model,
+ description: model === modelConfig.model ? "current model" : "",
+ selected: model === (pendingModel ?? modelConfig.model),
+ }))
+ : MODEL_COMMAND_THINKING_OPTIONS.map((option, i) => ({
+ key: option.label,
+ label: option.label,
+ description: option.thinkingEnabled ? `reasoningEffort: ${option.reasoningEffort}` : "thinking disabled",
+ selected: getThinkingOptionIndex(modelConfig) === i,
+ }));
+
+ return (
+
+ );
+};
+
+export { getThinkingOptionIndex };
+export default ModelsDropdown;
diff --git a/src/ui/components/RawModeExitPrompt/index.tsx b/src/ui/components/RawModeExitPrompt/index.tsx
new file mode 100644
index 0000000..57ebf07
--- /dev/null
+++ b/src/ui/components/RawModeExitPrompt/index.tsx
@@ -0,0 +1,20 @@
+import { useRef, type ReactElement } from "react";
+import { useInput } from "ink";
+import { useRawModeContext, type RawMode } from "../../contexts";
+
+export function RawModeExitPrompt({ onExit }: { onExit: (previousMode: RawMode) => void }): ReactElement | null {
+ const { previousMode } = useRawModeContext();
+ // Snapshot the prior mode at mount so later context updates do not change the ESC target.
+ const snapshotRef = useRef(previousMode);
+
+ useInput(
+ (_input, key) => {
+ if (key.escape) {
+ onExit(snapshotRef.current);
+ }
+ },
+ { isActive: true }
+ );
+
+ return null;
+}
diff --git a/src/ui/components/RawModelDropdown/index.tsx b/src/ui/components/RawModelDropdown/index.tsx
new file mode 100644
index 0000000..3397013
--- /dev/null
+++ b/src/ui/components/RawModelDropdown/index.tsx
@@ -0,0 +1,55 @@
+import React, { useState } from "react";
+import { useInput } from "ink";
+import DropdownMenu from "../../DropdownMenu";
+import type { RawMode } from "../../contexts";
+import { RAW_COMMAND_MODELS, useRawModeContext } from "../../contexts";
+
+const RawModelDropdown: React.FC<{
+ open: boolean;
+ screenWidth: number;
+ onClose?: (value: boolean) => void;
+ onSelect?: (model: string) => void;
+}> = ({ open = false, screenWidth, onSelect, onClose }) => {
+ const { mode, setMode } = useRawModeContext();
+ const [index, setIndex] = useState(0);
+ useInput(
+ (input, key) => {
+ if (key.upArrow) {
+ setIndex((i) => Math.max(0, i - 1));
+ return;
+ }
+ if (key.downArrow) {
+ setIndex((i) => Math.min(RAW_COMMAND_MODELS.length - 1, i + 1));
+ return;
+ }
+ if ((input === " " && !key.ctrl && !key.meta) || (key.return && !key.shift && !key.meta)) {
+ setMode(RAW_COMMAND_MODELS[index].key as RawMode);
+ onClose?.(false);
+ onSelect?.(RAW_COMMAND_MODELS[index].key);
+ return;
+ }
+ if (key.escape) {
+ onClose?.(false);
+ return;
+ }
+ },
+ { isActive: open }
+ );
+ if (!open) {
+ return null;
+ }
+ return (
+ ({ ...model, selected: model.key === mode }))}
+ helpText="Space/Enter select mode · Esc to close"
+ // onSelect={onSelect}
+ activeColor="#229ac3"
+ maxVisible={6}
+ activeIndex={index}
+ width={screenWidth}
+ />
+ );
+};
+
+export default RawModelDropdown;
diff --git a/src/ui/components/SkillsDropdown/index.tsx b/src/ui/components/SkillsDropdown/index.tsx
new file mode 100644
index 0000000..b320d24
--- /dev/null
+++ b/src/ui/components/SkillsDropdown/index.tsx
@@ -0,0 +1,74 @@
+import DropdownMenu from "../../DropdownMenu";
+import React, { useEffect, useState } from "react";
+import type { SkillInfo } from "../../../session";
+import { useInput } from "ink";
+import { isSkillSelected } from "../../SlashCommandMenu";
+
+const SkillsDropdown: React.FC<{
+ open: boolean;
+ onClose?: (value: boolean) => void;
+ width: number;
+ skills: SkillInfo[];
+ selectedSkills: SkillInfo[];
+ onSelect?: (skill: SkillInfo) => void;
+}> = ({ open, width, skills, selectedSkills, onSelect, onClose }) => {
+ const [skillsDropdownIndex, setSkillsDropdownIndex] = useState(0);
+ useInput(
+ (input, key) => {
+ if (key.upArrow) {
+ setSkillsDropdownIndex((idx) => (idx - 1 + skills.length) % skills.length);
+ return;
+ }
+ if (key.downArrow) {
+ setSkillsDropdownIndex((idx) => (idx + 1) % skills.length);
+ return;
+ }
+ if ((input === " " && !key.ctrl && !key.meta) || (key.return && !key.shift && !key.meta)) {
+ const skill = skills[skillsDropdownIndex];
+ if (skill) {
+ onSelect?.(skill);
+ }
+ return;
+ }
+ if (key.tab) {
+ onClose?.(false);
+ return;
+ }
+ if (key.escape) {
+ onClose?.(false);
+ }
+ },
+ { isActive: open }
+ );
+
+ useEffect(() => {
+ if (skillsDropdownIndex >= skills.length) {
+ setSkillsDropdownIndex(Math.max(0, skills.length - 1));
+ }
+ }, [skills.length, skillsDropdownIndex]);
+
+ if (!open) {
+ return null;
+ }
+
+ return (
+ ({
+ key: skill.path || skill.name,
+ label: skill.name,
+ description: skill.path,
+ selected: isSkillSelected(selectedSkills, skill),
+ statusIndicator: skill.isLoaded ? { symbol: "✓", color: "green" } : undefined,
+ }))}
+ activeIndex={skillsDropdownIndex}
+ activeColor="#229ac3"
+ maxVisible={6}
+ />
+ );
+};
+
+export default SkillsDropdown;
diff --git a/src/ui/components/index.ts b/src/ui/components/index.ts
new file mode 100644
index 0000000..635f733
--- /dev/null
+++ b/src/ui/components/index.ts
@@ -0,0 +1,6 @@
+export { default as RawModelDropdown } from "./RawModelDropdown";
+export { MessageView } from "./MessageView";
+export { RawModeExitPrompt } from "./RawModeExitPrompt";
+export { default as SkillsDropdown } from "./SkillsDropdown";
+export { default as ModelsDropdown } from "./ModelsDropdown";
+export { default as FileMentionMenu } from "./FileMentionMenu";
diff --git a/src/ui/constants.ts b/src/ui/constants.ts
new file mode 100644
index 0000000..43372f8
--- /dev/null
+++ b/src/ui/constants.ts
@@ -0,0 +1,7 @@
+// UI-level shared constants used across components.
+
+/** Separator used when rendering command arguments inline (e.g., `arg1 | arg2 | arg3`). */
+export const ARGS_SEPARATOR = " | ";
+
+/** ANSI escape code to clear the screen. */
+export const ANSI_CLEAR_SCREEN = "\u001B[2J\u001B[3J\u001B[H";
diff --git a/src/ui/contexts/AppContext.tsx b/src/ui/contexts/AppContext.tsx
new file mode 100644
index 0000000..41b1d1d
--- /dev/null
+++ b/src/ui/contexts/AppContext.tsx
@@ -0,0 +1,16 @@
+import { createContext, useContext } from "react";
+
+export interface AppState {
+ version: string;
+}
+
+export const AppContext = createContext(null);
+
+export const useAppContext = (): AppState => {
+ const context = useContext(AppContext);
+ if (!context) {
+ // Safe fallback when App is rendered without AppContainer (e.g., in tests).
+ return { version: "unknown" };
+ }
+ return context;
+};
diff --git a/src/ui/contexts/RawModeContext.tsx b/src/ui/contexts/RawModeContext.tsx
new file mode 100644
index 0000000..3198a3a
--- /dev/null
+++ b/src/ui/contexts/RawModeContext.tsx
@@ -0,0 +1,67 @@
+import React, { createContext, useCallback, useContext, useRef, useState } from "react";
+import type { DropdownMenuItem } from "../DropdownMenu";
+
+export enum RawMode {
+ None = "Normal mode",
+ Lite = "Lite mode",
+ Raw = "Raw scrollback mode",
+}
+export const RAW_COMMAND_MODELS: DropdownMenuItem[] = [
+ {
+ label: "Lite mode",
+ key: RawMode.Lite,
+ description: "Collapse chain-of-thought reasoning.",
+ },
+ {
+ label: "Normal mode",
+ key: RawMode.None,
+ description: "Show full chain-of-thought reasoning.",
+ },
+ {
+ label: "Raw scrollback mode",
+ key: RawMode.Raw,
+ description: "Show scrollback mode for copy-friendly terminal selection.",
+ },
+] as const;
+
+type RawModeContextValue = {
+ mode: RawMode;
+ setMode: React.Dispatch>;
+ // The mode that was active right before the most recent mode transition.
+ previousMode: RawMode;
+};
+
+const RawModeContext = createContext({
+ mode: RawMode.Lite,
+ setMode: () => {},
+ previousMode: RawMode.Lite,
+});
+
+export function useRawModeContext() {
+ const context = useContext(RawModeContext);
+ if (!context) {
+ throw new Error("useRawModeContext must be used within a RawModeProvider");
+ }
+ return context;
+}
+
+export const RawModeProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+ const [mode, _setMode] = useState(RawMode.Lite);
+ const previousModeRef = useRef(RawMode.Lite);
+
+ const setMode = useCallback>>((next) => {
+ _setMode((current) => {
+ const resolved = typeof next === "function" ? (next as (prev: RawMode) => RawMode)(current) : next;
+ if (resolved !== current) {
+ previousModeRef.current = current;
+ }
+ return resolved;
+ });
+ }, []);
+
+ return (
+
+ {children}
+
+ );
+};
diff --git a/src/ui/contexts/index.ts b/src/ui/contexts/index.ts
new file mode 100644
index 0000000..37e40cd
--- /dev/null
+++ b/src/ui/contexts/index.ts
@@ -0,0 +1,3 @@
+export { AppContext, useAppContext } from "./AppContext";
+export type { AppState } from "./AppContext";
+export { RawMode, RAW_COMMAND_MODELS, useRawModeContext, RawModeProvider } from "./RawModeContext";
diff --git a/src/ui/index.ts b/src/ui/index.ts
index 5bcde40..1348903 100644
--- a/src/ui/index.ts
+++ b/src/ui/index.ts
@@ -1,21 +1,28 @@
+import {
+ getThinkingOptionIndex,
+ MODEL_COMMAND_MODELS,
+ MODEL_COMMAND_THINKING_OPTIONS,
+} from "./components/ModelsDropdown";
+
export {
- App,
readSettings,
readProjectSettings,
writeSettings,
writeProjectSettings,
writeModelConfigSelection,
resolveCurrentSettings,
- createOpenAIClient,
+ buildPromptDraftFromSessionMessage,
} from "./App";
+export { createOpenAIClient } from "../common/openai-client";
+export { default as AppContainer } from "./AppContainer";
export { AskUserQuestionPrompt } from "./AskUserQuestionPrompt";
-export { MessageView, parseDiffPreview } from "./MessageView";
+export { MessageView } from "./components";
+export { parseDiffPreview } from "./components/MessageView/utils";
export {
PromptInput,
IMAGE_ATTACHMENT_CLEAR_HINT,
formatImageAttachmentStatus,
formatSelectedSkillsStatus,
- isSkillSelected,
addUniqueSkill,
toggleSkillSelection,
removeCurrentSlashToken,
@@ -23,16 +30,16 @@ export {
getPromptReturnKeyAction,
renderBufferWithCursor,
buildInitPromptSubmission,
- getThinkingOptionIndex,
- MODEL_COMMAND_MODELS,
- MODEL_COMMAND_THINKING_OPTIONS,
useTerminalInput,
parseTerminalInput,
+ dispatchTerminalInput,
type PromptSubmission,
+ type PromptDraft,
type InputKey,
} from "./PromptInput";
+export { getThinkingOptionIndex, MODEL_COMMAND_MODELS, MODEL_COMMAND_THINKING_OPTIONS };
export { disableTerminalExtendedKeys, enableTerminalExtendedKeys, getPromptCursorPlacement } from "./prompt/cursor";
-export { SessionList, formatSessionTitle } from "./SessionList";
+export { SessionList, formatSessionTitle, filterSessions, formatSessionStatus } from "./SessionList";
export { ThemedGradient } from "./ThemedGradient";
export { UpdatePrompt, type UpdatePromptChoice } from "./UpdatePrompt";
export { WelcomeScreen, formatHomeRelativePath, buildWelcomeTips } from "./WelcomeScreen";
@@ -47,7 +54,7 @@ export {
} from "./askUserQuestion";
export { readClipboardImage, type ClipboardImage } from "./clipboard";
export { buildLoadingText, type LoadingTextInput } from "./loadingText";
-export { renderMarkdown } from "./markdown";
+export { renderMarkdown, renderMarkdownSegments, type MarkdownSegment } from "./components/MessageView/markdown";
export {
EMPTY_BUFFER,
insertText,
diff --git a/src/ui/markdown.ts b/src/ui/markdown.ts
deleted file mode 100644
index 11fb0ea..0000000
--- a/src/ui/markdown.ts
+++ /dev/null
@@ -1,117 +0,0 @@
-import chalk from "chalk";
-
-export function renderMarkdown(text: string): string {
- if (!text) {
- return "";
- }
-
- const fenceSegments = splitByFences(text);
- return fenceSegments
- .map((segment) => {
- if (segment.kind === "code") {
- const langTag = segment.lang ? chalk.dim(`[${segment.lang}]`) + "\n" : "";
- return langTag + chalk.cyan(segment.body);
- }
- return renderInlineBlock(segment.body);
- })
- .join("");
-}
-
-type FenceSegment = { kind: "text"; body: string } | { kind: "code"; lang: string; body: string };
-
-function splitByFences(text: string): FenceSegment[] {
- const segments: FenceSegment[] = [];
- const lines = text.split(/\r?\n/);
- let buffer: string[] = [];
- let inFence = false;
- let fenceLang = "";
- let fenceBody: string[] = [];
-
- const flushText = () => {
- if (buffer.length === 0) {
- return;
- }
- segments.push({ kind: "text", body: buffer.join("\n") });
- buffer = [];
- };
-
- for (const line of lines) {
- const fenceMatch = /^\s*```(\w*)\s*$/.exec(line);
- if (fenceMatch) {
- if (!inFence) {
- flushText();
- inFence = true;
- fenceLang = fenceMatch[1] ?? "";
- fenceBody = [];
- } else {
- segments.push({ kind: "code", lang: fenceLang, body: fenceBody.join("\n") });
- inFence = false;
- fenceLang = "";
- fenceBody = [];
- }
- continue;
- }
-
- if (inFence) {
- fenceBody.push(line);
- } else {
- buffer.push(line);
- }
- }
-
- if (inFence) {
- segments.push({ kind: "code", lang: fenceLang, body: fenceBody.join("\n") });
- } else {
- flushText();
- }
-
- return segments;
-}
-
-function renderInlineBlock(text: string): string {
- return text
- .split("\n")
- .map((line) => renderInlineLine(line))
- .join("\n");
-}
-
-function renderInlineLine(line: string): string {
- const headingMatch = /^(\s*)(#{1,6})\s+(.*)$/.exec(line);
- if (headingMatch) {
- const [, lead, hashes, content] = headingMatch;
- const styled = hashes.length <= 2 ? chalk.bold.cyanBright(content) : chalk.bold.cyan(content);
- return `${lead}${chalk.dim(hashes)} ${styled}`;
- }
-
- const listMatch = /^(\s*)([-*+])\s+(.*)$/.exec(line);
- if (listMatch) {
- const [, lead, bullet, content] = listMatch;
- return `${lead}${chalk.yellow(bullet)} ${renderInlineSpans(content)}`;
- }
-
- const numListMatch = /^(\s*)(\d+\.)\s+(.*)$/.exec(line);
- if (numListMatch) {
- const [, lead, marker, content] = numListMatch;
- return `${lead}${chalk.yellow(marker)} ${renderInlineSpans(content)}`;
- }
-
- const quoteMatch = /^(\s*)>\s?(.*)$/.exec(line);
- if (quoteMatch) {
- const [, lead, content] = quoteMatch;
- return `${lead}${chalk.dim("│ ")}${chalk.italic(renderInlineSpans(content))}`;
- }
-
- return renderInlineSpans(line);
-}
-
-function renderInlineSpans(text: string): string {
- if (!text) {
- return text;
- }
- let result = text;
- result = result.replace(/`([^`]+)`/g, (_, inner) => chalk.cyan(inner));
- result = result.replace(/\*\*([^*]+)\*\*/g, (_, inner) => chalk.bold(inner));
- result = result.replace(/(? chalk.italic(inner));
- result = result.replace(/_([^_\n]+)_/g, (_, inner) => chalk.italic(inner));
- return result;
-}
diff --git a/src/ui/prompt/cursor.ts b/src/ui/prompt/cursor.ts
index 2668470..aefea34 100644
--- a/src/ui/prompt/cursor.ts
+++ b/src/ui/prompt/cursor.ts
@@ -40,6 +40,14 @@ function disableTerminalFocusReporting(): string {
return "\u001B[?1004l";
}
+function enableBracketedPaste(): string {
+ return "\u001B[?2004h";
+}
+
+function disableBracketedPaste(): string {
+ return "\u001B[?2004l";
+}
+
export function enableTerminalExtendedKeys(): string {
return "\u001B[>4;1m";
}
@@ -260,3 +268,16 @@ export function useTerminalExtendedKeys(stdout: NodeJS.WriteStream | undefined,
};
}, [isActive, stdout]);
}
+
+export function useBracketedPaste(stdout: NodeJS.WriteStream | undefined, isActive: boolean): void {
+ useLayoutEffect(() => {
+ if (!isActive || !stdout?.isTTY) {
+ return;
+ }
+
+ stdout.write(enableBracketedPaste());
+ return () => {
+ stdout.write(disableBracketedPaste());
+ };
+ }, [isActive, stdout]);
+}
diff --git a/src/ui/prompt/index.ts b/src/ui/prompt/index.ts
index a33172c..6435f62 100644
--- a/src/ui/prompt/index.ts
+++ b/src/ui/prompt/index.ts
@@ -1,9 +1,10 @@
-export { useTerminalInput, parseTerminalInput } from "./useTerminalInput";
+export { useTerminalInput, parseTerminalInput, dispatchTerminalInput } from "./useTerminalInput";
export type { InputKey } from "./useTerminalInput";
export {
useHiddenTerminalCursor,
useTerminalExtendedKeys,
+ useBracketedPaste,
usePromptTerminalCursor,
useTerminalFocusReporting,
getPromptCursorPlacement,
diff --git a/src/ui/prompt/useTerminalInput.ts b/src/ui/prompt/useTerminalInput.ts
index 8013ff6..e3d6349 100644
--- a/src/ui/prompt/useTerminalInput.ts
+++ b/src/ui/prompt/useTerminalInput.ts
@@ -20,6 +20,8 @@ export type InputKey = {
meta: boolean;
focusIn: boolean;
focusOut: boolean;
+ /** True when the input came from a bracketed paste (ESC[200~ ... ESC[201~). */
+ paste: boolean;
};
const BACKSPACE_BYTES = new Set(["\u007F", "\b"]);
@@ -35,6 +37,13 @@ const META_RIGHT_SEQUENCES = new Set(["\u001B[1;3C", "\u001B[3C", "\u001Bf"]);
const TERMINAL_FOCUS_IN = "\u001B[I";
const TERMINAL_FOCUS_OUT = "\u001B[O";
+// Bracketed paste mode markers (xterm-style).
+// When the terminal supports bracketed paste, pasted text is wrapped with:
+// ESC[200~ ...pasted content... ESC[201~
+const PASTE_START = "\u001B[200~";
+const PASTE_END = "\u001B[201~";
+const PASTE_END_LENGTH = 6; // length of PASTE_END
+
// Ctrl+- (minus) sequences in modifyOtherKeys mode.
// \u001B[45;5u — standard format: keycode=45 ('-'), modifier=5 (Ctrl)
// \u001B[27;5;45~ — extended format for function-like reporting
@@ -73,6 +82,7 @@ export function parseTerminalInput(data: Buffer | string): { input: string; key:
meta: false,
focusIn: false,
focusOut: false,
+ paste: false,
};
return { input, key };
}
@@ -100,6 +110,7 @@ export function parseTerminalInput(data: Buffer | string): { input: string; key:
meta: false,
focusIn: false,
focusOut: false,
+ paste: false,
};
return { input, key };
}
@@ -123,6 +134,7 @@ export function parseTerminalInput(data: Buffer | string): { input: string; key:
meta: META_LEFT_SEQUENCES.has(raw) || META_RIGHT_SEQUENCES.has(raw) || META_RETURN_SEQUENCES.has(raw),
focusIn: raw === TERMINAL_FOCUS_IN,
focusOut: raw === TERMINAL_FOCUS_OUT,
+ paste: false,
};
if (input <= "\u001A" && !key.return) {
@@ -169,6 +181,60 @@ export function parseTerminalInput(data: Buffer | string): { input: string; key:
return { input, key };
}
+export function dispatchTerminalInput(
+ data: Buffer | string,
+ inputHandler: (input: string, key: InputKey) => void
+): void {
+ const raw = String(data);
+
+ // Fix CJK composition bug on iOS terminals (Moshi, Blink, etc.).
+ // iOS keyboards can send composed characters as a single packet like:
+ // "가\x7f나" (character + backspace + replacement character)
+ // Do not split escape-prefixed sequences such as Alt+Backspace.
+ if (!raw.startsWith("\u001B") && raw.includes("\x7f") && raw.length > 1) {
+ const parts = raw.split("\x7f");
+ if (parts[0]) {
+ const { input, key } = parseTerminalInput(parts[0]);
+ inputHandler(input, key);
+ }
+ for (let i = 1; i < parts.length; i++) {
+ const bs = parseTerminalInput("\x7f");
+ inputHandler(bs.input, bs.key);
+ if (parts[i]) {
+ const { input, key } = parseTerminalInput(parts[i]);
+ inputHandler(input, key);
+ }
+ }
+ return;
+ }
+
+ const { input, key } = parseTerminalInput(data);
+ inputHandler(input, key);
+}
+
+/** An InputKey with all fields false (including paste). Used when dispatching paste events. */
+const EMPTY_KEY: InputKey = {
+ upArrow: false,
+ downArrow: false,
+ leftArrow: false,
+ rightArrow: false,
+ home: false,
+ end: false,
+ pageDown: false,
+ pageUp: false,
+ return: false,
+ escape: false,
+ ctrl: false,
+ shift: false,
+ tab: false,
+ backspace: false,
+ delete: false,
+ meta: false,
+ focusIn: false,
+ focusOut: false,
+ paste: false,
+};
+
export function useTerminalInput(
inputHandler: (input: string, key: InputKey) => void,
options: { isActive?: boolean } = {}
@@ -178,8 +244,15 @@ export function useTerminalInput(
const handlerRef = useRef(inputHandler);
handlerRef.current = inputHandler;
+ // Mutable paste-bracketing state shared across data events.
+ // Uses an array of chunks instead of string concatenation to avoid
+ // O(n²) copying when the terminal splits a large paste across many events.
+ const pasteRef = useRef({ active: false, chunks: [] as string[] });
+
useEffect(() => {
if (!isActive) {
+ pasteRef.current.active = false;
+ pasteRef.current.chunks = [];
return;
}
setRawMode(true);
@@ -192,9 +265,76 @@ export function useTerminalInput(
if (!isActive) {
return;
}
+
const handleData = (data: Buffer | string) => {
- const { input, key } = parseTerminalInput(data);
- handlerRef.current(input, key);
+ const raw = String(data);
+
+ // ----- Bracketed paste handling -----
+ // Most terminals send the start/end markers in the same chunk as
+ // the content. We handle both inline and multi-chunk scenarios.
+
+ if (raw.includes(PASTE_START)) {
+ pasteRef.current.active = true;
+ pasteRef.current.chunks = [];
+
+ // Extract content after the start marker.
+ const startIdx = raw.indexOf(PASTE_START);
+ const afterStart = raw.slice(startIdx + PASTE_START.length);
+
+ // Check if the end marker is also in this same chunk.
+ const endIdx = afterStart.indexOf(PASTE_END);
+ if (endIdx !== -1) {
+ // Both markers in one chunk — process immediately.
+ const pasteContent = afterStart.slice(0, endIdx);
+ pasteRef.current.active = false;
+ const remaining = afterStart.slice(endIdx + PASTE_END_LENGTH);
+
+ if (pasteContent.length > 0) {
+ handlerRef.current(pasteContent, { ...EMPTY_KEY, paste: true });
+ }
+ if (remaining.length > 0) {
+ dispatchTerminalInput(remaining, handlerRef.current);
+ }
+ return;
+ }
+
+ // Only start marker — buffer as first chunk.
+ if (afterStart) {
+ pasteRef.current.chunks.push(afterStart);
+ }
+ return;
+ }
+
+ if (pasteRef.current.active) {
+ pasteRef.current.chunks.push(raw);
+ // Only join+search when this chunk might contain the end marker.
+ if (raw.includes("201~")) {
+ const combined = pasteRef.current.chunks.join("");
+ const endIdx = combined.indexOf(PASTE_END);
+ if (endIdx !== -1) {
+ const pasteContent = combined.slice(0, endIdx);
+ pasteRef.current.active = false;
+ const remaining = combined.slice(endIdx + PASTE_END_LENGTH);
+ pasteRef.current.chunks = [];
+
+ // Dispatch the pasted text as a single event.
+ if (pasteContent.length > 0) {
+ handlerRef.current(pasteContent, { ...EMPTY_KEY, paste: true });
+ }
+
+ // Handle any remaining input after the paste end marker.
+ if (remaining.length > 0) {
+ dispatchTerminalInput(remaining, handlerRef.current);
+ }
+ return;
+ }
+ return;
+ }
+ return;
+ }
+
+ // ----- Normal (non-paste) input -----
+ dispatchTerminalInput(data, handlerRef.current);
};
stdin?.on("data", handleData);
diff --git a/src/ui/promptBuffer.ts b/src/ui/promptBuffer.ts
index 3e3c182..3e0a710b 100644
--- a/src/ui/promptBuffer.ts
+++ b/src/ui/promptBuffer.ts
@@ -171,6 +171,141 @@ export function getCurrentSlashToken(state: PromptBufferState): string | null {
return line;
}
+/**
+ * Regex matching paste markers like `[paste #1 +123 lines]` or `[paste #2 1234 chars]`.
+ * When the user pastes a large block of text (>10 lines or >1000 chars), a compact
+ * marker is inserted instead of the full content. The actual content is stored in a
+ * Map and expanded back before submission.
+ */
+export const PASTE_MARKER_REGEX = /\[paste #(\d+) (\+?\d+ lines|\d+ chars)\]/g;
+
+/**
+ * Find the paste marker that ends exactly at `state.cursor`, if any.
+ * Returns the marker's start and end positions, or `null`.
+ */
+export function findPasteMarkerBefore(state: PromptBufferState): { start: number; end: number } | null {
+ // Walk backwards through all markers and return the one that ends at the cursor.
+ let match: RegExpExecArray | null;
+ PASTE_MARKER_REGEX.lastIndex = 0;
+ while ((match = PASTE_MARKER_REGEX.exec(state.text)) !== null) {
+ if (match.index + match[0].length === state.cursor) {
+ return { start: match.index, end: match.index + match[0].length };
+ }
+ }
+ return null;
+}
+
+/**
+ * Find the paste marker that starts exactly at `state.cursor`, if any.
+ * Returns the marker's start and end positions, or `null`.
+ */
+export function findPasteMarkerAt(state: PromptBufferState): { start: number; end: number } | null {
+ let match: RegExpExecArray | null;
+ PASTE_MARKER_REGEX.lastIndex = 0;
+ while ((match = PASTE_MARKER_REGEX.exec(state.text)) !== null) {
+ if (match.index === state.cursor) {
+ return { start: match.index, end: match.index + match[0].length };
+ }
+ }
+ return null;
+}
+
+/**
+ * If the cursor is immediately after a paste marker, delete the entire marker
+ * (atomic backspace). Returns the new state, or `state` unchanged if no marker.
+ */
+export function deletePasteMarkerBackward(
+ state: PromptBufferState,
+ validIds: Map
+): PromptBufferState | null {
+ const marker = findPasteMarkerBefore(state);
+ if (!marker) return null;
+ // Only delete if this is a real paste marker (ID in validIds).
+ PASTE_MARKER_REGEX.lastIndex = 0;
+ const m = PASTE_MARKER_REGEX.exec(state.text.slice(marker.start, marker.end));
+ if (!m || !validIds.has(Number.parseInt(m[1]!, 10))) return null;
+ const text = state.text.slice(0, marker.start) + state.text.slice(marker.end);
+ return { text, cursor: marker.start };
+}
+
+/**
+ * If the cursor is at the start of a paste marker, delete the entire marker
+ * (atomic forward delete). Returns the new state, or `state` unchanged if no marker.
+ */
+export function deletePasteMarkerForward(
+ state: PromptBufferState,
+ validIds: Map
+): PromptBufferState | null {
+ const marker = findPasteMarkerAt(state);
+ if (!marker) return null;
+ // Only delete if this is a real paste marker (ID in validIds).
+ PASTE_MARKER_REGEX.lastIndex = 0;
+ const m = PASTE_MARKER_REGEX.exec(state.text.slice(marker.start, marker.end));
+ if (!m || !validIds.has(Number.parseInt(m[1]!, 10))) return null;
+ const text = state.text.slice(0, marker.start) + state.text.slice(marker.end);
+ return { text, cursor: marker.start };
+}
+
+/**
+ * Sanitize stored paste content (filter control chars, expand tabs).
+ * Called lazily on expand/submit, not during paste to keep paste instant.
+ */
+export function cleanPasteContent(text: string): string {
+ return text
+ .replace(/\r\n|\r/g, "\n")
+ .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "")
+ .replace(/\t/g, " ");
+}
+
+/**
+ * Expand paste markers in the text back to their original (cleaned) content.
+ * @param text - Text potentially containing paste markers.
+ * @param pastes - Map of paste ID → original content.
+ */
+export function expandPasteMarkers(text: string, pastes: Map): string {
+ if (pastes.size === 0) return text;
+ let result = text;
+ for (const [pasteId, pasteContent] of pastes) {
+ const markerRegex = new RegExp(`\\[paste #${pasteId} (\\+?\\d+ lines|\\d+ chars)\\]`, "g");
+ result = result.replace(markerRegex, () => cleanPasteContent(pasteContent));
+ }
+ return result;
+}
+
+/**
+ * Find the paste marker that contains `state.cursor`, if any.
+ * Returns the marker's start, end, and numeric paste ID, or `null`.
+ */
+export function findPasteMarkerContaining(state: PromptBufferState): { start: number; end: number; id: number } | null {
+ let match: RegExpExecArray | null;
+ PASTE_MARKER_REGEX.lastIndex = 0;
+ while ((match = PASTE_MARKER_REGEX.exec(state.text)) !== null) {
+ if (match.index <= state.cursor && match.index + match[0].length >= state.cursor) {
+ return {
+ start: match.index,
+ end: match.index + match[0].length,
+ id: Number.parseInt(match[1]!, 10),
+ };
+ }
+ }
+ return null;
+}
+
+/**
+ * Check whether the text contains real paste markers (IDs present in validIds).
+ */
+export function hasActivePasteMarkers(text: string, validIds: Map): boolean {
+ if (!text.includes("[paste #")) return false;
+ PASTE_MARKER_REGEX.lastIndex = 0;
+ let match: RegExpExecArray | null;
+ while ((match = PASTE_MARKER_REGEX.exec(text)) !== null) {
+ if (validIds.has(Number.parseInt(match[1]!, 10))) {
+ return true;
+ }
+ }
+ return false;
+}
+
function locate(state: PromptBufferState): {
line: number;
column: number;
diff --git a/src/ui/slashCommands.ts b/src/ui/slashCommands.ts
index 6552ba0..6d9b7cc 100644
--- a/src/ui/slashCommands.ts
+++ b/src/ui/slashCommands.ts
@@ -1,6 +1,17 @@
import type { SkillInfo } from "../session";
-export type SlashCommandKind = "skill" | "skills" | "model" | "new" | "init" | "resume" | "continue" | "mcp" | "exit";
+export type SlashCommandKind =
+ | "skill"
+ | "skills"
+ | "model"
+ | "new"
+ | "init"
+ | "resume"
+ | "continue"
+ | "undo"
+ | "mcp"
+ | "raw"
+ | "exit";
export type SlashCommandItem = {
kind: SlashCommandKind;
@@ -8,6 +19,7 @@ export type SlashCommandItem = {
label: string;
description: string;
skill?: SkillInfo;
+ args?: string[];
};
export const BUILTIN_SLASH_COMMANDS: SlashCommandItem[] = [
@@ -47,12 +59,25 @@ export const BUILTIN_SLASH_COMMANDS: SlashCommandItem[] = [
label: "/continue",
description: "Continue the active conversation or pick one to resume",
},
+ {
+ kind: "undo",
+ name: "undo",
+ label: "/undo",
+ description: "Restore code and/or conversation to a previous point",
+ },
{
kind: "mcp",
name: "mcp",
label: "/mcp",
description: "Show MCP server status and available tools",
},
+ {
+ kind: "raw",
+ name: "raw",
+ label: "/raw",
+ args: ["lite", "normal", "raw-scrollback"],
+ description: "Toggle display mode for viewing or collapsing reasoning content",
+ },
{
kind: "exit",
name: "exit",
diff --git a/src/ui/utils/index.ts b/src/ui/utils/index.ts
new file mode 100644
index 0000000..4b498a0
--- /dev/null
+++ b/src/ui/utils/index.ts
@@ -0,0 +1,24 @@
+import chalk from "chalk";
+import type { SessionMessage } from "../../session";
+import { renderMessageToStdout } from "../components/MessageView/utils";
+import type { RawMode } from "../contexts";
+
+/**
+ * Render all messages directly to stdout for Raw mode display.
+ * Writes each message followed by the "Press ESC to exit raw mode" footer.
+ */
+export function renderRawModeMessages(allMessages: SessionMessage[], mode: string | RawMode): void {
+ for (const msg of allMessages) {
+ process.stdout.write("\n");
+ process.stdout.write(renderMessageToStdout(msg, mode as RawMode) + "\n\n");
+ }
+ if (allMessages.length > 0) {
+ process.stdout.write("\n\n");
+ process.stdout.write(chalk.dim("Press ESC to exit raw mode"));
+ } else {
+ process.stdout.write("\n");
+ process.stdout.write(chalk.dim("(No messages in this session yet. Start chatting to see them here.)"));
+ process.stdout.write("\n\n");
+ process.stdout.write(chalk.dim("Press ESC to exit raw mode"));
+ }
+}
diff --git a/templates/tools/bash.md b/templates/tools/bash.md
index 0705120..83027d3 100644
--- a/templates/tools/bash.md
+++ b/templates/tools/bash.md
@@ -28,6 +28,11 @@ Before executing the command, please follow these steps:
Usage notes:
- The command argument is required.
+ - The sideEffects argument is required. Declare the minimum permission scopes the command may need.
+ - Use `sideEffects: []` only for commands that do not read, write, delete, query Git history, mutate Git history, or access the network, such as `date` or `node --version`.
+ - Use `*-out-cwd` when the command accesses paths outside the current workspace. For example, `cat /etc/hosts` requires `["read-out-cwd"]`.
+ - Use `query-git-log` for commands such as `git log`, `git show HEAD`, `git blame`, or history diffs. Use `mutate-git-log` for commands such as `git commit`, `git reset`, `git rebase`, `git merge`, `git cherry-pick`, or `git tag`.
+ - Use `["unknown"]` when you cannot classify the command safely.
- It is very helpful if you write a clear, concise description of what this command does. For simple commands, keep it brief (5-10 words). For complex commands (piped commands, obscure flags, or anything hard to understand at a glance), add enough context to clarify what it does.
- If the output exceeds 30000 characters, output will be truncated before being returned to you.
- Always prefer using the dedicated tools for these commands:
@@ -60,10 +65,31 @@ Usage notes:
"description": {
"description": "Clear, concise description of what this command does in active voice. Never use words like \"complex\" or \"risk\" in the description - just describe what it does.\n\nFor simple commands (git, npm, standard CLI tools), keep it brief (5-10 words):\n- ls → \"List files in current directory\"\n- git status → \"Show working tree status\"\n- npm install → \"Install package dependencies\"\n\nFor commands that are harder to parse at a glance (piped commands, obscure flags, etc.), add enough context to clarify what it does:\n- find . -name \"*.tmp\" -exec rm {} \\; → \"Find and delete all .tmp files recursively\"\n- git reset --hard origin/main → \"Discard all local changes and match remote main\"\n- curl -s url | jq '.data[]' → \"Fetch JSON from URL and extract data array elements\"",
"type": "string"
+ },
+ "sideEffects": {
+ "description": "Permission scopes required by this bash command. Use [] only for commands that do not read, write, delete, or access the network. Use [\"unknown\"] when the effects cannot be classified safely.",
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": [
+ "read-in-cwd",
+ "read-out-cwd",
+ "write-in-cwd",
+ "write-out-cwd",
+ "delete-in-cwd",
+ "delete-out-cwd",
+ "query-git-log",
+ "mutate-git-log",
+ "network",
+ "unknown"
+ ]
+ },
+ "uniqueItems": true
}
},
"required": [
- "command"
+ "command",
+ "sideEffects"
],
"additionalProperties": false
}