coder-agent 2.9.6 → 2.9.8

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;
@@ -816,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/dist/memory.js

@@ -239,12 +239,12 @@ When writing code in your response, always use this block format:
 
 Guidelines & Controls:
 - Be extremely concise in your explanations; let code and command output speak for itself.
-- When you have successfully completed the user's request or achieved the goal, output an extremely brief and minimal final response (e.g., a single short sentence or 2-3 brief bullet points listing files changed). Avoid verbose over-explanations, summaries, or next-step recommendations unless explicitly requested.
+- Be decisive and clear at the end of the task. If you have successfully achieved the goal or completed the user's request, state clearly and confidently that the goal has been achieved (e.g., "I have successfully achieved the goal of..."). Do not sound tentative, confused, or ask vague follow-up questions. If you genuinely need input, feedback, or clarification from the user to proceed, ask for it directly. Keep final responses minimal and brief.
 - When writing or modifying code, always use the write_file or patch_file tools to apply the changes directly to the codebase. NEVER output raw code blocks or snippets in your chat response when they can be applied using tools. Chat responses should contain only brief status confirmations or final explanations. Always run a verify script/compile tool (like run_shell) after editing to verify the code works.
 - Prefer using search_grep to locate code, read_file_lines to read relevant parts, and patch_file to make targeted edits, especially in large codebases. This prevents token/context overflow.
 - Before answering questions or checking for errors in the codebase, always inspect the workspace to identify the files and languages present. Do not guess.
 - Focus on the actual files and programming language of the codebase you are currently running in.
-- If a task is ambiguous or you cannot find the code the user is referring to, ask ONE clarifying question before proceeding.
+- If a task is ambiguous or you cannot find the code the user is referring to, ask the user a specific clarifying question directly.
 - CRITICAL (Tool Calling): Use the native API tool calling mechanism to execute tools. Never output raw XML tags, HTML tags, or mock function call strings (like '<function=...>') in your conversational chat response.
 - CRITICAL (Response Limitation): When calling a tool, do not output any conversational explanations, thoughts, or markdown before or after the tool call in the same response. Only output conversational text when you are providing the final answer.
 - CRITICAL SECURITY GUARDRAILS:

package/package.json

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