coder-agent 2.9.7 → 2.9.9

package/dist/agent.js

@@ -83,6 +83,30 @@ function extractDiagnostics(text) {
     }
     return diagnostics;
 }
+function extractFilePaths(text) {
+    const pathRegex = /(?:\.\/|\.\.\\|[a-zA-Z]:\\)?(?:[a-zA-Z0-9_\-\.]+[\\\/])+[a-zA-Z0-9_\-\.]+\.[a-zA-Z0-9]+/g;
+    const fileRegex = /\b[a-zA-Z0-9_\-\.]+\.[a-zA-Z0-9]+\b/g;
+    const matches = new Set();
+    let match;
+    while ((match = pathRegex.exec(text)) !== null) {
+        matches.add(match[0]);
+    }
+    while ((match = fileRegex.exec(text)) !== null) {
+        matches.add(match[0]);
+    }
+    const paths = [];
+    for (const m of matches) {
+        const trimmed = m.trim();
+        if (!trimmed)
+            continue;
+        if (/^\d/.test(trimmed))
+            continue;
+        if (trimmed.includes("://") || trimmed.startsWith("http"))
+            continue;
+        paths.push(trimmed);
+    }
+    return paths;
+}
 function getToolBadge(name) {
     const blue = chalk.hex('#0a84ff');
     const amber = chalk.hex('#ff9f0a');
@@ -680,6 +704,49 @@ export class Agent {
                 }
                 enrichedPrompt += "\n\n=== Enriched Code Context (Auto-Parsed) ===\n" + contexts.join("\n\n") + "\n===========================================";
             }
+            // Auto-resolve any file paths explicitly mentioned in the user message
+            try {
+                const potentialPaths = extractFilePaths(userMessage);
+                const autoResolvedContexts = [];
+                for (const rawPath of potentialPaths) {
+                    // Skip if already in diagnostics to avoid duplication
+                    if (diagnostics.some(d => d.resource.toLowerCase().includes(rawPath.toLowerCase()))) {
+                        continue;
+                    }
+                    const filePath = normalizeFilePath(rawPath);
+                    try {
+                        const stats = await fs.stat(filePath);
+                        if (stats.isFile()) {
+                            const content = await fs.readFile(filePath, "utf-8");
+                            const lines = content.split(/\r?\n/);
+                            const fileContentText = lines.length > 800
+                                ? lines.slice(0, 800).join("\n") + "\n... [Content truncated: first 800 lines shown] ..."
+                                : content;
+                            autoResolvedContexts.push(`File: ${rawPath}\n\`\`\`\n${fileContentText}\n\`\`\``);
+                        }
+                    }
+                    catch {
+                        try {
+                            // Try resolving relative path if absolute resolution failed
+                            const relativePath = path.relative("/", filePath).replace(/^[a-zA-Z]:/, "").replace(/^\\+|^[//]+/, "");
+                            const stats = await fs.stat(relativePath);
+                            if (stats.isFile()) {
+                                const content = await fs.readFile(relativePath, "utf-8");
+                                const lines = content.split(/\r?\n/);
+                                const fileContentText = lines.length > 800
+                                    ? lines.slice(0, 800).join("\n") + "\n... [Content truncated: first 800 lines shown] ..."
+                                    : content;
+                                autoResolvedContexts.push(`File: ${rawPath}\n\`\`\`\n${fileContentText}\n\`\`\``);
+                            }
+                        }
+                        catch { }
+                    }
+                }
+                if (autoResolvedContexts.length > 0) {
+                    enrichedPrompt += "\n\n=== Auto-Resolved File Context ===\n" + autoResolvedContexts.join("\n\n") + "\n===================================";
+                }
+            }
+            catch { }
             this.memory.add({ role: "user", content: enrichedPrompt });
             let iterations = 0;
             const MAX_ITERATIONS = 12;

package/dist/memory.js

@@ -15,7 +15,7 @@ CORE OPERATING PRINCIPLES
    - What is the correct file/folder structure?
    - What dependencies are required and at what versions?
    - What edge cases exist in this domain?
-   If the target file and required changes are obvious (especially when resolved directly from the ## File-to-Data Map in memory or recent history), skip writing a verbose plan and execute the read/edit tools immediately in the very first turn to proceed as fast as possible. Otherwise, output a brief plan (3–8 bullet points) before writing code, labeled "PLAN:".
+   If the target file is clear, or if its contents are already provided in the prompt context (e.g. under "Auto-Resolved File Context"), skip writing a plan, reasoning preamble, or explanation. Proceed directly to executing the edit tools (like patch_file or write_file) in the very first turn to achieve the goal as fast as possible. Minimize conversational turns and thinking overhead.
 
 2. WRITE COMPLETE, RUNNABLE OUTPUT
    - Never write "// TODO", "// implement this", or skeleton functions unless the user explicitly asks for a scaffold.
@@ -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.7",
+  "version": "2.9.9",
   "description": "CLI coding agent powered by Google Gemini",
   "type": "module",
   "main": "dist/index.js",