ideacode 1.2.1 → 1.2.3

package/dist/api.js

@@ -9,12 +9,25 @@ export async function fetchModels(apiKey) {
     const json = (await res.json());
     return json.data ?? [];
 }
-const MAX_RETRIES = 3;
-const INITIAL_BACKOFF_MS = 1000;
+const MAX_RETRIES = 8;
+const INITIAL_BACKOFF_MS = 1200;
+const MAX_BACKOFF_MS = 30_000;
+const RETRYABLE_STATUS = new Set([408, 429, 500, 502, 503, 504]);
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-export async function callApi(apiKey, messages, systemPrompt, model) {
+function computeRetryDelayMs(attempt, retryAfterHeader) {
+    if (retryAfterHeader) {
+        const retrySeconds = Number.parseFloat(retryAfterHeader);
+        if (Number.isFinite(retrySeconds) && retrySeconds > 0) {
+            return Math.max(1000, Math.min(MAX_BACKOFF_MS, Math.round(retrySeconds * 1000)));
+        }
+    }
+    const base = Math.min(MAX_BACKOFF_MS, INITIAL_BACKOFF_MS * Math.pow(2, attempt));
+    const jitter = 0.75 + Math.random() * 0.5; // 0.75x .. 1.25x
+    return Math.max(1000, Math.round(base * jitter));
+}
+export async function callApi(apiKey, messages, systemPrompt, model, callbacks) {
     const body = {
         model,
         max_tokens: 8192,
@@ -36,11 +49,15 @@ export async function callApi(apiKey, messages, systemPrompt, model) {
             return res.json();
         const text = await res.text();
         lastError = new Error(`API ${res.status}: ${text}`);
-        if ((res.status === 429 || res.status === 503) && attempt < MAX_RETRIES) {
+        if (RETRYABLE_STATUS.has(res.status) && attempt < MAX_RETRIES) {
             const retryAfter = res.headers.get("retry-after");
-            const waitMs = retryAfter
-                ? Math.max(1000, parseInt(retryAfter, 10) * 1000)
-                : INITIAL_BACKOFF_MS * Math.pow(2, attempt);
+            const waitMs = computeRetryDelayMs(attempt, retryAfter);
+            callbacks?.onRetry?.({
+                attempt: attempt + 1,
+                maxAttempts: MAX_RETRIES + 1,
+                waitMs,
+                status: res.status,
+            });
             await sleep(waitMs);
             continue;
         }
@@ -187,7 +204,7 @@ export async function callApiStream(apiKey, messages, systemPrompt, model, callb
     await flushRemainingToolCalls();
     return finish();
 }
-const SUMMARIZE_SYSTEM = "You are a summarizer. Summarize the following conversation between user and assistant, including any tool use and results. Preserve the user's goal, key decisions, and important facts. Output only the summary, no preamble.";
+const SUMMARIZE_SYSTEM = "You are a summarizer. Compress the conversation while preserving fidelity. Output plain text with these exact sections: Goal, Constraints, Decisions, Open Questions, Next Actions, Critical Facts. Keep literals (paths, model ids, command names, env vars, URLs, numbers, error messages) whenever available. Include key tool results in concise form. Do not add preamble or commentary.";
 export async function callSummarize(apiKey, messages, model) {
     const body = {
         model,
@@ -213,11 +230,9 @@ export async function callSummarize(apiKey, messages, model) {
         }
         const text = await res.text();
         lastError = new Error(`Summarize API ${res.status}: ${text}`);
-        if ((res.status === 429 || res.status === 503) && attempt < MAX_RETRIES) {
+        if (RETRYABLE_STATUS.has(res.status) && attempt < MAX_RETRIES) {
             const retryAfter = res.headers.get("retry-after");
-            const waitMs = retryAfter
-                ? Math.max(1000, parseInt(retryAfter, 10) * 1000)
-                : INITIAL_BACKOFF_MS * Math.pow(2, attempt);
+            const waitMs = computeRetryDelayMs(attempt, retryAfter);
             await sleep(waitMs);
             continue;
         }

package/dist/context.js

@@ -1,4 +1,52 @@
 import { callSummarize } from "./api.js";
+const MAX_PINNED_FACTS = 28;
+const MAX_PINNED_FACT_CHARS = 200;
+function messageContentToText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const item of content) {
+            if (item && typeof item === "object") {
+                const maybe = item;
+                if (typeof maybe.content === "string")
+                    parts.push(maybe.content);
+                if (maybe.type === "tool_use" && typeof maybe.name === "string") {
+                    parts.push(`tool_use ${maybe.name} ${JSON.stringify(maybe.input ?? {})}`);
+                }
+            }
+        }
+        return parts.join("\n");
+    }
+    return JSON.stringify(content);
+}
+function extractPinnedFacts(messages) {
+    const allLines = messages
+        .flatMap((m) => messageContentToText(m.content).split("\n"))
+        .map((l) => l.trim())
+        .filter(Boolean);
+    const facts = [];
+    const seen = new Set();
+    const importantPattern = /(\/[A-Za-z0-9._/-]{2,}|https?:\/\/\S+|\b[A-Z][A-Z0-9_]{2,}\b|\b(error|failed|must|never|always|todo|fixme|constraint)\b)/i;
+    for (const line of allLines) {
+        if (!importantPattern.test(line))
+            continue;
+        const cleaned = line.replace(/\s+/g, " ").slice(0, MAX_PINNED_FACT_CHARS);
+        if (!cleaned || seen.has(cleaned))
+            continue;
+        seen.add(cleaned);
+        facts.push(cleaned);
+        if (facts.length >= MAX_PINNED_FACTS)
+            break;
+    }
+    return facts;
+}
+function buildSummaryEnvelope(summary, pinnedFacts) {
+    const factBlock = pinnedFacts.length > 0
+        ? `Pinned facts (verbatim, highest priority):\n${pinnedFacts.map((f) => `- ${f}`).join("\n")}\n\n`
+        : "";
+    return `${factBlock}Conversation summary:\n${summary}`.trim();
+}
 export function estimateTokens(messages, systemPrompt) {
     let chars = 0;
     for (const m of messages) {
@@ -21,9 +69,10 @@ export async function compressState(apiKey, state, systemPrompt, model, options)
     const toSummarize = state.slice(0, state.length - keepLast);
     const recent = state.slice(-keepLast);
     const summary = await callSummarize(apiKey, toSummarize, model);
+    const pinnedFacts = extractPinnedFacts(toSummarize);
     const summaryMessage = {
-        role: "user",
-        content: `Previous context:\n${summary}`,
+        role: "assistant",
+        content: buildSummaryEnvelope(summary, pinnedFacts),
     };
     return [summaryMessage, ...recent];
 }
@@ -31,12 +80,13 @@ export async function ensureUnderBudget(apiKey, state, systemPrompt, model, opti
     const { maxTokens, keepLast } = options;
     if (estimateTokens(state, systemPrompt) <= maxTokens)
         return state;
-    if (state.length <= keepLast) {
-        let trimmed = state;
-        while (trimmed.length > 1 && estimateTokens(trimmed, systemPrompt) > maxTokens) {
-            trimmed = trimmed.slice(1);
-        }
-        return trimmed;
+    let working = state;
+    if (working.length > keepLast) {
+        working = await compressState(apiKey, working, systemPrompt, model, { keepLast });
+    }
+    // If still over budget, trim oldest messages as a hard fallback.
+    while (working.length > 1 && estimateTokens(working, systemPrompt) > maxTokens) {
+        working = working.slice(1);
     }
-    return compressState(apiKey, state, systemPrompt, model, { keepLast });
+    return working;
 }

package/dist/index.js

@@ -1,11 +1,37 @@
 #!/usr/bin/env node
 import { jsx as _jsx } from "react/jsx-runtime";
 import "dotenv/config";
+import { writeSync } from "node:fs";
 import { render } from "ink";
 import { getApiKey } from "./config.js";
 import { getVersion } from "./version.js";
 import { runOnboarding } from "./onboarding.js";
 import { Repl } from "./repl.js";
+const PRINT_TRANSCRIPT_ON_EXIT = process.env.IDEACODE_TRANSCRIPT_ON_EXIT === "1";
+const CLEAR_SCREEN_ON_EXIT = process.env.IDEACODE_CLEAR_ON_EXIT !== "0";
+const TERMINAL_RESTORE_SEQ = "\x1b[?2004l\x1b[?1004l\x1b[?1007l\x1b[?1015l\x1b[?1006l\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?25h\x1b[0m";
+function restoreTerminalState() {
+    try {
+        if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+            process.stdin.setRawMode(false);
+        }
+        if (process.stdout.isTTY) {
+            writeSync(process.stdout.fd, TERMINAL_RESTORE_SEQ);
+        }
+    }
+    catch {
+        // Ignore restore failures during process teardown.
+    }
+}
+process.on("exit", restoreTerminalState);
+process.on("SIGINT", () => {
+    restoreTerminalState();
+    process.exit(130);
+});
+process.on("SIGTERM", () => {
+    restoreTerminalState();
+    process.exit(143);
+});
 async function main() {
     const args = process.argv.slice(2);
     if (args.includes("-v") || args.includes("--version")) {
@@ -20,7 +46,19 @@ async function main() {
     if (!apiKey) {
         process.exit(1);
     }
-    const { waitUntilExit } = render(_jsx(Repl, { apiKey: apiKey, cwd: process.cwd(), onQuit: () => process.exit(0) }));
-    await waitUntilExit();
+    let app;
+    let transcriptLines = [];
+    app = render(_jsx(Repl, { apiKey: apiKey, cwd: process.cwd(), onQuit: (lines) => {
+            transcriptLines = lines;
+            app.unmount();
+        } }));
+    await app.waitUntilExit();
+    if (!PRINT_TRANSCRIPT_ON_EXIT && CLEAR_SCREEN_ON_EXIT && process.stdout.isTTY) {
+        // Clear lingering in-place TUI frame from primary screen buffer.
+        writeSync(process.stdout.fd, "\x1b[2J\x1b[H");
+    }
+    if (PRINT_TRANSCRIPT_ON_EXIT && transcriptLines.length > 0) {
+        process.stdout.write("\n" + transcriptLines.join("\n") + "\n");
+    }
 }
 main();

package/dist/repl.js

@@ -2,10 +2,11 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 /**
  * Main REPL UI: input, log viewport, slash/@ suggestions, modals (model picker, palette), API loop and tool dispatch.
  */
-import { useState, useCallback, useRef, useMemo, useEffect } from "react";
+import React, { useState, useCallback, useRef, useMemo, useEffect } from "react";
 import { Box, Text, useInput, useStdout } from "ink";
 import { globSync } from "glob";
 import * as path from "node:path";
+import { writeSync } from "node:fs";
 import gradient from "gradient-string";
 // Custom matcha-themed gradient: matcha green → dark sepia
 const matchaGradient = gradient(["#7F9A65", "#5C4033"]);
@@ -39,7 +40,7 @@ const MAX_AT_SUGGESTIONS = 12;
 const INITIAL_BANNER_LINES = 12;
 const ENABLE_PARALLEL_TOOL_CALLS = process.env.IDEACODE_PARALLEL_TOOL_CALLS !== "0";
 const PARALLEL_SAFE_TOOLS = new Set(["read", "glob", "grep", "web_fetch", "web_search"]);
-const LOADING_TICK_MS = Math.min(300, Math.max(80, Number.parseInt(process.env.IDEACODE_SPINNER_MS ?? "110", 10) || 110));
+const LOADING_TICK_MS = 80;
 const TRUNCATE_NOTE = "\n\n(Output truncated to save context. Use read with offset/limit, grep with a specific pattern, or tail with fewer lines to get more.)";
 function truncateToolResult(content) {
     if (content.length <= MAX_TOOL_RESULT_CHARS)
@@ -62,6 +63,65 @@ function listFilesWithFilter(cwd, filter) {
         return [];
     }
 }
+function summarizeBashCommand(cmdRaw) {
+    const parts = cmdRaw
+        .split(/\n|&&|;|\|/g)
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const commands = [];
+    for (const part of parts) {
+        let s = part.replace(/^\(+/, "").trim();
+        if (!s || s.toUpperCase() === "EOF")
+            continue;
+        // Strip simple environment assignments at the front: FOO=bar CMD
+        while (/^[A-Za-z_][A-Za-z0-9_]*=/.test(s)) {
+            const idx = s.indexOf(" ");
+            if (idx === -1) {
+                s = "";
+                break;
+            }
+            s = s.slice(idx + 1).trim();
+        }
+        if (!s)
+            continue;
+        const token = s.split(/\s+/)[0]?.replace(/^['"]|['"]$/g, "") ?? "";
+        if (!/^[A-Za-z0-9_./-]+$/.test(token))
+            continue;
+        if (token === "echo")
+            continue;
+        if (token === "cat" && /<<\s*['"]?EOF/i.test(s))
+            continue;
+        if (!commands.includes(token))
+            commands.push(token);
+    }
+    if (commands.length === 0)
+        return "bash";
+    const shown = commands.slice(0, 5);
+    const suffix = commands.length > 5 ? `, +${commands.length - 5}` : "";
+    return (shown.join(", ") + suffix).slice(0, 140);
+}
+function toolArgPreview(toolName, toolArgs) {
+    if (toolName === "bash") {
+        const cmd = String(toolArgs.cmd ?? "").trim();
+        return cmd ? summarizeBashCommand(cmd) : "—";
+    }
+    if ("path" in toolArgs && typeof toolArgs.path === "string") {
+        return toolArgs.path.slice(0, 140) || "—";
+    }
+    const firstVal = Object.values(toolArgs)[0];
+    return String(firstVal ?? "").slice(0, 140) || "—";
+}
+function parseEditDelta(result) {
+    const both = result.match(/ok\s*\(\+(\d+)\s*-(\d+)\)/i);
+    if (both) {
+        return { added: Number.parseInt(both[1] ?? "0", 10), removed: Number.parseInt(both[2] ?? "0", 10) };
+    }
+    const addOnly = result.match(/ok\s*\(\+(\d+)\)/i);
+    if (addOnly) {
+        return { added: Number.parseInt(addOnly[1] ?? "0", 10), removed: 0 };
+    }
+    return undefined;
+}
 function parseAtSegments(value) {
     const segments = [];
     let pos = 0;
@@ -115,11 +175,13 @@ function replayMessagesToLogLines(messages) {
                         const block = toolUses.find((b) => b.id === tr.tool_use_id);
                         if (block?.name) {
                             const name = block.name.trim().toLowerCase();
-                            const firstVal = block.input && typeof block.input === "object" ? Object.values(block.input)[0] : undefined;
-                            const argPreview = String(firstVal ?? "").slice(0, 50) || "—";
+                            const args = block.input && typeof block.input === "object"
+                                ? block.input
+                                : {};
+                            const argPreview = toolArgPreview(name, args).slice(0, 60);
                             const content = tr.content ?? "";
                             const ok = !content.startsWith("error:");
-                            lines.push(toolCallBox(name, argPreview, ok));
+                            lines.push(toolCallBox(name, argPreview, ok, 0, name === "edit" || name === "write" ? parseEditDelta(content) : undefined));
                             const tokens = estimateTokensForString(content);
                             lines.push(toolResultTokenLine(tokens, ok));
                         }
@@ -158,6 +220,42 @@ function useTerminalSize() {
     }, [stdout]);
     return size;
 }
+const LogViewport = React.memo(function LogViewport({ lines, startIndex, height, }) {
+    return (_jsx(Box, { flexDirection: "column", height: height, overflow: "hidden", children: lines.map((line, i) => (_jsx(Text, { children: line === "" ? "\u00A0" : line }, startIndex + i))) }));
+});
+function orbitDots(frame) {
+    const phase = frame % 6;
+    const activeIndex = phase <= 3 ? phase : 6 - phase;
+    const slots = ["·", "·", "·", "·"];
+    slots[activeIndex] = "●";
+    return slots
+        .map((ch, i) => (i === activeIndex ? colors.gray(ch) : colors.mutedDark(ch)))
+        .join("");
+}
+const LoadingStatus = React.memo(function LoadingStatus({ active, label, }) {
+    const [frame, setFrame] = useState(0);
+    const startedAtRef = useRef(null);
+    useEffect(() => {
+        if (!active) {
+            startedAtRef.current = null;
+            return;
+        }
+        if (startedAtRef.current == null) {
+            startedAtRef.current = Date.now();
+            setFrame(0);
+        }
+        const anim = setInterval(() => setFrame((n) => n + 1), LOADING_TICK_MS);
+        return () => {
+            clearInterval(anim);
+        };
+    }, [active]);
+    if (!active)
+        return _jsx(Text, { color: inkColors.textSecondary, children: "\u00A0" });
+    const startedAt = startedAtRef.current ?? Date.now();
+    const elapsedSeconds = Math.max(0, (Date.now() - startedAt) / 1000);
+    const elapsedText = elapsedSeconds < 10 ? `${elapsedSeconds.toFixed(1)}s` : `${Math.floor(elapsedSeconds)}s`;
+    return (_jsxs(Text, { color: inkColors.textSecondary, children: [" ", orbitDots(frame), " ", colors.gray(label), " ", colors.gray(elapsedText)] }));
+});
 export function Repl({ apiKey, cwd, onQuit }) {
     const { rows: termRows, columns: termColumns } = useTerminalSize();
     // Big ASCII art logo for ideacode
@@ -189,6 +287,10 @@ export function Repl({ apiKey, cwd, onQuit }) {
         }
         return banner;
     });
+    const logLinesRef = useRef(logLines);
+    useEffect(() => {
+        logLinesRef.current = logLines;
+    }, [logLines]);
     const [inputValue, setInputValue] = useState("");
     const [currentModel, setCurrentModel] = useState(getModel);
     const [messages, setMessages] = useState(() => loadConversation(cwd));
@@ -236,10 +338,23 @@ export function Repl({ apiKey, cwd, onQuit }) {
         if (saveDebounceRef.current)
             clearTimeout(saveDebounceRef.current);
         saveConversation(cwd, messagesRef.current);
-        onQuit();
+        // Best-effort terminal mode reset in case process exits before React cleanup runs.
+        try {
+            if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+                process.stdin.setRawMode(false);
+            }
+            if (process.stdout.isTTY) {
+                writeSync(process.stdout.fd, "\x1b[?2004l\x1b[?1004l\x1b[?1007l\x1b[?1015l\x1b[?1006l\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?25h\x1b[0m");
+            }
+        }
+        catch {
+            // Ignore restore failures during teardown.
+        }
+        onQuit(logLinesRef.current);
     }, [cwd, onQuit]);
     const [loading, setLoading] = useState(false);
     const [loadingLabel, setLoadingLabel] = useState("Thinking…");
+    const [cursorBlinkOn, setCursorBlinkOn] = useState(true);
     const [showPalette, setShowPalette] = useState(false);
     const [paletteIndex, setPaletteIndex] = useState(0);
     const [showModelSelector, setShowModelSelector] = useState(false);
@@ -258,14 +373,21 @@ export function Repl({ apiKey, cwd, onQuit }) {
     const scrollBoundsRef = useRef({ maxLogScrollOffset: 0, logViewportHeight: 1 });
     const prevEscRef = useRef(false);
     useEffect(() => {
+        // Enable SGR mouse + basic tracking so trackpad wheel scrolling works.
         process.stdout.write("\x1b[?1006h\x1b[?1000h");
         return () => {
             process.stdout.write("\x1b[?1006l\x1b[?1000l");
         };
     }, []);
-    const [spinnerTick, setSpinnerTick] = useState(0);
-    const loadingStartedAtRef = useRef(0);
-    const SPINNER = ["●○○", "○●○", "○○●", "○●○"];
+    useEffect(() => {
+        setCursorBlinkOn(true);
+        if (loading)
+            return;
+        const timer = setInterval(() => {
+            setCursorBlinkOn((prev) => !prev);
+        }, 520);
+        return () => clearInterval(timer);
+    }, [loading, inputValue, inputCursor]);
     const estimatedTokens = useMemo(() => estimateTokens(messages, undefined), [messages]);
     const contextWindowK = useMemo(() => {
         const ctx = modelList.find((m) => m.id === currentModel)?.context_length;
@@ -279,6 +401,20 @@ export function Repl({ apiKey, cwd, onQuit }) {
         return modelList.filter((m) => m.id.toLowerCase().includes(q) ||
             (m.name ?? "").toLowerCase().includes(q));
     }, [modelList, modelSearchFilter]);
+    const wrapWidth = Math.max(10, termColumns - PROMPT_INDENT_LEN - 2);
+    const inputLineCount = useMemo(() => {
+        const lines = inputValue.split("\n");
+        return lines.reduce((sum, line) => sum + Math.max(1, Math.ceil(line.length / wrapWidth)), 0);
+    }, [inputValue, wrapWidth]);
+    const [stableInputLineCount, setStableInputLineCount] = useState(inputLineCount);
+    useEffect(() => {
+        if (inputLineCount <= 1) {
+            setStableInputLineCount(1);
+            return;
+        }
+        const t = setTimeout(() => setStableInputLineCount(inputLineCount), 90);
+        return () => clearTimeout(t);
+    }, [inputLineCount]);
     useEffect(() => {
         setInputCursor((c) => Math.min(c, Math.max(0, inputValue.length)));
     }, [inputValue.length]);
@@ -296,14 +432,6 @@ export function Repl({ apiKey, cwd, onQuit }) {
         if (showModelSelector && filteredModelList.length > 0)
             setModelIndex((i) => Math.min(i, filteredModelList.length - 1));
     }, [showModelSelector, filteredModelList.length]);
-    useEffect(() => {
-        if (!loading)
-            return;
-        loadingStartedAtRef.current = Date.now();
-        setSpinnerTick(0);
-        const t = setInterval(() => setSpinnerTick((n) => n + 1), LOADING_TICK_MS);
-        return () => clearInterval(t);
-    }, [loading]);
     const showSlashSuggestions = inputValue.startsWith("/");
     const filteredSlashCommands = useMemo(() => {
         const filter = inputValue.slice(1).trim();
@@ -446,7 +574,7 @@ export function Repl({ apiKey, cwd, onQuit }) {
         appendLog(userPromptBox(userInput));
         appendLog("");
         let state = [...messages, { role: "user", content: userInput }];
-        const systemPrompt = `Concise coding assistant. cwd: ${cwd}. PRIORITIZE grep to locate; then read with offset and limit to fetch only relevant sections. Do not read whole files unless the user explicitly asks. Use focused greps (specific patterns, narrow paths) and read in chunks when files are large; avoid one huge grep or read that floods context. When exploring a dependency, set path to that package (e.g. node_modules/<pkg>) and list/read only what you need. Prefer grep or keyword search for the most recent or specific occurrence; avoid tail/read of thousands of lines. If a tool result says it was truncated, call the tool again with offset, limit, or a narrower pattern to get what you need. Use as many parallel read/search/web tool calls as needed in one turn when they are independent (often more than 3 is appropriate for broad research), but keep each call high-signal, non-redundant, and minimal in output size.`;
+        const systemPrompt = `Concise coding assistant. cwd: ${cwd}. PRIORITIZE grep to locate; then read with offset and limit to fetch only relevant sections. Do not read whole files unless the user explicitly asks. Use focused greps (specific patterns, narrow paths) and read in chunks when files are large; avoid one huge grep or read that floods context. When exploring a dependency, set path to that package (e.g. node_modules/<pkg>) and list/read only what you need. Prefer grep or keyword search for the most recent or specific occurrence; avoid tail/read of thousands of lines. If a tool result says it was truncated, call the tool again with offset, limit, or a narrower pattern to get what you need. Use as many parallel read/search/web tool calls as needed in one turn when they are independent (often more than 3 is appropriate for broad research), but keep each call high-signal, non-redundant, and minimal in output size. For bash tool calls, avoid decorative echo headers; run direct commands and keep commands concise.`;
         const modelContext = modelList.find((m) => m.id === currentModel)?.context_length;
         const maxContextTokens = Math.floor((modelContext ?? CONTEXT_WINDOW_K * 1024) * 0.85);
         const stateBeforeCompress = state;
@@ -454,19 +582,25 @@ export function Repl({ apiKey, cwd, onQuit }) {
         setLoading(true);
         state = await ensureUnderBudget(apiKey, state, systemPrompt, currentModel, {
             maxTokens: maxContextTokens,
-            keepLast: 6,
+            keepLast: 8,
         });
         if (state.length < stateBeforeCompress.length) {
             appendLog(colors.muted("  (context compressed to stay under limit)\n"));
         }
+        setLoadingLabel("Thinking…");
         for (;;) {
+            setLoading(true);
             setLoadingLabel("Thinking…");
-            const response = await callApi(apiKey, state, systemPrompt, currentModel);
+            const response = await callApi(apiKey, state, systemPrompt, currentModel, {
+                onRetry: ({ attempt, maxAttempts, waitMs, status }) => {
+                    setLoadingLabel(`Rate limited (${status}), retry ${attempt}/${maxAttempts} in ${(waitMs / 1000).toFixed(1)}s…`);
+                },
+            });
             const contentBlocks = response.content ?? [];
             const toolResults = [];
             const renderToolOutcome = (planned, result, extraIndent = 0) => {
                 const ok = !result.startsWith("error:");
-                appendLog(toolCallBox(planned.toolName, planned.argPreview, ok, extraIndent));
+                appendLog(toolCallBox(planned.toolName, planned.argPreview, ok, extraIndent, planned.toolName === "edit" || planned.toolName === "write" ? parseEditDelta(result) : undefined));
                 const contentForApi = truncateToolResult(result);
                 const tokens = estimateTokensForString(contentForApi);
                 appendLog(toolResultTokenLine(tokens, ok, extraIndent));
@@ -477,6 +611,7 @@ export function Repl({ apiKey, cwd, onQuit }) {
             const runParallelBatch = async (batch) => {
                 if (batch.length === 0)
                     return;
+                setLoadingLabel(`Running ${batch.length} tools in parallel…`);
                 const started = Date.now();
                 const groupedTools = Array.from(batch.reduce((acc, planned) => {
                     acc.set(planned.toolName, (acc.get(planned.toolName) ?? 0) + 1);
@@ -504,12 +639,11 @@ export function Repl({ apiKey, cwd, onQuit }) {
                     continue;
                 const toolName = block.name.trim().toLowerCase();
                 const toolArgs = block.input;
-                const firstVal = Object.values(toolArgs)[0];
                 const planned = {
                     block,
                     toolName,
                     toolArgs,
-                    argPreview: String(firstVal ?? "").slice(0, 100) || "—",
+                    argPreview: toolArgPreview(toolName, toolArgs),
                 };
                 if (ENABLE_PARALLEL_TOOL_CALLS && PARALLEL_SAFE_TOOLS.has(toolName)) {
                     parallelBatch.push(planned);
@@ -517,11 +651,11 @@ export function Repl({ apiKey, cwd, onQuit }) {
                 }
                 await runParallelBatch(parallelBatch);
                 parallelBatch = [];
+                setLoadingLabel(`Running ${planned.toolName}…`);
                 const result = await runTool(planned.toolName, planned.toolArgs);
                 renderToolOutcome(planned, result);
             }
             await runParallelBatch(parallelBatch);
-            setLoading(false);
             state = [...state, { role: "assistant", content: contentBlocks }];
             if (toolResults.length === 0) {
                 setMessages(state);
@@ -530,6 +664,7 @@ export function Repl({ apiKey, cwd, onQuit }) {
             state = [...state, { role: "user", content: toolResults }];
             setMessages(state);
         }
+        setLoading(false);
         return true;
     }, [apiKey, cwd, currentModel, messages, modelList, appendLog, openModelSelector, openBraveKeyModal, openHelpModal]);
     const handleSubmit = useCallback(async (value) => {
@@ -947,13 +1082,8 @@ export function Repl({ apiKey, cwd, onQuit }) {
         ? 4 + Math.max(1, filteredFilePaths.length)
         : 0;
     const suggestionBoxLines = slashSuggestionBoxLines || atSuggestionBoxLines;
-    const wrapWidth = Math.max(10, termColumns - PROMPT_INDENT_LEN - 2);
-    const inputLineCount = (() => {
-        const lines = inputValue.split("\n");
-        return lines.reduce((sum, line) => sum + Math.max(1, Math.ceil(line.length / wrapWidth)), 0);
-    })();
     // Keep a fixed loading row reserved to avoid viewport jumps/flicker when loading starts/stops.
-    const reservedLines = 1 + inputLineCount + 2;
+    const reservedLines = 1 + stableInputLineCount + 2;
     const logViewportHeight = Math.max(1, termRows - reservedLines - suggestionBoxLines);
     const effectiveLogLines = logLines;
     const maxLogScrollOffset = Math.max(0, effectiveLogLines.length - logViewportHeight);
@@ -963,7 +1093,8 @@ export function Repl({ apiKey, cwd, onQuit }) {
         logStartIndex = 0;
     }
     const sliceEnd = logStartIndex + logViewportHeight;
-    const visibleLogLines = effectiveLogLines.slice(logStartIndex, sliceEnd);
+    const visibleLogLines = useMemo(() => effectiveLogLines.slice(logStartIndex, sliceEnd), [effectiveLogLines, logStartIndex, sliceEnd]);
+    const useSimpleInputRenderer = inputLineCount > 1;
     if (showHelpModal) {
         const helpModalWidth = Math.min(88, Math.max(80, termColumns - 4));
         const helpContentRows = 20;
@@ -986,17 +1117,14 @@ export function Repl({ apiKey, cwd, onQuit }) {
         const leftPad = Math.max(0, Math.floor((termColumns - paletteModalWidth) / 2));
         return (_jsxs(Box, { flexDirection: "column", height: termRows, overflow: "hidden", children: [_jsx(Box, { height: topPad }), _jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: leftPad }), _jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: inkColors.primary, paddingX: 2, paddingY: 1, width: paletteModalWidth, minHeight: paletteModalHeight, children: [_jsx(Text, { bold: true, children: " Command palette " }), COMMANDS.map((c, i) => (_jsxs(Text, { color: i === paletteIndex ? inkColors.primary : undefined, children: [i === paletteIndex ? "› " : "  ", c.cmd, _jsxs(Text, { color: inkColors.textSecondary, children: [" \u2014 ", c.desc] })] }, c.cmd))), _jsxs(Text, { color: paletteIndex === COMMANDS.length ? inkColors.primary : undefined, children: [paletteIndex === COMMANDS.length ? "› " : "  ", "Cancel (Esc)"] }), _jsx(Text, { color: inkColors.textSecondary, children: " \u2191/\u2193 select, Enter confirm, Esc close " })] })] }), _jsx(Box, { flexGrow: 1 })] }));
     }
-    const footerLines = suggestionBoxLines + 1 + inputLineCount;
-    return (_jsxs(Box, { flexDirection: "column", height: termRows, overflow: "hidden", children: [_jsxs(Box, { flexDirection: "column", flexGrow: 1, minHeight: 0, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", height: logViewportHeight, overflow: "hidden", children: visibleLogLines.map((line, i) => (_jsx(Text, { children: line === "" ? "\u00A0" : line }, effectiveLogLines.length - visibleLogLines.length + i))) }), _jsx(Box, { flexDirection: "row", marginTop: 1, marginBottom: 0, children: _jsxs(Text, { color: inkColors.textSecondary, children: [" ", loading
-                                    ? `${SPINNER[spinnerTick % SPINNER.length]} ${loadingLabel} ${((Date.now() - loadingStartedAtRef.current) /
-                                        1000).toFixed(1)}s`
-                                    : "\u00A0"] }) })] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, height: footerLines, children: [showSlashSuggestions && (_jsxs(Box, { flexDirection: "column", marginBottom: 0, paddingLeft: 2, borderStyle: "single", borderColor: inkColors.textDisabled, children: [filteredSlashCommands.length === 0 ? (_jsx(Text, { color: inkColors.textSecondary, children: " No match " })) : ([...filteredSlashCommands].reverse().map((c, rev) => {
+    const footerLines = suggestionBoxLines + 1 + stableInputLineCount;
+    return (_jsxs(Box, { flexDirection: "column", height: termRows, overflow: "hidden", children: [_jsxs(Box, { flexDirection: "column", flexGrow: 1, minHeight: 0, overflow: "hidden", children: [_jsx(LogViewport, { lines: visibleLogLines, startIndex: logStartIndex, height: logViewportHeight }), _jsx(Box, { flexDirection: "row", marginTop: 1, marginBottom: 0, children: _jsx(LoadingStatus, { active: loading, label: loadingLabel }) })] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, height: footerLines, children: [showSlashSuggestions && (_jsxs(Box, { flexDirection: "column", marginBottom: 0, paddingLeft: 2, borderStyle: "single", borderColor: inkColors.textDisabled, children: [filteredSlashCommands.length === 0 ? (_jsx(Text, { color: inkColors.textSecondary, children: " No match " })) : ([...filteredSlashCommands].reverse().map((c, rev) => {
                                 const i = filteredSlashCommands.length - 1 - rev;
                                 return (_jsxs(Text, { color: i === clampedSlashIndex ? inkColors.primary : undefined, children: [i === clampedSlashIndex ? "› " : "  ", c.cmd, _jsxs(Text, { color: inkColors.textSecondary, children: [" \u2014 ", c.desc] })] }, c.cmd));
                             })), _jsx(Text, { color: inkColors.textSecondary, children: " Commands (\u2191/\u2193 select, Enter run, Esc clear) " })] })), cursorInAtSegment && !showSlashSuggestions && (_jsxs(Box, { flexDirection: "column", marginBottom: 0, paddingLeft: 2, borderStyle: "single", borderColor: inkColors.textDisabled, children: [filteredFilePaths.length === 0 ? (_jsxs(Text, { color: inkColors.textSecondary, children: [" ", hasCharsAfterAt ? "No match" : "Type to search files", " "] })) : ([...filteredFilePaths].reverse().map((p, rev) => {
                                 const i = filteredFilePaths.length - 1 - rev;
                                 return (_jsxs(Text, { color: i === clampedAtFileIndex ? inkColors.primary : undefined, children: [i === clampedAtFileIndex ? "› " : "  ", p] }, p));
-                            })), _jsx(Box, { flexDirection: "row", marginTop: 1, children: _jsx(Text, { color: inkColors.textSecondary, children: " Files (\u2191/\u2193 select, Enter/Tab complete, Esc clear) " }) })] })), _jsxs(Box, { flexDirection: "row", marginTop: 0, children: [_jsxs(Text, { color: "gray", children: [" ", icons.tool, " ", tokenDisplay] }), _jsx(Text, { color: "gray", children: `  ·  / ! @  trackpad/↑/↓ scroll  Opt/Fn+select  Ctrl+J newline  Tab queue  Esc Esc edit  ${pasteShortcut} paste  Ctrl+C exit` })] }), _jsx(Box, { flexDirection: "column", marginTop: 0, children: inputValue.length === 0 ? (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: inkColors.primary, children: [icons.prompt, " "] }), _jsx(Text, { inverse: true, color: inkColors.primary, children: " " }), _jsx(Text, { color: inkColors.textSecondary, children: "Message or / for commands, @ for files, ! for shell, ? for help..." })] })) : ((() => {
+                            })), _jsx(Box, { flexDirection: "row", marginTop: 1, children: _jsx(Text, { color: inkColors.textSecondary, children: " Files (\u2191/\u2193 select, Enter/Tab complete, Esc clear) " }) })] })), _jsxs(Box, { flexDirection: "row", marginTop: 0, children: [_jsxs(Text, { color: "gray", children: [" ", icons.tool, " ", tokenDisplay] }), _jsx(Text, { color: "gray", children: `  ·  / ! @  trackpad/↑/↓ scroll  Opt/Fn+select  Ctrl+J newline  Tab queue  Esc Esc edit  ${pasteShortcut} paste  Ctrl+C exit` })] }), _jsx(Box, { flexDirection: "column", marginTop: 0, children: inputValue.length === 0 ? (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: inkColors.primary, children: [icons.prompt, " "] }), cursorBlinkOn ? (_jsx(Text, { inverse: true, color: inkColors.primary, children: " " })) : (_jsx(Text, { color: inkColors.primary, children: " " })), _jsx(Text, { color: inkColors.textSecondary, children: "Message or / for commands, @ for files, ! for shell, ? for help..." })] })) : ((() => {
                             const lines = inputValue.split("\n");
                             let lineStart = 0;
                             return (_jsx(_Fragment, { children: lines.flatMap((lineText, lineIdx) => {
@@ -1005,6 +1133,49 @@ export function Repl({ apiKey, cwd, onQuit }) {
                                     const cursorOffsetInLine = cursorOnThisLine ? inputCursor - lineStart : -1;
                                     const currentLineStart = lineStart;
                                     lineStart = lineEnd + 1;
+                                    if (useSimpleInputRenderer) {
+                                        const visualLines = wrapLine(lineText, wrapWidth);
+                                        return visualLines.map((visualChunk, v) => {
+                                            const visualStart = v * wrapWidth;
+                                            const visualEnd = Math.min((v + 1) * wrapWidth, lineText.length);
+                                            const isLastVisualOfThisLine = v === visualLines.length - 1;
+                                            const cursorAtEndOfVisual = isLastVisualOfThisLine && cursorOffsetInLine === visualEnd;
+                                            const cursorPosInVisual = cursorOnThisLine &&
+                                                cursorOffsetInLine >= visualStart &&
+                                                (cursorOffsetInLine < visualEnd || cursorAtEndOfVisual)
+                                                ? cursorOffsetInLine < visualEnd
+                                                    ? cursorOffsetInLine - visualStart
+                                                    : visualEnd - visualStart
+                                                : -1;
+                                            const isFirstRow = lineIdx === 0 && v === 0;
+                                            const isLastLogicalLine = lineIdx === lines.length - 1;
+                                            const isLastVisualOfLine = v === visualLines.length - 1;
+                                            const rowNodes = [];
+                                            if (lineText === "" && v === 0 && cursorOnThisLine) {
+                                                rowNodes.push(cursorBlinkOn
+                                                    ? (_jsx(Text, { inverse: true, color: inkColors.primary, children: "\u00A0" }, "cursor-empty-on"))
+                                                    : (_jsx(Text, { color: inkColors.primary, children: "\u00A0" }, "cursor-empty-off")));
+                                            }
+                                            else if (cursorPosInVisual >= 0) {
+                                                const before = visualChunk.slice(0, cursorPosInVisual);
+                                                const curChar = cursorPosInVisual < visualChunk.length
+                                                    ? visualChunk[cursorPosInVisual]
+                                                    : "\u00A0";
+                                                const after = cursorPosInVisual < visualChunk.length
+                                                    ? visualChunk.slice(cursorPosInVisual + 1)
+                                                    : "";
+                                                rowNodes.push(_jsx(Text, { children: before }, "plain-before"));
+                                                rowNodes.push(cursorBlinkOn
+                                                    ? (_jsx(Text, { inverse: true, color: inkColors.primary, children: curChar }, "plain-caret-on"))
+                                                    : (_jsx(Text, { children: curChar }, "plain-caret-off")));
+                                                rowNodes.push(_jsx(Text, { children: after }, "plain-after"));
+                                            }
+                                            else {
+                                                rowNodes.push(_jsx(Text, { children: visualChunk }, "plain"));
+                                            }
+                                            return (_jsxs(Box, { flexDirection: "row", children: [isFirstRow ? (_jsxs(Text, { color: inkColors.primary, children: [icons.prompt, " "] })) : (_jsx(Text, { children: " ".repeat(PROMPT_INDENT_LEN) })), rowNodes, isLastLogicalLine && isLastVisualOfLine && inputValue.startsWith("!") && (_jsxs(Text, { color: inkColors.textDisabled, children: ["  — ", "type a shell command to run"] }))] }, `simple-${lineIdx}-${v}`));
+                                        });
+                                    }
                                     const segments = parseAtSegments(lineText);
                                     let runIdx = 0;
                                     const segmentsWithStyle = [];
@@ -1068,7 +1239,9 @@ export function Repl({ apiKey, cwd, onQuit }) {
                                             : -1;
                                         const lineNodes = [];
                                         if (lineText === "" && v === 0 && cursorOnThisLine) {
-                                            lineNodes.push(_jsx(Text, { inverse: true, color: inkColors.primary, children: "\u00A0" }, "cursor"));
+                                            lineNodes.push(cursorBlinkOn
+                                                ? (_jsx(Text, { inverse: true, color: inkColors.primary, children: "\u00A0" }, "cursor-on"))
+                                                : (_jsx(Text, { color: inkColors.primary, children: "\u00A0" }, "cursor-off")));
                                         }
                                         else {
                                             let cursorRendered = false;
@@ -1088,7 +1261,12 @@ export function Repl({ apiKey, cwd, onQuit }) {
                                                         const after = text.slice(segRel + 1);
                                                         const usePath = "color" in seg.style && !!seg.style.color;
                                                         lineNodes.push(_jsx(Text, { ...seg.style, children: before }, `${segIdx}-a`));
-                                                        lineNodes.push(_jsx(Text, { inverse: true, color: usePath ? inkColors.path : inkColors.primary, bold: "bold" in seg.style && !!seg.style.bold, children: curChar }, `${segIdx}-b`));
+                                                        if (cursorBlinkOn) {
+                                                            lineNodes.push(_jsx(Text, { inverse: true, color: usePath ? inkColors.path : inkColors.primary, bold: "bold" in seg.style && !!seg.style.bold, children: curChar }, `${segIdx}-b-on`));
+                                                        }
+                                                        else {
+                                                            lineNodes.push(_jsx(Text, { ...seg.style, children: curChar }, `${segIdx}-b-off`));
+                                                        }
                                                         lineNodes.push(_jsx(Text, { ...seg.style, children: after }, `${segIdx}-c`));
                                                         cursorRendered = true;
                                                     }
@@ -1101,7 +1279,9 @@ export function Repl({ apiKey, cwd, onQuit }) {
                                                 }
                                             });
                                             if (cursorPosInVisual >= 0 && !cursorRendered) {
-                                                lineNodes.push(_jsx(Text, { inverse: true, color: inkColors.primary, children: "\u00A0" }, "cursor-end"));
+                                                lineNodes.push(cursorBlinkOn
+                                                    ? (_jsx(Text, { inverse: true, color: inkColors.primary, children: "\u00A0" }, "cursor-end-on"))
+                                                    : (_jsx(Text, { color: inkColors.primary, children: "\u00A0" }, "cursor-end-off")));
                                             }
                                         }
                                         const isFirstRow = lineIdx === 0 && v === 0;

package/dist/tools/file.js

@@ -19,8 +19,10 @@ export function readFile(args) {
         suffix);
 }
 export function writeFile(args) {
-    fs.writeFileSync(args.path, args.content, "utf-8");
-    return "ok";
+    const content = args.content;
+    fs.writeFileSync(args.path, content, "utf-8");
+    const added = content === "" ? 0 : content.split("\n").length;
+    return `ok (+${added})`;
 }
 export function editFile(args) {
     const text = fs.readFileSync(args.path, "utf-8");
@@ -39,5 +41,9 @@ export function editFile(args) {
     }
     const replacement = args.all ? text.split(oldStr).join(newStr) : text.replace(oldStr, newStr);
     fs.writeFileSync(args.path, replacement, "utf-8");
-    return "ok";
+    const oldLines = oldStr === "" ? 0 : oldStr.split("\n").length;
+    const newLines = newStr === "" ? 0 : newStr.split("\n").length;
+    const removed = oldLines * count;
+    const added = newLines * count;
+    return `ok (+${added} -${removed})`;
 }

package/dist/ui/format.js

@@ -308,14 +308,17 @@ export function userPromptBox(prompt) {
 }
 const TOOL_INDENT = "  ";
 const toolSubdued = chalk.gray;
-export function toolCallBox(toolName, argPreview, success = true, extraIndent = 0) {
+export function toolCallBox(toolName, argPreview, success = true, extraIndent = 0, editDelta) {
     const indent = TOOL_INDENT + "  ".repeat(Math.max(0, extraIndent));
     const diamondColor = success ? colors.toolSuccess : colors.toolFail;
     const nameColor = diamondColor;
     const argColor = success ? toolSubdued : colors.toolFail;
     const parenColor = colors.mutedDark;
     const name = " " + toolName.trim().toLowerCase();
-    return `${indent}${diamondColor(icons.tool)}${nameColor(name)}${parenColor("(")}${argColor(argPreview)}${parenColor(")")}`;
+    const delta = editDelta != null
+        ? ` ${colors.toolSuccess(`+${editDelta.added}`)} ${colors.toolFail(`-${editDelta.removed}`)}`
+        : "";
+    return `${indent}${diamondColor(icons.tool)}${nameColor(name)}${parenColor("(")}${argColor(argPreview)}${parenColor(")")}${delta}`;
 }
 export function toolResultLine(preview, success = true) {
     const pipeColor = success ? toolSubdued : colors.toolFail;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ideacode",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "CLI TUI for AI agents via OpenRouter — agentic loop, tools, markdown",
   "type": "module",
   "repository": {