coder-agent 2.1.0 → 2.2.0

package/dist/agent.js

@@ -2,6 +2,136 @@ import chalk from "chalk";
 import * as path from "path";
 import { TOOL_DEFINITIONS, dispatchTool } from "./tools.js";
 import { Memory } from "./memory.js";
+// ─── Loading Spinner ──────────────────────────────────────────────────────────
+let spinnerTimer = null;
+let currentFrame = 0;
+const frames = ['·  ', '·· ', '···', ' ··', '  ·'];
+const colorBlue = chalk.hex('#0a84ff');
+function startSpinner(label) {
+    stopSpinner();
+    currentFrame = 0;
+    process.stdout.write(`\r${colorBlue(frames[currentFrame])} ${chalk.dim(label)}`);
+    spinnerTimer = setInterval(() => {
+        currentFrame = (currentFrame + 1) % frames.length;
+        process.stdout.write(`\r${colorBlue(frames[currentFrame])} ${chalk.dim(label)}`);
+    }, 120);
+}
+function updateSpinner(label) {
+    if (spinnerTimer) {
+        process.stdout.write(`\r\x1b[K${colorBlue(frames[currentFrame])} ${chalk.dim(label)}`);
+    }
+}
+function stopSpinner() {
+    if (spinnerTimer) {
+        clearInterval(spinnerTimer);
+        spinnerTimer = null;
+        process.stdout.write('\r\x1b[K');
+    }
+}
+// ─── Formatting Helpers ──────────────────────────────────────────────────────
+function getToolBadge(name) {
+    const blue = chalk.hex('#0a84ff');
+    const amber = chalk.hex('#ff9f0a');
+    const green = chalk.hex('#30d158');
+    switch (name) {
+        case "read_file":
+        case "read_file_lines":
+            return blue("[read]  ");
+        case "write_file":
+        case "patch_file":
+            return amber("[write] ");
+        case "run_shell":
+            return green("[run]   ");
+        case "list_directory":
+        case "find_files":
+        case "search_grep":
+        case "web_search":
+            return blue("[search]");
+        default:
+            return blue("[tool]  ");
+    }
+}
+function getToolTargetDescription(name, args) {
+    switch (name) {
+        case "read_file":
+        case "read_file_lines":
+        case "write_file":
+        case "patch_file":
+            return args.file_path || "unknown file";
+        case "run_shell":
+            return args.command || "unknown command";
+        case "list_directory":
+            return args.dir_path || ".";
+        case "find_files":
+            return `find: "${args.query}"`;
+        case "search_grep":
+            return `grep: "${args.query}"`;
+        case "web_search":
+            return `search: "${args.query}"`;
+        default:
+            return JSON.stringify(args);
+    }
+}
+function getToolDetailsDescription(name, args) {
+    switch (name) {
+        case "read_file":
+            return "read entire file";
+        case "read_file_lines":
+            return `lines ${args.start_line}–${args.end_line}`;
+        case "write_file":
+            return `write ${args.content?.length || 0} chars`;
+        case "patch_file":
+            return "apply selective patch";
+        case "run_shell":
+            return `cwd: ${args.cwd || "project root"}`;
+        case "list_directory":
+            return "list directory contents";
+        case "find_files":
+            return `search in ${args.dir_path || "."}`;
+        case "search_grep":
+            return args.is_regex ? "regex search" : "literal search";
+        case "web_search":
+            return "DuckDuckGo search";
+        default:
+            return "";
+    }
+}
+function getToolSuccessSummary(name, args, result) {
+    switch (name) {
+        case "read_file":
+            return `read ${args.file_path} (${result.length} chars)`;
+        case "read_file_lines":
+            return `read lines ${args.start_line}–${args.end_line} in ${args.file_path}`;
+        case "write_file":
+            return `written changes to ${args.file_path}`;
+        case "patch_file":
+            return `patched file ${args.file_path}`;
+        case "run_shell":
+            return `executed command: ${args.command}`;
+        case "list_directory":
+            return `listed ${args.dir_path || "."}`;
+        case "find_files":
+            const fileCount = result.split("\n").length;
+            return `found ${fileCount} matching files`;
+        case "search_grep":
+            const occurrenceCount = result.split("\n").length;
+            return `found ${occurrenceCount} occurrences`;
+        case "web_search":
+            return `retrieved search results for "${args.query}"`;
+        default:
+            return "completed successfully";
+    }
+}
+function formatResponseText(text) {
+    const parts = text.split(/(\*\*[^*]+\*\*)/g);
+    return parts.map(part => {
+        if (part.startsWith('**') && part.endsWith('**')) {
+            return chalk.white.bold(part.slice(2, -2));
+        }
+        return chalk.white(part);
+    }).join('');
+}
+// ─── Extract Text Tool Calls ──────────────────────────────────────────────────
 function extractTextToolCalls(content) {
     const calls = [];
     // Pattern 1: <function(name)> {args} </function>
@@ -60,6 +190,7 @@ function extractTextToolCalls(content) {
     }
     return calls;
 }
+// ─── Gemini API client ────────────────────────────────────────────────────────
 async function callGeminiAPI(apiKey, params, maxRetries = 3, initialDelayMs = 1500) {
     let attempts = 0;
     while (attempts < maxRetries) {
@@ -86,7 +217,6 @@ async function callGeminiAPI(apiKey, params, maxRetries = 3, initialDelayMs = 15
             const isRetryableError = status === 429 || status === 503 || (status >= 500 && status < 600) || !status;
             if (isRetryableError && attempts < maxRetries) {
                 const delay = initialDelayMs * Math.pow(2, attempts - 1);
-                console.log(chalk.gray(`  ⚠️  Gemini API busy (Status ${status || "network"}). Retrying in ${(delay / 1000).toFixed(1)}s (attempt ${attempts}/${maxRetries})...`));
                 await new Promise(resolve => setTimeout(resolve, delay));
                 continue;
             }
@@ -94,6 +224,7 @@ async function callGeminiAPI(apiKey, params, maxRetries = 3, initialDelayMs = 15
         }
     }
 }
+// ─── Agent Class ─────────────────────────────────────────────────────────────
 export class Agent {
     apiKey;
     memory;
@@ -121,10 +252,15 @@ export class Agent {
         await this.memory.init(this.memoryScope, "coder");
         this.memory.add({ role: "user", content: userMessage });
         let iterations = 0;
-        const MAX_ITERATIONS = 12; // prevent infinite tool loops
+        const MAX_ITERATIONS = 12;
         const modifiedFiles = new Set();
+        let cleanContent = "";
+        // ── Phase 1: Input to Thinking ──────────────────────────────────────────
+        console.log(chalk.dim('\n' + '─'.repeat(48) + '\n'));
+        startSpinner("thinking...");
         while (iterations < MAX_ITERATIONS) {
             iterations++;
+            updateSpinner("thinking...");
             const response = await callGeminiAPI(this.apiKey, {
                 model: this.model,
                 messages: this.memory.getAll(),
@@ -132,6 +268,7 @@ export class Agent {
                 tool_choice: "auto",
                 temperature: 0.2,
             });
+            stopSpinner();
             const choice = response.choices[0];
             const msg = choice.message;
             // Extract text-based tool calls if native tool_calls is empty
@@ -147,7 +284,7 @@ export class Agent {
                     }
                 }));
             }
-            // Save assistant message to memory (with standard/parsed tool calls)
+            // Save assistant message to memory
             const assistantMsg = {
                 role: "assistant",
                 content: msg.content ?? "",
@@ -155,23 +292,17 @@ export class Agent {
             };
             this.memory.add(assistantMsg);
             // Clean up text tool calls from the conversational output content
-            let cleanContent = msg.content ?? "";
+            cleanContent = msg.content ?? "";
             for (const call of extracted) {
                 cleanContent = cleanContent.replace(call.rawText, "");
             }
             cleanContent = cleanContent.trim();
             // ── No tool calls → final answer ─────────────────────────────────────
             if (toolCalls.length === 0) {
-                if (cleanContent) {
-                    console.log("\n" + chalk.bold.white("coder-agent ❯ ") + cleanContent);
-                }
                 break;
             }
-            // If the model returned conversational text along with tool calls, print it cleanly
-            if (cleanContent) {
-                console.log("\n" + chalk.bold.white("coder-agent ❯ ") + cleanContent);
-            }
-            // ── Execute tool calls ────────────────────────────────────────────────
+            // ── Phase 2: Tool Execution ───────────────────────────────────────────
+            const statusLines = [];
             for (const toolCall of toolCalls) {
                 const name = toolCall.function.name;
                 let args = {};
@@ -179,7 +310,12 @@ export class Agent {
                     args = JSON.parse(toolCall.function.arguments);
                 }
                 catch { }
-                console.log(chalk.gray(`  ○ tool: ${name}`) + chalk.gray(` (${JSON.stringify(args).slice(0, 100)}...)`));
+                // Render tool execution card
+                const badge = getToolBadge(name);
+                const target = getToolTargetDescription(name, args);
+                const details = getToolDetailsDescription(name, args);
+                console.log(`  ${badge}  ${chalk.gray(target)}`);
+                console.log(chalk.dim(`  ${details}`));
                 // Track created or modified files
                 if (name === "write_file" || name === "patch_file") {
                     if (args.file_path) {
@@ -187,10 +323,14 @@ export class Agent {
                     }
                 }
                 const result = await dispatchTool(name, args);
-                const preview = result.length > 300 ? result.slice(0, 300) + "\n    … (truncated)" : result;
-                // Format preview text elegantly with indentation
-                const indentedPreview = preview.split("\n").map(l => "    " + l).join("\n");
-                console.log(chalk.gray(indentedPreview));
+                // Generate outcome result status line
+                const isError = result.startsWith("ERROR:");
+                if (isError) {
+                    statusLines.push(`${chalk.hex('#ff453a')('✕')} ${chalk.gray(result.slice(6).trim())}`);
+                }
+                else {
+                    statusLines.push(`${chalk.hex('#30d158')('✓')} ${chalk.gray(getToolSuccessSummary(name, args, result))}`);
+                }
                 this.memory.add({
                     role: "tool",
                     content: result,
@@ -198,16 +338,29 @@ export class Agent {
                     name,
                 });
             }
+            // Stream results status lines
+            console.log("");
+            for (const line of statusLines) {
+                console.log(line);
+            }
+            if (iterations < MAX_ITERATIONS) {
+                console.log(chalk.dim('\n' + '─'.repeat(48) + '\n'));
+                startSpinner("thinking...");
+            }
         }
-        // Print a clean summary of modified files at the end of the conversation turn
+        // Output modified files metadata line if applicable
         if (modifiedFiles.size > 0) {
-            console.log(chalk.gray("\n  Modified files:"));
-            for (const file of modifiedFiles) {
-                console.log(chalk.white(`  • ${file}`));
-            }
+            console.log(chalk.dim('─') + ' ' + chalk.dim(`${modifiedFiles.size} file(s) modified`));
+        }
+        // ── Phase 3: Final Agent Response ───────────────────────────────────────
+        console.log(chalk.dim('\n' + '─'.repeat(48) + '\n'));
+        if (cleanContent) {
+            console.log(formatResponseText(cleanContent));
+            console.log(""); // one trailing blank line
         }
         if (iterations >= MAX_ITERATIONS) {
-            console.log(chalk.red("  ✗ Max tool iterations reached."));
+            console.log(chalk.hex('#ff453a')('✕ error'));
+            console.log(chalk.dim('  Max tool iterations reached.'));
         }
     }
 }

package/dist/index.js

@@ -9,30 +9,28 @@ const VALID_MODELS = [
     "gemini-2.0-flash",
     "gemini-2.0-pro-exp"
 ];
-// ─── Banner ──────────────────────────────────────────────────────────────────
+// ─── Startup Screen ──────────────────────────────────────────────────────────
 function printBanner(modelName) {
+    console.log(chalk.white.bold('coder-agent') + chalk.dim(' 1.1.0'));
     console.log("");
-    console.log(chalk.bold.white("  Coder"));
-    console.log(chalk.gray(`  Model:  ${modelName}`));
-    console.log(chalk.gray("  Status: Ready"));
-    console.log(chalk.gray("  ──────────────────────────────────────────────────────────"));
-    console.log(chalk.gray("  Tools:    ") + chalk.white("read_file · write_file · patch_file · search_grep · run_shell · web_search"));
-    console.log(chalk.gray("  Commands: ") + chalk.white("/model · /clear · /status · /help · /exit"));
-    console.log(chalk.gray("  ──────────────────────────────────────────────────────────"));
+    console.log(chalk.dim('model   ') + chalk.gray(modelName));
+    console.log(chalk.dim('context ') + chalk.gray('1m+ tokens'));
+    console.log(chalk.dim('tools   ') + chalk.gray('read · write · run · search'));
     console.log("");
+    console.log(chalk.dim('─'.repeat(48)));
 }
 function printHelp() {
-    console.log(chalk.bold.white("\n  Coder CLI v1.1\n"));
+    console.log(chalk.white.bold("\n  Coder CLI v1.1\n"));
     console.log(chalk.gray("  Usage:"));
     console.log(chalk.white("    coder-agent                     — Start the interactive REPL"));
     console.log(chalk.white("    coder-agent [options]           — Run with config options"));
-    console.log(chalk.white("    coder-agent \"your query here\"   — Run in single-shot mode (exits after completion)"));
+    console.log(chalk.white("    coder-agent \"your query here\"   — Run in single-shot mode"));
     console.log("");
     console.log(chalk.gray("  Options:"));
     console.log(chalk.white("    -h, --help                     — Show this help screen"));
     console.log(chalk.white("    -v, --version                  — Show version information"));
     console.log(chalk.white("    --model <model_name>           — Set default model globally"));
-    console.log(chalk.white("    --memory <scope>               — Set memory scope: 'user', 'project', or 'local' (default: 'project')"));
+    console.log(chalk.white("    --memory <scope>               — Set memory scope: 'user', 'project', or 'local'"));
     console.log(chalk.white("    --set-key <api_key>            — Save your Gemini API Key globally"));
     console.log(chalk.white("    --set-gemini-key <api_key>     — Save your Gemini API Key globally (alias)"));
     console.log("");
@@ -50,12 +48,13 @@ async function promptApiKey() {
         output: process.stdout,
     });
     return new Promise((resolve) => {
-        console.log(chalk.gray("\n  🔑 Gemini API Key is required."));
-        console.log(chalk.gray("     Get a free key at https://aistudio.google.com"));
+        console.log(chalk.dim("\n  🔑 Gemini API Key is required."));
+        console.log(chalk.dim("     Get a free key at https://aistudio.google.com"));
         rl.question(chalk.gray("\n  Enter Gemini API Key: "), async (key) => {
             const trimmedKey = key.trim();
             if (!trimmedKey) {
-                console.log(chalk.red("  ✗ API Key cannot be empty."));
+                console.log(chalk.hex('#ff453a')('✕ error'));
+                console.log(chalk.dim("  API Key cannot be empty."));
                 rl.close();
                 process.exit(1);
             }
@@ -63,10 +62,10 @@ async function promptApiKey() {
                 const save = answer.toLowerCase().startsWith("y");
                 if (save) {
                     await saveApiKey(trimmedKey);
-                    console.log(chalk.gray(`  ✓ Key saved to ~/.coder-config.json`));
+                    console.log(chalk.dim(`  ✓ Key saved to ~/.coder-config.json`));
                 }
                 else {
-                    console.log(chalk.gray(`  ⚠ Using key for this session only (not saved).`));
+                    console.log(chalk.dim(`  ⚠ Using key for this session only (not saved).`));
                 }
                 rl.close();
                 resolve(trimmedKey);
@@ -89,7 +88,8 @@ async function main() {
         else if (args[i] === "--memory") {
             const scope = args[i + 1];
             if (scope !== "user" && scope !== "project" && scope !== "local") {
-                console.log(chalk.red("✗ Invalid memory scope. Choose 'user', 'project', or 'local'."));
+                console.log(chalk.hex('#ff453a')('✕ error'));
+                console.log(chalk.dim("  Invalid memory scope. Choose 'user', 'project', or 'local'."));
                 process.exit(1);
             }
             tempMemoryScope = scope;
@@ -98,11 +98,12 @@ async function main() {
         else if (args[i] === "--set-key" || args[i] === "--set-gemini-key") {
             const key = args[i + 1];
             if (!key) {
-                console.log(chalk.red("✗ Please specify an API key."));
+                console.log(chalk.hex('#ff453a')('✕ error'));
+                console.log(chalk.dim("  Please specify an API key."));
                 process.exit(1);
             }
             await saveApiKey(key);
-            console.log(chalk.gray("✓ Gemini API Key saved successfully to global config."));
+            console.log(chalk.dim("✓ Gemini API Key saved successfully to global config."));
             process.exit(0);
         }
         else if (args[i] === "-h" || args[i] === "--help") {
@@ -127,14 +128,15 @@ async function main() {
         defaultModel = storedModel;
     }
     if (tempModel && !VALID_MODELS.includes(tempModel)) {
-        console.log(chalk.red(`✗ Invalid model: ${tempModel}. Choose one of: ${VALID_MODELS.join(", ")}`));
+        console.log(chalk.hex('#ff453a')('✕ error'));
+        console.log(chalk.dim(`  Invalid model: ${tempModel}. Choose one of: ${VALID_MODELS.join(", ")}`));
         process.exit(1);
     }
     const modelToUse = tempModel || defaultModel;
     // Save model if specified without query
     if (tempModel && queryArgs.length === 0) {
         await saveModel(tempModel);
-        console.log(chalk.gray(`✓ Default model set to: ${tempModel}`));
+        console.log(chalk.dim(`✓ Default model set to: ${tempModel}`));
         process.exit(0);
     }
     // Bootstrap API Key if missing
@@ -145,20 +147,19 @@ async function main() {
     // Single-Shot Mode
     if (queryArgs.length > 0) {
         const singleShotPrompt = queryArgs.join(" ").trim();
-        console.log(chalk.gray(`🚀 Running single-shot query using model '${modelToUse}'...`));
-        console.log(chalk.gray(`❯ Query: ${singleShotPrompt}`));
         try {
             await agent.chat(singleShotPrompt);
         }
         catch (err) {
+            console.log(chalk.hex('#ff453a')('✕ error'));
             if (err?.status === 401) {
-                console.log(chalk.red("✗ Invalid API key. Check your configuration."));
+                console.log(chalk.dim("  Invalid API key. Check your configuration."));
             }
             else if (err?.status === 429) {
-                console.log(chalk.red("\n✗ Rate limit exceeded on Gemini API."));
+                console.log(chalk.dim("  Rate limit exceeded on Gemini API."));
             }
             else {
-                console.log(chalk.red(`✗ Error: ${err.message}`));
+                console.log(chalk.dim(`  ${err.message}`));
             }
             process.exit(1);
         }
@@ -172,7 +173,7 @@ async function main() {
         terminal: true,
     });
     const prompt = () => {
-        rl.question(chalk.gray("\ncoder-agent ❯ "), async (input) => {
+        rl.question(chalk.hex('#0a84ff')('›') + ' ', async (input) => {
             const trimmed = input.trim();
             if (!trimmed) {
                 prompt();
@@ -180,43 +181,47 @@ async function main() {
             }
             // Built-in slash commands
             if (trimmed === "/exit" || trimmed === "/quit") {
-                console.log(chalk.gray("\nGoodbye."));
                 rl.close();
                 process.exit(0);
             }
             if (trimmed === "/clear") {
                 agent.clearMemory();
+                console.log(chalk.hex('#30d158')('✓') + ' ' + chalk.gray('Memory cleared'));
                 prompt();
                 return;
             }
             if (trimmed === "/status") {
-                console.log(chalk.gray(`  Model:  `) + chalk.white(agent.getModel()));
-                console.log(chalk.gray(`  Memory: `) + chalk.white(agent.memoryStatus()));
+                console.log(chalk.dim(`session · ${agent.memoryStatus()}`));
                 prompt();
                 return;
             }
             if (trimmed.startsWith("/model")) {
                 const parts = trimmed.split(/\s+/);
                 if (parts.length === 1) {
-                    console.log(chalk.gray(`\n  Active model: ${agent.getModel()}`));
-                    console.log(chalk.gray(`  Available models:\n` + VALID_MODELS.map(m => `    • ${m}`).join("\n")));
-                    console.log(chalk.gray(`\n  To switch model, run: /model <model-name>`));
+                    console.log(chalk.dim(`model   `) + chalk.gray(agent.getModel()));
+                    console.log(chalk.gray(`options `) + chalk.gray(VALID_MODELS.join(" · ")));
                 }
                 else {
                     const newModel = parts[1];
-                    agent.setModel(newModel);
-                    console.log(chalk.gray(`\n✓ Switched active model to: ${newModel}`));
+                    if (VALID_MODELS.includes(newModel)) {
+                        agent.setModel(newModel);
+                        console.log(chalk.hex('#30d158')('✓') + ' ' + chalk.gray(`Switched model to: ${newModel}`));
+                    }
+                    else {
+                        console.log(chalk.hex('#ff453a')('✕ error'));
+                        console.log(chalk.dim(`  Model must be one of: ${VALID_MODELS.join(" · ")}`));
+                    }
                 }
                 prompt();
                 return;
             }
             if (trimmed === "/help") {
-                console.log(chalk.bold.white("\n  Interactive Commands:"));
+                console.log(chalk.white.bold("\n  Interactive Commands:"));
                 console.log(chalk.gray(`    /model [name] — View active model or switch to [name]
     /clear        — Wipe conversation memory
     /status       — Show active model and memory usage
     /exit         — Exit Coder`));
-                console.log(chalk.bold.white("\n  API Keys & Configuration:"));
+                console.log(chalk.white.bold("\n  API Keys & Configuration:"));
                 console.log(chalk.gray(`    • Stored at: ~/.coder-config.json
     • To change key: Exit and run 'coder-agent --set-key <key>'
     • Env variable option: GEMINI_API_KEY`));
@@ -227,14 +232,15 @@ async function main() {
                 await agent.chat(trimmed);
             }
             catch (err) {
+                console.log(chalk.hex('#ff453a')('✕ error'));
                 if (err?.status === 401) {
-                    console.log(chalk.red("✗ Invalid API key. Check your configuration."));
+                    console.log(chalk.dim("  Invalid API key. Check your configuration."));
                 }
                 else if (err?.status === 429) {
-                    console.log(chalk.red("\n✗ Rate limit exceeded on Gemini API."));
+                    console.log(chalk.dim("  Rate limit exceeded on Gemini API."));
                 }
                 else {
-                    console.log(chalk.red(`✗ Error: ${err.message}`));
+                    console.log(chalk.dim(`  ${err.message}`));
                 }
             }
             prompt();
@@ -242,12 +248,12 @@ async function main() {
     };
     // Handle Ctrl+C gracefully
     rl.on("SIGINT", () => {
-        console.log(chalk.gray("\n\nGoodbye."));
         process.exit(0);
     });
     prompt();
 }
 main().catch((err) => {
-    console.error(chalk.red(`Fatal Error: ${err.message}`));
+    console.error(chalk.hex('#ff453a')('✕ error'));
+    console.error(chalk.dim(`  ${err.message}`));
     process.exit(1);
 });

package/dist/memory.js

@@ -6,7 +6,7 @@ const SYSTEM_PROMPT = `You are a powerful, intelligent CLI coding agent named Co
 The tools available to you are provided automatically by the API schema. Do NOT describe the tools in your text or invent custom tags.
 
 PRINCIPLES & SYSTEM PROTOCOLS FOR ERROR-FREE EXECUTION:
-1. Ground Truth Workspace Context: Use the provided environment platform info, workspace file structure snapshot, and package configurations as your primary source of requirements. Do not guess what files exist or how the project compiles.
+1. Ground Truth Workspace Context: Use the provided environment platform info, workspace file structure snapshot, and package configurations as your primary source of requirements. Note that the file structure snapshot only lists top-level files and folders, NOT the recursive contents of subdirectories. Do not assume a file in a subdirectory does not exist just because it is not in the top-level snapshot.
 2. Read before Writing/Editing: Always look at the files you want to change first. Read the relevant lines (using read_file_lines or read_file) to understand import requirements, types, and architecture.
 3. Precise Target Editing: Prefer patching files (using patch_file) over complete overwriting. Ensure targeted matches are unique and match exactly, leaving existing unrelated functions/comments intact.
 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.
@@ -20,6 +20,7 @@ Guidelines:
 - When you encounter errors, diagnose and fix them autonomously.
 - Prefer running commands to verify assumptions rather than guessing.
 - Before answering questions or checking for errors in the codebase, always inspect the workspace (e.g., list directories, read files) to identify the files and languages present. Do not guess file names or run commands on files without checking if they exist first.
+- Never assume a file mentioned in the user's query or diagnostic payload does not exist just because it is missing from the top-level file snapshot. Always attempt to read the file path directly (using read_file or read_file_lines), or search for it (using find_files) to verify its existence.
 - Focus on the actual files and programming language of the codebase you are currently running in (the user's repository). Do not assume the project is in a different language. Identify the project type and use appropriate commands (e.g., check package.json/tsconfig.json and run 'npm run build' or 'npx tsc' for TypeScript, or use python commands only if the workspace is a Python project).
 - NEVER create dummy or placeholder files (such as write_file of a hello-world 'test.py' or 'filename.py') to simulate compilation or execution. Work only with the actual code of the project.
 - When asked to "check for syntax errors" or "compile", do NOT search the files for the literal string "syntax error". Instead, run the project's compiler, build script, type-checker, or linter (such as 'npm run build', 'npx tsc --noEmit', or standard language compilers) to find actual code syntax issues.

package/package.json

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