Merge branch 'main' of https://github.com/lessweb/deepcode-cli

Author: dengmik-commits

src/prompt.ts

@@ -243,9 +243,9 @@ Here's an example of how your output should be structured:
 
 </summary>`;
 
-const SYSTEM_PROMPT_BASE = `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+const SYSTEM_PROMPT_BASE = `你是名叫Deep Code的交互式CLI工具，帮助用户完成软件工程任务。 Use the instructions below and the tools available to you to assist the user.
 
-IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files.`;
+重要：严禁编造任何非编程相关的 URL。对于编程链接，仅限使用：1) 用户提供的上下文；2) 你确定的官方文档主域名。在输出前，必须自查该链接是否存在于你的上下文记忆中；若不存在，请明确说明无法提供。`;
 
 type PromptToolOptions = {
   webSearchEnabled?: boolean;

src/session.ts

@@ -121,6 +121,7 @@ export type MessageMeta = {
   resultMd?: string;
   asThinking?: boolean;
   isSummary?: boolean;
+  isModelChange?: boolean;
   skill?: SkillInfo;
 };
 
@@ -598,7 +599,7 @@ The candidate skills are as follows:\n\n`;
       if (!fs.existsSync(root)) {
         return [];
       }
-      let entries: fs.Dirent[] = [];
+      let entries: fs.Dirent[];
       try {
         entries = fs.readdirSync(root, { withFileTypes: true });
       } catch {
@@ -772,6 +773,12 @@ The candidate skills are as follows:\n\n`;
     this.activeSessionId = sessionId;
   }
 
+  addSessionSystemMessage(sessionId: string, content: string, meta?: MessageMeta): void {
+    const message = this.buildSystemMessage(sessionId, content, meta);
+    this.appendSessionMessage(sessionId, message);
+    this.onAssistantMessage(message, false);
+  }
+
   async handleUserPrompt(userPrompt: UserPromptContent): Promise<void> {
     const controller = new AbortController();
     this.activePromptController = controller;
@@ -1535,7 +1542,12 @@ ${skillMd}
     return this.readNonEmptyFile(path.join(os.homedir(), ".deepcode", "AGENTS.md"));
   }
 
-  private buildSystemMessage(sessionId: string, content: string, contentParams: unknown | null = null): SessionMessage {
+  private buildSystemMessage(
+    sessionId: string,
+    content: string,
+    contentParams: unknown | null = null,
+    meta?: MessageMeta
+  ): SessionMessage {
     const now = new Date().toISOString();
     return {
       id: crypto.randomUUID(),
@@ -1548,6 +1560,7 @@ ${skillMd}
       visible: false,
       createTime: now,
       updateTime: now,
+      meta,
     };
   }
 

src/tests/dropdownMenu.test.ts

@@ -0,0 +1,148 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { calculateVisibleStart } from "../ui/DropdownMenu";
+
+test("calculateVisibleStart centers active item when possible", () => {
+  // 10 items, max 5 visible, active index 4 (middle)
+  // Should show items 2-6 (start at 2)
+  const start = calculateVisibleStart(4, 10, 5);
+  assert.equal(start, 2);
+});
+
+test("calculateVisibleStart handles active item at the beginning", () => {
+  // 10 items, max 5 visible, active index 0
+  // Should show items 0-4 (start at 0)
+  const start = calculateVisibleStart(0, 10, 5);
+  assert.equal(start, 0);
+});
+
+test("calculateVisibleStart handles active item at the end", () => {
+  // 10 items, max 5 visible, active index 9 (last)
+  // Should show items 5-9 (start at 5)
+  const start = calculateVisibleStart(9, 10, 5);
+  assert.equal(start, 5);
+});
+
+test("calculateVisibleStart handles fewer items than maxVisible", () => {
+  // 3 items, max 5 visible, active index 1
+  // Should show all items (start at 0)
+  const start = calculateVisibleStart(1, 3, 5);
+  assert.equal(start, 0);
+});
+
+test("calculateVisibleStart handles single item", () => {
+  // 1 item, max 5 visible, active index 0
+  // Should start at 0
+  const start = calculateVisibleStart(0, 1, 5);
+  assert.equal(start, 0);
+});
+
+test("calculateVisibleStart handles empty list", () => {
+  // 0 items, max 5 visible, active index 0
+  // Should start at 0
+  const start = calculateVisibleStart(0, 0, 5);
+  assert.equal(start, 0);
+});
+
+test("calculateVisibleStart handles activeIndex near start with odd maxVisible", () => {
+  // 10 items, max 7 visible (odd), active index 2
+  // floor((7-1)/2) = 3, so 2-3 = -1, clamped to 0
+  const start = calculateVisibleStart(2, 10, 7);
+  assert.equal(start, 0);
+});
+
+test("calculateVisibleStart handles activeIndex near start with even maxVisible", () => {
+  // 10 items, max 6 visible (even), active index 2
+  // floor((6-1)/2) = 2, so 2-2 = 0
+  const start = calculateVisibleStart(2, 10, 6);
+  assert.equal(start, 0);
+});
+
+test("calculateVisibleStart keeps active item centered in middle range", () => {
+  // 20 items, max 5 visible, active index 10
+  // floor((5-1)/2) = 2, so 10-2 = 8
+  const start = calculateVisibleStart(10, 20, 5);
+  assert.equal(start, 8);
+});
+
+test("calculateVisibleStart handles activeIndex at exact boundary", () => {
+  // 10 items, max 5 visible, active index 2 (boundary where centering starts)
+  // floor((5-1)/2) = 2, so 2-2 = 0
+  const start = calculateVisibleStart(2, 10, 5);
+  assert.equal(start, 0);
+});
+
+test("calculateVisibleStart handles activeIndex just after boundary", () => {
+  // 10 items, max 5 visible, active index 3
+  // floor((5-1)/2) = 2, so 3-2 = 1
+  const start = calculateVisibleStart(3, 10, 5);
+  assert.equal(start, 1);
+});
+
+test("calculateVisibleStart handles large maxVisible", () => {
+  // 10 items, max 100 visible, active index 5
+  // Should show all items (start at 0)
+  const start = calculateVisibleStart(5, 10, 100);
+  assert.equal(start, 0);
+});
+
+test("calculateVisibleStart handles activeIndex equal to totalItems", () => {
+  // 10 items, max 5 visible, active index 10 (out of bounds)
+  // floor((5-1)/2) = 2, so 10-2 = 8, clamped to 5 (10-5)
+  const start = calculateVisibleStart(10, 10, 5);
+  assert.equal(start, 5);
+});
+
+test("calculateVisibleStart with maxVisible of 1", () => {
+  // 5 items, max 1 visible, active index 2
+  // floor((1-1)/2) = 0, so 2-0 = 2, clamped to 4 (5-1)
+  const start = calculateVisibleStart(2, 5, 1);
+  assert.equal(start, 2);
+});
+
+test("calculateVisibleStart with maxVisible of 1 at end", () => {
+  // 5 items, max 1 visible, active index 4 (last)
+  // floor((1-1)/2) = 0, so 4-0 = 4, clamped to 4 (5-1)
+  const start = calculateVisibleStart(4, 5, 1);
+  assert.equal(start, 4);
+});
+
+test("calculateVisibleStart scrolling behavior - moving down", () => {
+  // Simulate scrolling through a list
+  // 10 items, max 5 visible
+
+  // Start at index 0
+  assert.equal(calculateVisibleStart(0, 10, 5), 0);
+
+  // Move to index 2 (still centered)
+  assert.equal(calculateVisibleStart(2, 10, 5), 0);
+
+  // Move to index 5 (window should scroll)
+  assert.equal(calculateVisibleStart(5, 10, 5), 3);
+
+  // Move to index 8 (near end)
+  assert.equal(calculateVisibleStart(8, 10, 5), 5);
+
+  // Move to index 9 (at end)
+  assert.equal(calculateVisibleStart(9, 10, 5), 5);
+});
+
+test("calculateVisibleStart scrolling behavior - moving up", () => {
+  // Simulate scrolling up through a list
+  // 10 items, max 5 visible
+
+  // Start at index 9 (end)
+  assert.equal(calculateVisibleStart(9, 10, 5), 5);
+
+  // Move to index 6
+  assert.equal(calculateVisibleStart(6, 10, 5), 4);
+
+  // Move to index 4 (window should scroll up)
+  assert.equal(calculateVisibleStart(4, 10, 5), 2);
+
+  // Move to index 1 (near start)
+  assert.equal(calculateVisibleStart(1, 10, 5), 0);
+
+  // Move to index 0 (at start)
+  assert.equal(calculateVisibleStart(0, 10, 5), 0);
+});

src/tests/promptInputKeys.test.ts

@@ -128,6 +128,44 @@ test("parseTerminalInput recognizes ctrl+x as the image attachment clear shortcu
   assert.equal(isClearImageAttachmentsShortcut(input, key), true);
 });
 
+test("parseTerminalInput recognizes ctrl+- modifyOtherKeys sequence (standard)", () => {
+  const { input, key } = parseTerminalInput("\u001B[45;5u");
+  assert.equal(input, "-");
+  assert.equal(key.ctrl, true);
+  assert.equal(key.meta, false);
+});
+
+test("parseTerminalInput recognizes ctrl+- modifyOtherKeys sequence (extended)", () => {
+  const { input, key } = parseTerminalInput("\u001B[27;5;45~");
+  assert.equal(input, "-");
+  assert.equal(key.ctrl, true);
+  assert.equal(key.meta, false);
+});
+
+test("parseTerminalInput recognizes raw 0x1F as ctrl+shift+- (redo)", () => {
+  const { input, key } = parseTerminalInput("\u001F");
+  assert.equal(input, "-");
+  assert.equal(key.ctrl, true);
+  assert.equal(key.shift, true);
+  assert.equal(key.meta, false);
+});
+
+test("parseTerminalInput recognizes ctrl+shift+- modifyOtherKeys sequence (standard)", () => {
+  const { input, key } = parseTerminalInput("\u001B[45;6u");
+  assert.equal(input, "-");
+  assert.equal(key.ctrl, true);
+  assert.equal(key.shift, true);
+  assert.equal(key.meta, false);
+});
+
+test("parseTerminalInput recognizes ctrl+shift+- modifyOtherKeys sequence (extended)", () => {
+  const { input, key } = parseTerminalInput("\u001B[27;6;45~");
+  assert.equal(input, "-");
+  assert.equal(key.ctrl, true);
+  assert.equal(key.shift, true);
+  assert.equal(key.meta, false);
+});
+
 test("formatImageAttachmentStatus formats the image count label", () => {
   assert.equal(formatImageAttachmentStatus(0), "");
   assert.equal(formatImageAttachmentStatus(1), "📎 1 image attached");

src/tests/promptUndoRedo.test.ts

@@ -0,0 +1,60 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { removeCurrentSlashToken } from "../ui";
+import {
+  clearPromptUndoRedoState,
+  createPromptUndoRedoState,
+  recordPromptEdit,
+  redoPromptEdit,
+  undoPromptEdit,
+} from "../ui/promptUndoRedo";
+
+test("prompt undo and redo restore edited buffer states", () => {
+  const history = createPromptUndoRedoState();
+  const empty = { text: "", cursor: 0 };
+  const hello = { text: "hello", cursor: 5 };
+
+  recordPromptEdit(history, empty, hello);
+
+  assert.deepEqual(undoPromptEdit(history, hello), empty);
+  assert.deepEqual(redoPromptEdit(history, empty), hello);
+});
+
+test("prompt redo history is cleared after a new edit", () => {
+  const history = createPromptUndoRedoState();
+  const empty = { text: "", cursor: 0 };
+  const first = { text: "first", cursor: 5 };
+  const second = { text: "second", cursor: 6 };
+
+  recordPromptEdit(history, empty, first);
+  assert.deepEqual(undoPromptEdit(history, first), empty);
+
+  recordPromptEdit(history, empty, second);
+
+  assert.equal(redoPromptEdit(history, second), null);
+});
+
+test("prompt undo ignores cursor-only movement", () => {
+  const history = createPromptUndoRedoState();
+  const before = { text: "hello", cursor: 5 };
+  const after = { text: "hello", cursor: 0 };
+
+  recordPromptEdit(history, before, after);
+
+  assert.equal(undoPromptEdit(history, after), null);
+});
+
+test("clearing consumed slash token drops undo and redo history", () => {
+  const history = createPromptUndoRedoState();
+  const empty = { text: "", cursor: 0 };
+  const slashCommand = { text: "/model", cursor: 6 };
+
+  recordPromptEdit(history, empty, slashCommand);
+  const cleared = removeCurrentSlashToken(slashCommand);
+  clearPromptUndoRedoState(history);
+
+  assert.deepEqual(cleared, { text: "", cursor: 0 });
+  assert.equal(undoPromptEdit(history, cleared), null);
+  assert.equal(redoPromptEdit(history, cleared), null);
+});

src/ui/App.tsx

@@ -8,6 +8,7 @@ import OpenAI from "openai";
 import {
   SessionManager,
   type LlmStreamProgress,
+  type MessageMeta,
   type SessionEntry,
   type SessionMessage,
   type SessionStatus,
@@ -268,12 +269,42 @@ export function App({ projectRoot, version = "", onRestart }: AppProps): React.R
       const { changed } = writeModelConfigSelection(selection, current, projectRoot);
       const next = resolveCurrentSettings(projectRoot);
       setResolvedSettings(next);
+
       if (!changed) {
         return "Model settings unchanged";
       }
+
+      const activeSessionId = sessionManager.getActiveSessionId();
+      const meta: MessageMeta = {
+        isModelChange: true,
+      };
+      const content = `/model\n└ Set model to ${selection.model} (${selection?.thinkingEnabled ? selection?.reasoningEffort : "no thinking"})`;
+
+      if (activeSessionId) {
+        sessionManager.addSessionSystemMessage(activeSessionId, content, meta);
+      } else {
+        const now = new Date().toISOString();
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: crypto.randomUUID(),
+            sessionId: "local",
+            role: "system" as const,
+            content,
+            contentParams: null,
+            messageParams: null,
+            compacted: false,
+            visible: true,
+            createTime: now,
+            updateTime: now,
+            meta,
+          },
+        ]);
+      }
+
       return `Model settings updated: ${formatModelConfig(current)} → ${formatModelConfig(next)}`;
     },
-    [projectRoot]
+    [projectRoot, sessionManager]
   );
 
   const handleSubmit = useCallback(