coder-agent 2.9.5 → 2.9.7

package/dist/agent.js

@@ -35,7 +35,12 @@ function normalizeFilePath(p) {
     if (process.platform === "win32" && /^\/[a-zA-Z]:/.test(normalized)) {
         normalized = normalized.slice(1);
     }
-    return path.normalize(normalized);
+    try {
+        return path.resolve(process.cwd(), normalized);
+    }
+    catch {
+        return path.normalize(normalized);
+    }
 }
 function extractDiagnostics(text) {
     const diagnostics = [];
@@ -180,38 +185,69 @@ function formatResponseText(text) {
         return chalk.white(part);
     }).join('');
 }
-function normalizeContentForLoopCheck(content) {
-    if (!content)
+function normalizeCode(code) {
+    if (!code)
         return "";
-    return content
+    return code
         .toLowerCase()
-        .replace(/\s+/g, " ")
+        .replace(/\s+/g, "")
         .trim();
 }
-function normalizeToolCallsForLoopCheck(toolCalls) {
+function getLoopCheckKey(toolCalls) {
     if (!toolCalls || toolCalls.length === 0)
         return "";
-    return toolCalls.map(tc => {
+    const parts = toolCalls.map(tc => {
         const name = tc.function?.name || "";
-        let argsStr = "";
+        let args = {};
         try {
             const rawArgs = tc.function?.arguments;
-            const args = typeof rawArgs === 'string'
+            args = typeof rawArgs === 'string'
                 ? JSON.parse(rawArgs)
                 : rawArgs;
-            if (args && typeof args === 'object') {
-                const sortedArgs = {};
-                for (const key of Object.keys(args).sort()) {
-                    sortedArgs[key] = args[key];
-                }
-                argsStr = JSON.stringify(sortedArgs);
+            if (args && typeof args === "object") {
+                if (args.filepath && !args.file_path)
+                    args.file_path = args.filepath;
+                if (args.path && !args.file_path)
+                    args.file_path = args.path;
+                if (args.dirpath && !args.dir_path)
+                    args.dir_path = args.dirpath;
             }
         }
-        catch {
-            argsStr = tc.function?.arguments || "";
+        catch { }
+        const filePath = args.file_path || args.dir_path || "";
+        const normalizedPath = filePath ? normalizeFilePath(filePath).toLowerCase() : "";
+        switch (name) {
+            case "read_file":
+                return `read_file:${normalizedPath}`;
+            case "read_file_lines":
+                const start = args.start_line ?? "";
+                const end = args.end_line ?? "";
+                return `read_file_lines:${normalizedPath}:${start}-${end}`;
+            case "write_file":
+                return `write_file:${normalizedPath}:${normalizeCode(args.content || "")}`;
+            case "patch_file":
+                const targetCode = normalizeCode(args.target_code || "");
+                const replacementCode = normalizeCode(args.replacement_code || "");
+                return `patch_file:${normalizedPath}:${targetCode}:${replacementCode}`;
+            case "list_directory":
+                return `list_directory:${normalizedPath}`;
+            case "run_shell":
+                const cmd = (args.command || "").toLowerCase().trim().replace(/\s+/g, " ");
+                return `run_shell:${cmd}`;
+            case "web_search":
+                const qSearch = (args.query || "").toLowerCase().trim().replace(/\s+/g, " ");
+                return `web_search:${qSearch}`;
+            case "find_files":
+                const qFind = (args.query || "").toLowerCase().trim().replace(/\s+/g, " ");
+                return `find_files:${normalizedPath}:${qFind}`;
+            case "search_grep":
+                const qGrep = (args.query || "").toLowerCase().trim().replace(/\s+/g, " ");
+                return `search_grep:${qGrep}`;
+            default:
+                return `${name}:${JSON.stringify(args)}`;
         }
-        return `${name}(${argsStr})`;
-    }).join(";");
+    });
+    return parts.sort().join(";");
 }
 function hasRepeatingCycle(history) {
     const n = history.length;
@@ -503,10 +539,34 @@ async function callGeminiAPIWithRotation(apiKey, params, maxRetries = 3, initial
                     const nextModel = rotationList[modelIndex];
                     if (!silent) {
                         stopSpinner();
-                        const reason = isModelError ? "Model unavailable" : "Rate limited";
-                        console.log(chalk.hex('#ff9f0a')('⚠') + ' ' + chalk.gray(`${reason} on ${currentModel}. Rotating to ${nextModel}`));
+                        let reason = "Rate limited";
+                        if (isModelError)
+                            reason = "Model unavailable";
+                        else if (status >= 500)
+                            reason = "Server error (5xx)";
+                        console.log(chalk.hex('#ff9f0a')('⚠') + ' ' + chalk.gray(`${reason} on ${currentModel}. Rotating to ${nextModel}...`));
                         startSpinner("thinking...");
                     }
+                    // Delay slightly on rate limits or server errors before sending next request
+                    if (status === 429 || (status >= 500 && status < 600)) {
+                        try {
+                            await new Promise((resolve, reject) => {
+                                const timer = setTimeout(resolve, 2000);
+                                if (signal) {
+                                    signal.addEventListener("abort", () => {
+                                        clearTimeout(timer);
+                                        const abortErr = new Error("The user aborted a request.");
+                                        abortErr.name = "AbortError";
+                                        reject(abortErr);
+                                    });
+                                }
+                            });
+                        }
+                        catch (err) {
+                            if (err.name === "AbortError" || signal?.aborted)
+                                throw err;
+                        }
+                    }
                     currentModel = nextModel;
                     attempts = 0; // reset retry counter for the fresh model
                     continue;
@@ -792,7 +852,7 @@ export class Agent {
                     console.log(line);
                 }
                 // Loop detection & intervention
-                const currentKey = `${normalizeContentForLoopCheck(msg.content || "")}|${normalizeToolCallsForLoopCheck(toolCalls)}`;
+                const currentKey = getLoopCheckKey(toolCalls);
                 const tempHistory = [...stateHistory, currentKey];
                 if (hasRepeatingCycle(tempHistory)) {
                     loopInterventions++;

package/package.json

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