coder-agent 2.3.2 → 2.3.4

package/dist/agent.js

@@ -2,7 +2,7 @@ import chalk from "chalk";
 import * as path from "path";
 import * as fs from "fs/promises";
 import { TOOL_DEFINITIONS, dispatchTool } from "./tools.js";
-import { Memory } from "./memory.js";
+import { Memory, getAgentMemoryEntrypoint } from "./memory.js";
 // ─── Loading Spinner ──────────────────────────────────────────────────────────
 let spinnerTimer = null;
 let currentFrame = 0;
@@ -237,12 +237,14 @@ function extractTextToolCalls(content) {
     return calls;
 }
 // ─── Gemini API client with Auto-Rotation Fallback ────────────────────────────
-async function callGeminiAPIWithRotation(apiKey, params, maxRetries = 3, initialDelayMs = 1500, signal) {
+async function callGeminiAPIWithRotation(apiKey, params, maxRetries = 3, initialDelayMs = 1500, signal, silent = false) {
     const rotationList = [
+        "gemini-2.0-flash",
+        "gemini-2.0-pro-exp",
         "gemini-2.5-flash",
         "gemini-2.5-pro",
-        "gemini-2.0-flash",
-        "gemini-2.0-pro-exp"
+        "gemini-3.5-flash",
+        "gemini-3.1-flash-lite"
     ];
     let currentModel = params.model;
     let modelIndex = rotationList.indexOf(currentModel);
@@ -282,20 +284,24 @@ async function callGeminiAPIWithRotation(apiKey, params, maxRetries = 3, initial
             attempts++;
             const status = err?.status;
             const isRetryableError = status === 429 || status === 503 || (status >= 500 && status < 600) || !status;
-            if (isRetryableError) {
-                // Rotate model immediately if rate limit or service unavailable occurred
-                if ((status === 429 || status === 503) && modelIndex + 1 < rotationList.length) {
+            const isModelError = status === 404 || status === 400;
+            if (isRetryableError || isModelError) {
+                // Rotate model immediately if rate limit or model error occurred
+                if (modelIndex + 1 < rotationList.length) {
                     modelIndex++;
                     const nextModel = rotationList[modelIndex];
-                    stopSpinner();
-                    console.log(chalk.hex('#ff9f0a')('⚠') + ' ' + chalk.gray(`Rate limited on ${currentModel}. Rotating to ${nextModel}`));
-                    startSpinner("thinking...");
+                    if (!silent) {
+                        stopSpinner();
+                        const reason = isModelError ? "Model unavailable" : "Rate limited";
+                        console.log(chalk.hex('#ff9f0a')('⚠') + ' ' + chalk.gray(`${reason} on ${currentModel}. Rotating to ${nextModel}`));
+                        startSpinner("thinking...");
+                    }
                     currentModel = nextModel;
                     attempts = 0; // reset retry counter for the fresh model
                     continue;
                 }
-                // Otherwise do standard delay retry on same model
-                if (attempts < maxRetries) {
+                // Otherwise do standard delay retry on same model ONLY if it is a transient/retryable error
+                if (isRetryableError && attempts < maxRetries) {
                     const delay = initialDelayMs * Math.pow(2, attempts - 1);
                     await new Promise((resolve, reject) => {
                         const timer = setTimeout(resolve, delay);
@@ -348,7 +354,7 @@ export class Agent {
                 abortErr.name = "AbortError";
                 throw abortErr;
             }
-            await this.memory.init(this.memoryScope, "coder");
+            await this.memory.init(this.memoryScope, "coder", true);
             if (signal?.aborted) {
                 const abortErr = new Error("The user aborted a request.");
                 abortErr.name = "AbortError";
@@ -527,9 +533,67 @@ export class Agent {
                 console.log(chalk.hex('#ff453a')('✕ error'));
                 console.log(chalk.dim('  Max tool iterations reached.'));
             }
+            // Auto-update persistent memory in the background (fire and forget)
+            this.autoUpdateMemory().catch(() => { });
         }
         finally {
             stopSpinner();
         }
     }
+    async autoUpdateMemory() {
+        try {
+            const memoryFile = getAgentMemoryEntrypoint("coder", this.memoryScope);
+            let existingMemory = "";
+            try {
+                existingMemory = await fs.readFile(memoryFile, "utf-8");
+            }
+            catch (err) {
+                if (err.code !== "ENOENT") {
+                    return;
+                }
+            }
+            const allMessages = this.memory.getAll();
+            if (allMessages.length <= 1)
+                return;
+            const prompt = `You are a memory manager for the CLI coding agent.
+Your task is to update the persistent agent memory file based on the recent conversation history.
+
+Here is the current memory file content:
+---
+${existingMemory}
+---
+
+Here is the recent conversation history:
+---
+${JSON.stringify(allMessages.slice(1).map(m => ({ role: m.role, content: m.content || JSON.stringify(m.tool_calls) })))}
+---
+
+Instructions:
+1. Review the conversation history and extract any important new project setup details, style preferences, build/test commands, package quirks, or persistent instructions that should be remembered for future sessions.
+2. Integrate these new learnings into the existing memory structure. Keep existing useful learnings/preferences, but clean up duplicates or obsolete info.
+3. Keep the content concise, clean, and formatted in Markdown.
+4. If there are no new learnings, setup details, or instructions in the conversation, output EXACTLY the existing memory content. Do not add conversational text, just output the updated/existing markdown content.`;
+            const responseObj = await callGeminiAPIWithRotation(this.apiKey, {
+                model: this.model,
+                messages: [{ role: "user", content: prompt }],
+                temperature: 0.1,
+            }, 3, 1500, undefined, true);
+            let newMemory = responseObj.data.choices[0].message.content?.trim() || "";
+            if (newMemory.startsWith("```markdown")) {
+                newMemory = newMemory.slice(11).trim();
+            }
+            if (newMemory.startsWith("```")) {
+                newMemory = newMemory.slice(3).trim();
+            }
+            if (newMemory.endsWith("```")) {
+                newMemory = newMemory.slice(0, -3).trim();
+            }
+            if (newMemory && newMemory !== existingMemory.trim()) {
+                await fs.writeFile(memoryFile, newMemory, "utf-8");
+            }
+        }
+        catch {
+            // Fail silently to avoid interrupting the main interaction
+        }
+    }
 }

package/dist/index.js

@@ -7,6 +7,8 @@ import { getStoredApiKey, saveApiKey, getStoredModel, saveModel } from "./config
 const VALID_MODELS = [
     "gemini-2.5-flash",
     "gemini-2.5-pro",
+    "gemini-3.5-flash",
+    "gemini-3.1-flash-lite",
     "gemini-2.0-flash",
     "gemini-2.0-pro-exp"
 ];
@@ -66,10 +68,12 @@ function printHelp() {
     console.log(chalk.white("    --set-gemini-key <api_key>     — Save your Gemini API Key globally (alias)"));
     console.log("");
     console.log(chalk.gray("  Popular Gemini Models:"));
+    console.log(chalk.white("    gemini-3.5-flash               — Newest, highly capable & fast"));
     console.log(chalk.white("    gemini-2.5-flash               — Default, highly capable & fast"));
     console.log(chalk.white("    gemini-2.5-pro                 — Reasoning model, excellent coding"));
-    console.log(chalk.white("    gemini-2.0-flash               — Ultra-fast, lightweight"));
-    console.log(chalk.white("    gemini-2.0-pro-exp             — Experimental reasoning model"));
+    console.log(chalk.white("    gemini-3.1-flash-lite          — Light-weight, high volume"));
+    console.log(chalk.white("    gemini-2.0-flash               — (Deprecated) Ultra-fast, lightweight"));
+    console.log(chalk.white("    gemini-2.0-pro-exp             — (Deprecated) Experimental reasoning"));
     console.log("");
 }
 // ─── API Key Bootstrap ────────────────────────────────────────────────────────

package/dist/memory.js

@@ -12,6 +12,7 @@ PRINCIPLES & SYSTEM PROTOCOLS FOR ERROR-FREE EXECUTION:
 4. Auto-Verification Loop: After any code or file edit, you MUST run the appropriate compiler, type-check, build script, or test tool (e.g. npm run build, npx tsc, pytest, cargo build, etc.) to verify your changes are syntactically and logically correct. If compilation fails, diagnose the error and patch it immediately.
 5. Autonomous Troubleshooting: If a command fails or times out, inspect the codebase or script to see why it hangs or fails. Do not blindly edit package scripts or configs.
 6. Automated Diagnostic Parsing: When the user pastes IDE problem diagnostics (e.g., JSON blocks containing "resource", "message", "startLineNumber"), stack traces, or compiler errors, parse the diagnostic payload autonomously. Extract the file path and line number, locate the file inside the workspace (resolving drive formats like '/c:/...' to standard local paths, or searching for the filename if needed), read the target lines, and formulate a fix. Do not ask the user for clarifying questions (such as "where is this error?") if the path and error message are already present in the diagnostic block.
+7. Resilience on Tool Failures: If a tool execution returns an error (such as "Target code not found in file" during patch_file, or any other tool failure), do NOT stop or give up. Autonomously analyze the error, adjust your arguments/parameters, or read the file to verify its exact content, and try again with a corrected tool call (or fall back to a full write_file if patching repeatedly fails) to achieve the user's goal.
 
 Guidelines:
 - Be concise in your explanations; let code and command output speak for itself.
@@ -218,6 +219,50 @@ ${topLevelStructure || "(empty)"}
 \`\`\`
 `;
 }
+function pruneMessages(messages, maxMessages) {
+    if (messages.length <= maxMessages + 1) {
+        return messages;
+    }
+    const systemPrompt = messages[0];
+    const history = messages.slice(1);
+    // Group history into turns, where each turn starts with role === "user"
+    const turns = [];
+    let currentTurn = [];
+    for (const msg of history) {
+        if (msg.role === "user") {
+            if (currentTurn.length > 0) {
+                turns.push(currentTurn);
+            }
+            currentTurn = [msg];
+        }
+        else {
+            currentTurn.push(msg);
+        }
+    }
+    if (currentTurn.length > 0) {
+        turns.push(currentTurn);
+    }
+    // Keep turns from the end (most recent) until we hit the maxMessages limit
+    const keptTurns = [];
+    let currentCount = 0;
+    for (let i = turns.length - 1; i >= 0; i--) {
+        const turn = turns[i];
+        if (currentCount + turn.length <= maxMessages) {
+            keptTurns.unshift(turn);
+            currentCount += turn.length;
+        }
+        else {
+            // If we can't fit this turn, but we have kept nothing so far (e.g. a single giant turn),
+            // we must keep at least this turn to avoid sending an empty history.
+            if (keptTurns.length === 0) {
+                keptTurns.push(turn);
+            }
+            break;
+        }
+    }
+    const prunedHistory = keptTurns.flat();
+    return [systemPrompt, ...prunedHistory];
+}
 export class Memory {
     messages = [];
     maxMessages;
@@ -228,8 +273,8 @@ export class Memory {
         this.maxMessages = maxMessages;
         this.messages.push({ role: "system", content: SYSTEM_PROMPT });
     }
-    async init(scope = "project", agentType = "coder") {
-        if (this.initialized)
+    async init(scope = "project", agentType = "coder", forceRefresh = false) {
+        if (this.initialized && !forceRefresh)
             return;
         this.scope = scope;
         this.agentType = agentType;
@@ -240,10 +285,7 @@ export class Memory {
     }
     add(msg) {
         this.messages.push(msg);
-        // Keep within token budget: always keep system prompt + last N messages
-        if (this.messages.length > this.maxMessages + 1) {
-            this.messages = [this.messages[0], ...this.messages.slice(-(this.maxMessages))];
-        }
+        this.messages = pruneMessages(this.messages, this.maxMessages);
     }
     getAll() {
         return this.messages;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coder-agent",
-  "version": "2.3.2",
+  "version": "2.3.4",
   "description": "CLI coding agent powered by Google Gemini",
   "type": "module",
   "main": "dist/index.js",