coder-agent 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,104 @@
+# 🤖 Coder
+
+A powerful, zero-dependency, cross-platform CLI coding agent powered by **Google Gemini** (gemini-2.5-flash / gemini-2.5-pro) with native tool execution and a clean, minimal Apple-inspired design.
+
+## Features
+
+- **Apple-Inspired Design**: A clean, high-contrast, minimalist terminal UI styled in elegant monochrome greys and whites.
+- **Global CLI Execution**: Install once and run anywhere via `coder` (or the `gemini-agent` / `groq-agent` compatibility aliases).
+- **System Automation Tools**:
+  - `read_file` / `write_file` / `patch_file` — Segmented reading and patch-based editing.
+  - `list_directory` / `find_files` — Recursive structure traversal.
+  - `run_shell` — Direct command execution in Windows, macOS, or Linux terminals.
+  - `web_search` — DuckDuckGo instant answers for documentation retrieval.
+- **Context Persistence**: Local JSON-based persistent configuration stored in `~/.coder-config.json` for key management and default model settings.
+- **Interactive REPL & Single-Shot Modes**:
+  - Start the interactive shell with `coder`.
+  - Execute a direct command: `coder "build a quicksort function in python"` (exits upon completion).
+
+---
+
+## Installation
+
+Install globally via npm:
+
+```bash
+npm install -g coder-agent
+```
+
+Or execute directly without installation:
+
+```bash
+npx coder-agent
+```
+
+---
+
+## Setup & Configuration
+
+The agent requires a **Gemini API Key**.
+
+### 1. Interactive Bootstrapping
+Simply run `coder`. If no key is configured, the CLI will interactively prompt you for the key and offer to save it globally.
+
+### 2. Command Line Flags
+You can save your key globally at any time using flags:
+
+```bash
+coder --set-key YOUR_GEMINI_API_KEY
+```
+
+### 3. Environment Variables
+Alternatively, you can export it as an environment variable:
+
+```bash
+export GEMINI_API_KEY=AIzaSy...
+```
+
+---
+
+## Usage & Arguments
+
+### REPL Mode
+Start an interactive pair programming session:
+```bash
+coder
+```
+
+### Single-Shot Prompt Mode
+Run a prompt directly from the shell:
+```bash
+coder "write a binary search script in Python"
+```
+
+### CLI Command Options
+- `-h, --help` — Show the help screen.
+- `-v, --version` — Show version information.
+- `--model <name>` — Set the default Gemini model globally.
+- `--set-key <key>` — Persist your Gemini API Key globally.
+- `--memory <scope>` — Define memory scope (`project`, `user`, or `local`).
+
+---
+
+## Built-in REPL Commands
+
+Type these commands directly inside the interactive session:
+
+| Command | Description |
+|---------|-------------|
+| `/model [name]` | View active model or switch active model dynamically (e.g. `/model gemini-2.5-pro`) |
+| `/clear` | Wipe conversation memory |
+| `/status` | Show active model and memory usage details |
+| `/help` | Show command summary |
+| `/exit` | Quit Coder |
+
+---
+
+## Popular Models Supported
+- `gemini-2.5-flash` (Default, highly capable, extremely fast, massive 1M+ token context)
+- `gemini-2.5-pro` (Reasoning model, superb for complex coding tasks)
+- `gemini-2.0-flash` (Ultra-fast, lightweight)
+- `gemini-2.0-pro-exp` (Experimental reasoning model)
+
+## License
+MIT

package/dist/agent.js

@@ -0,0 +1,213 @@
+import chalk from "chalk";
+import * as path from "path";
+import { TOOL_DEFINITIONS, dispatchTool } from "./tools.js";
+import { Memory } from "./memory.js";
+function extractTextToolCalls(content) {
+    const calls = [];
+    // Pattern 1: <function(name)> {args} </function>
+    const pattern1 = /<function\((\w+)\)>([\s\S]*?)(?:<\/function>)?/g;
+    let match;
+    while ((match = pattern1.exec(content)) !== null) {
+        try {
+            const name = match[1];
+            const argsText = match[2].trim();
+            const args = JSON.parse(argsText);
+            calls.push({
+                id: `text_call_${Math.random().toString(36).substring(2, 9)}`,
+                name,
+                args,
+                rawText: match[0]
+            });
+        }
+        catch { }
+    }
+    // Pattern 1b: <function(name){args}></function>
+    const pattern1b = /<function\((\w+)\)({[\s\S]*?})>(?:<\/function>)?/g;
+    pattern1b.lastIndex = 0;
+    while ((match = pattern1b.exec(content)) !== null) {
+        try {
+            const name = match[1];
+            const argsText = match[2].trim();
+            if (calls.some(c => c.rawText === match[0]))
+                continue;
+            const args = JSON.parse(argsText);
+            calls.push({
+                id: `text_call_${Math.random().toString(36).substring(2, 9)}`,
+                name,
+                args,
+                rawText: match[0]
+            });
+        }
+        catch { }
+    }
+    // Pattern 2: <function=name>{args}</function>
+    const pattern2 = /<function=(\w+)>({[\s\S]*?})<\/function>/g;
+    pattern2.lastIndex = 0;
+    while ((match = pattern2.exec(content)) !== null) {
+        try {
+            const name = match[1];
+            const args = JSON.parse(match[2]);
+            if (calls.some(c => c.rawText === match[0]))
+                continue;
+            calls.push({
+                id: `text_call_${Math.random().toString(36).substring(2, 9)}`,
+                name,
+                args,
+                rawText: match[0]
+            });
+        }
+        catch { }
+    }
+    return calls;
+}
+async function callGeminiAPI(apiKey, params, maxRetries = 3, initialDelayMs = 1500) {
+    let attempts = 0;
+    while (attempts < maxRetries) {
+        try {
+            const res = await fetch("https://generativelanguage.googleapis.com/v1beta/openai/chat/completions", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${apiKey}`
+                },
+                body: JSON.stringify(params)
+            });
+            if (!res.ok) {
+                const errText = await res.text();
+                const err = new Error(`Gemini API error (${res.status}): ${errText}`);
+                err.status = res.status;
+                throw err;
+            }
+            return await res.json();
+        }
+        catch (err) {
+            attempts++;
+            const status = err?.status;
+            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;
+            }
+            throw err;
+        }
+    }
+}
+export class Agent {
+    apiKey;
+    memory;
+    model;
+    memoryScope;
+    constructor(apiKey, model = "gemini-2.5-flash", memoryScope = "project") {
+        this.apiKey = apiKey;
+        this.memory = new Memory();
+        this.model = model;
+        this.memoryScope = memoryScope;
+    }
+    clearMemory() {
+        this.memory.clear();
+    }
+    memoryStatus() {
+        return this.memory.summary();
+    }
+    getModel() {
+        return this.model;
+    }
+    setModel(model) {
+        this.model = model;
+    }
+    async chat(userMessage) {
+        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 modifiedFiles = new Set();
+        while (iterations < MAX_ITERATIONS) {
+            iterations++;
+            const response = await callGeminiAPI(this.apiKey, {
+                model: this.model,
+                messages: this.memory.getAll(),
+                tools: TOOL_DEFINITIONS,
+                tool_choice: "auto",
+                temperature: 0.2,
+            });
+            const choice = response.choices[0];
+            const msg = choice.message;
+            // Extract text-based tool calls if native tool_calls is empty
+            let toolCalls = msg.tool_calls || [];
+            const extracted = extractTextToolCalls(msg.content ?? "");
+            if (toolCalls.length === 0 && extracted.length > 0) {
+                toolCalls = extracted.map(e => ({
+                    id: e.id,
+                    type: "function",
+                    function: {
+                        name: e.name,
+                        arguments: JSON.stringify(e.args)
+                    }
+                }));
+            }
+            // Save assistant message to memory (with standard/parsed tool calls)
+            const assistantMsg = {
+                role: "assistant",
+                content: msg.content ?? "",
+                tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+            };
+            this.memory.add(assistantMsg);
+            // Clean up text tool calls from the conversational output content
+            let 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 ❯ ") + cleanContent);
+                }
+                break;
+            }
+            // If the model returned conversational text along with tool calls, print it cleanly
+            if (cleanContent) {
+                console.log("\n" + chalk.bold.white("coder ❯ ") + cleanContent);
+            }
+            // ── Execute tool calls ────────────────────────────────────────────────
+            for (const toolCall of toolCalls) {
+                const name = toolCall.function.name;
+                let args = {};
+                try {
+                    args = JSON.parse(toolCall.function.arguments);
+                }
+                catch { }
+                console.log(chalk.gray(`  ○ tool: ${name}`) + chalk.gray(` (${JSON.stringify(args).slice(0, 100)}...)`));
+                // Track created or modified files
+                if (name === "write_file" || name === "patch_file") {
+                    if (args.file_path) {
+                        modifiedFiles.add(path.normalize(args.file_path));
+                    }
+                }
+                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));
+                this.memory.add({
+                    role: "tool",
+                    content: result,
+                    tool_call_id: toolCall.id,
+                    name,
+                });
+            }
+        }
+        // Print a clean summary of modified files at the end of the conversation turn
+        if (modifiedFiles.size > 0) {
+            console.log(chalk.gray("\n  Modified files:"));
+            for (const file of modifiedFiles) {
+                console.log(chalk.white(`  • ${file}`));
+            }
+        }
+        if (iterations >= MAX_ITERATIONS) {
+            console.log(chalk.red("  ✗ Max tool iterations reached."));
+        }
+    }
+}

package/dist/config.js

@@ -0,0 +1,82 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+const CONFIG_FILE = path.join(os.homedir(), ".coder-config.json");
+const OLD_GEMINI_CONFIG_FILE = path.join(os.homedir(), ".gemini-agent-config.json");
+const OLD_GROQ_CONFIG_FILE = path.join(os.homedir(), ".groq-agent-config.json");
+async function readConfig() {
+    // Try reading the primary Coder config file
+    try {
+        const data = await fs.readFile(CONFIG_FILE, "utf-8");
+        return JSON.parse(data);
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            // Try migrating from the gemini config file
+            try {
+                const data = await fs.readFile(OLD_GEMINI_CONFIG_FILE, "utf-8");
+                const oldConfig = JSON.parse(data);
+                const migrated = {
+                    geminiApiKey: oldConfig.geminiApiKey,
+                    defaultModel: oldConfig.defaultModel,
+                };
+                // Save the migrated config immediately
+                await writeConfig(migrated);
+                return migrated;
+            }
+            catch {
+                // Try migrating from the older groq config file
+                try {
+                    const data = await fs.readFile(OLD_GROQ_CONFIG_FILE, "utf-8");
+                    const oldConfig = JSON.parse(data);
+                    const migrated = {
+                        geminiApiKey: oldConfig.geminiApiKey || oldConfig.apiKey,
+                        defaultModel: oldConfig.defaultModel,
+                    };
+                    // Save the migrated config immediately
+                    await writeConfig(migrated);
+                    return migrated;
+                }
+                catch {
+                    return {};
+                }
+            }
+        }
+        return {};
+    }
+}
+async function writeConfig(config) {
+    try {
+        await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+    }
+    catch (err) {
+        console.error(`\n  ⚠️  Failed to save config to ${CONFIG_FILE}: ${err.message}`);
+    }
+}
+export async function getStoredApiKey() {
+    const config = await readConfig();
+    return config.geminiApiKey;
+}
+export async function saveApiKey(apiKey) {
+    const config = await readConfig();
+    config.geminiApiKey = apiKey;
+    await writeConfig(config);
+}
+export async function getStoredModel() {
+    const config = await readConfig();
+    return config.defaultModel;
+}
+export async function saveModel(model) {
+    const config = await readConfig();
+    config.defaultModel = model;
+    await writeConfig(config);
+}
+export async function getStoredGeminiApiKey() {
+    const config = await readConfig();
+    return config.geminiApiKey;
+}
+export async function saveGeminiApiKey(geminiApiKey) {
+    const config = await readConfig();
+    config.geminiApiKey = geminiApiKey;
+    await writeConfig(config);
+}

package/dist/index.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+import * as readline from "readline";
+import chalk from "chalk";
+import { Agent } from "./agent.js";
+import { getStoredApiKey, saveApiKey, getStoredModel, saveModel } from "./config.js";
+const VALID_MODELS = [
+    "gemini-2.5-flash",
+    "gemini-2.5-pro",
+    "gemini-2.0-flash",
+    "gemini-2.0-pro-exp"
+];
+// ─── Banner ──────────────────────────────────────────────────────────────────
+function printBanner(modelName) {
+    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("");
+}
+function printHelp() {
+    console.log(chalk.bold.white("\n  Coder CLI v1.1\n"));
+    console.log(chalk.gray("  Usage:"));
+    console.log(chalk.white("    coder                     — Start the interactive REPL"));
+    console.log(chalk.white("    coder [options]           — Run with config options"));
+    console.log(chalk.white("    coder \"your query here\"   — Run in single-shot mode (exits after completion)"));
+    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("    --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("");
+    console.log(chalk.gray("  Popular Gemini Models:"));
+    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("");
+}
+// ─── API Key Bootstrap ────────────────────────────────────────────────────────
+async function promptApiKey() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        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"));
+        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."));
+                rl.close();
+                process.exit(1);
+            }
+            rl.question(chalk.gray("  Save this key globally? (y/N): "), async (answer) => {
+                const save = answer.toLowerCase().startsWith("y");
+                if (save) {
+                    await saveApiKey(trimmedKey);
+                    console.log(chalk.gray(`  ✓ Key saved to ~/.coder-config.json`));
+                }
+                else {
+                    console.log(chalk.gray(`  ⚠ Using key for this session only (not saved).`));
+                }
+                rl.close();
+                resolve(trimmedKey);
+            });
+        });
+    });
+}
+// ─── Main Execution ───────────────────────────────────────────────────────────
+async function main() {
+    const args = process.argv.slice(2);
+    let tempModel;
+    let tempMemoryScope;
+    const queryArgs = [];
+    // Parse arguments manually
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--model") {
+            tempModel = args[i + 1];
+            i++; // skip next arg
+        }
+        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'."));
+                process.exit(1);
+            }
+            tempMemoryScope = scope;
+            i++; // skip next arg
+        }
+        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."));
+                process.exit(1);
+            }
+            await saveApiKey(key);
+            console.log(chalk.gray("✓ Gemini API Key saved successfully to global config."));
+            process.exit(0);
+        }
+        else if (args[i] === "-h" || args[i] === "--help") {
+            printHelp();
+            process.exit(0);
+        }
+        else if (args[i] === "-v" || args[i] === "--version") {
+            console.log("coder v1.1.0");
+            process.exit(0);
+        }
+        else {
+            queryArgs.push(args[i]);
+        }
+    }
+    // Load stored settings
+    const storedKey = await getStoredApiKey();
+    const envKey = process.env.GEMINI_API_KEY || process.env.GROQ_API_KEY;
+    let apiKey = envKey || storedKey;
+    const storedModel = await getStoredModel();
+    const defaultModel = storedModel || "gemini-2.5-flash";
+    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}`));
+        process.exit(0);
+    }
+    // Bootstrap API Key if missing
+    if (!apiKey) {
+        apiKey = await promptApiKey();
+    }
+    const agent = new Agent(apiKey, modelToUse, tempMemoryScope);
+    // 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) {
+            if (err?.status === 401) {
+                console.log(chalk.red("✗ Invalid API key. Check your configuration."));
+            }
+            else if (err?.status === 429) {
+                console.log(chalk.red("\n✗ Rate limit exceeded on Gemini API."));
+            }
+            else {
+                console.log(chalk.red(`✗ Error: ${err.message}`));
+            }
+            process.exit(1);
+        }
+        process.exit(0);
+    }
+    // Interactive REPL Mode
+    printBanner(modelToUse);
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true,
+    });
+    const prompt = () => {
+        rl.question(chalk.gray("\ncoder ❯ "), async (input) => {
+            const trimmed = input.trim();
+            if (!trimmed) {
+                prompt();
+                return;
+            }
+            // Built-in slash commands
+            if (trimmed === "/exit" || trimmed === "/quit") {
+                console.log(chalk.gray("\nGoodbye."));
+                rl.close();
+                process.exit(0);
+            }
+            if (trimmed === "/clear") {
+                agent.clearMemory();
+                prompt();
+                return;
+            }
+            if (trimmed === "/status") {
+                console.log(chalk.gray(`  Model:  `) + chalk.white(agent.getModel()));
+                console.log(chalk.gray(`  Memory: `) + chalk.white(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>`));
+                }
+                else {
+                    const newModel = parts[1];
+                    agent.setModel(newModel);
+                    console.log(chalk.gray(`\n✓ Switched active model to: ${newModel}`));
+                }
+                prompt();
+                return;
+            }
+            if (trimmed === "/help") {
+                console.log(chalk.bold.white("\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.gray(`    • Stored at: ~/.coder-config.json
+    • To change key: Exit and run 'coder --set-key <key>'
+    • Env variable option: GEMINI_API_KEY`));
+                prompt();
+                return;
+            }
+            try {
+                await agent.chat(trimmed);
+            }
+            catch (err) {
+                if (err?.status === 401) {
+                    console.log(chalk.red("✗ Invalid API key. Check your configuration."));
+                }
+                else if (err?.status === 429) {
+                    console.log(chalk.red("\n✗ Rate limit exceeded on Gemini API."));
+                }
+                else {
+                    console.log(chalk.red(`✗ Error: ${err.message}`));
+                }
+            }
+            prompt();
+        });
+    };
+    // 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}`));
+    process.exit(1);
+});

package/dist/memory.js

@@ -0,0 +1,257 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+const SYSTEM_PROMPT = `You are a powerful, intelligent CLI coding agent named Coder. You help users write code, debug, manage files, run commands, and search the web.
+
+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.
+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.
+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.
+
+Guidelines:
+- Be concise in your explanations; let code and command output speak for itself.
+- When writing code, always use write_file then run_shell to verify it 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.
+- 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.
+- 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.
+- If a shell command fails, hangs, or times out with minimal output (e.g. "Command failed"), do not make blind edits to configuration files (like package.json). Inspect the source code of the entry point or script to see if it requires environment variables (e.g., API keys), blocks on interactive terminal input (e.g., readline prompts), or has other expectations. You can test commands by passing dummy environment variables if needed.
+- If a task is ambiguous or you cannot find the code the user is referring to, ask ONE clarifying question before proceeding.
+- Always show the user what files you've created/modified.
+- 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.`;
+function sanitizeAgentTypeForPath(agentType) {
+    return agentType.replace(/:/g, "-");
+}
+function getLocalAgentMemoryDir(dirName) {
+    return path.join(process.cwd(), ".coder", "agent-memory-local", dirName);
+}
+export function getAgentMemoryDir(agentType, scope) {
+    const dirName = sanitizeAgentTypeForPath(agentType);
+    switch (scope) {
+        case "project":
+            return path.join(process.cwd(), ".coder", "agent-memory", dirName);
+        case "local":
+            return getLocalAgentMemoryDir(dirName);
+        case "user":
+            return path.join(os.homedir(), ".coder", "agent-memory", dirName);
+    }
+}
+export function getAgentMemoryEntrypoint(agentType, scope) {
+    return path.join(getAgentMemoryDir(agentType, scope), "MEMORY.md");
+}
+export function getMemoryScopeDisplay(memory) {
+    switch (memory) {
+        case "user":
+            return `User (${path.join(os.homedir(), ".coder", "agent-memory")})`;
+        case "project":
+            return "Project (.coder/agent-memory/)";
+        case "local":
+            return "Local (.coder/agent-memory-local/)";
+        default:
+            return "None";
+    }
+}
+export async function loadAgentMemoryPrompt(agentType, scope) {
+    const memoryDir = getAgentMemoryDir(agentType, scope);
+    const memoryFile = getAgentMemoryEntrypoint(agentType, scope);
+    // Ensure memory directory exists
+    try {
+        await fs.mkdir(memoryDir, { recursive: true });
+    }
+    catch (err) {
+        console.error(`Failed to create memory directory: ${err.message}`);
+    }
+    // Ensure MEMORY.md exists
+    let memoryContent = "";
+    try {
+        memoryContent = await fs.readFile(memoryFile, "utf-8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            // Try to migrate from gemini memory file first
+            const geminiMemoryFile = path.join(scope === "user" ? os.homedir() : process.cwd(), ".gemini-agent", scope === "local" ? "agent-memory-local" : "agent-memory", sanitizeAgentTypeForPath("gemini-agent"), "MEMORY.md");
+            // Try to migrate from groq memory file second
+            const groqMemoryFile = path.join(scope === "user" ? os.homedir() : process.cwd(), ".groq-agent", scope === "local" ? "agent-memory-local" : "agent-memory", sanitizeAgentTypeForPath("groq-agent"), "MEMORY.md");
+            try {
+                memoryContent = await fs.readFile(geminiMemoryFile, "utf-8");
+                // Save to new path
+                await fs.writeFile(memoryFile, memoryContent, "utf-8");
+            }
+            catch {
+                try {
+                    memoryContent = await fs.readFile(groqMemoryFile, "utf-8");
+                    // Save to new path
+                    await fs.writeFile(memoryFile, memoryContent, "utf-8");
+                }
+                catch {
+                    // Create default template
+                    const defaultTemplate = `# Persistent Agent Memory\n\nUse this section to write general rules, project setup details, style preferences, or learnings. Update this file using your write_file/patch_file tools to persist memories.\n\n## Learnings & Guidelines\n- (No memories stored yet. Add your learnings here.)\n`;
+                    try {
+                        await fs.writeFile(memoryFile, defaultTemplate, "utf-8");
+                        memoryContent = defaultTemplate;
+                    }
+                    catch (writeErr) {
+                        console.error(`Failed to create default memory file: ${writeErr.message}`);
+                    }
+                }
+            }
+        }
+        else {
+            console.error(`Failed to read memory file: ${err.message}`);
+        }
+    }
+    let scopeNote = "";
+    switch (scope) {
+        case "user":
+            scopeNote = "- Since this memory has 'user' scope, keep learnings general since they apply across all of the user's projects.";
+            break;
+        case "project":
+            scopeNote = "- Since this memory has 'project' scope and is shared with the team via version control, tailor memories specifically to this project.";
+            break;
+        case "local":
+            scopeNote = "- Since this memory has 'local' scope (not checked into version control), tailor memories specifically to this machine and project.";
+            break;
+    }
+    return `
+## Persistent Agent Memory
+You have access to a persistent memory file stored at: \`${memoryFile}\`.
+This memory is loaded at the start of every session and injected into your system prompt.
+
+### Guidelines for Memory Usage:
+1. Read the memory contents below to see existing learnings, project instructions, or user preferences.
+2. If you learn something new that would be useful for future sessions (e.g., build commands, package quirks, style guidelines, API details, tool workarounds), update this file directly using your \`write_file\` or \`patch_file\` tools targeting the file path: \`${memoryFile}\`.
+3. Keep the content concise, clean, and organized.
+${scopeNote}
+
+### Current Memory Contents:
+\`\`\`markdown
+${memoryContent}
+\`\`\`
+`;
+}
+async function getWorkspaceContext() {
+    const osPlatform = os.platform();
+    const cwd = process.cwd();
+    // Get top level files & folders
+    let topLevelStructure = "";
+    try {
+        const entries = await fs.readdir(cwd, { withFileTypes: true });
+        const folders = [];
+        const files = [];
+        for (const entry of entries) {
+            if (["node_modules", ".git", "dist", "build", ".coder", ".gemini-agent", ".groq-agent"].includes(entry.name)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                folders.push(`📁 ${entry.name}/`);
+            }
+            else {
+                files.push(`📄 ${entry.name}`);
+            }
+        }
+        topLevelStructure = [...folders, ...files].join("\n");
+    }
+    catch (err) {
+        topLevelStructure = `Error reading workspace structure: ${err.message}`;
+    }
+    // Check for package.json or key config files
+    let projectMeta = "";
+    try {
+        const packageJsonPath = path.join(cwd, "package.json");
+        const packageJsonData = await fs.readFile(packageJsonPath, "utf-8");
+        const pkg = JSON.parse(packageJsonData);
+        projectMeta += `\n- **Project Type**: Node.js / npm\n`;
+        if (pkg.name)
+            projectMeta += `  - **Name**: ${pkg.name}\n`;
+        if (pkg.version)
+            projectMeta += `  - **Version**: ${pkg.version}\n`;
+        if (pkg.scripts) {
+            projectMeta += `  - **Available Scripts**:\n` + Object.keys(pkg.scripts).map(s => `    - npm run ${s} (\`${pkg.scripts[s]}\`)`).join("\n") + "\n";
+        }
+        if (pkg.dependencies) {
+            projectMeta += `  - **Dependencies**:\n` + Object.keys(pkg.dependencies).map(d => `    - \`${d}\`: ${pkg.dependencies[d]}`).join("\n") + "\n";
+        }
+    }
+    catch (err) {
+        // Not a Node.js project or no package.json
+    }
+    // Check for python project config
+    try {
+        const reqsTxtPath = path.join(cwd, "requirements.txt");
+        await fs.stat(reqsTxtPath);
+        projectMeta += `\n- **Project Type**: Python (requirements.txt present)\n`;
+    }
+    catch { }
+    // Check for cargo
+    try {
+        const cargoTomlPath = path.join(cwd, "Cargo.toml");
+        await fs.stat(cargoTomlPath);
+        projectMeta += `\n- **Project Type**: Rust / Cargo (Cargo.toml present)\n`;
+    }
+    catch { }
+    // Check for tsconfig.json
+    let hasTsConfig = false;
+    try {
+        await fs.stat(path.join(cwd, "tsconfig.json"));
+        hasTsConfig = true;
+    }
+    catch { }
+    return `
+## Current Workspace & System Environment Context:
+- **Operating System Platform**: ${osPlatform}
+- **Current Working Directory**: \`${cwd}\`
+- **TypeScript Configured**: ${hasTsConfig ? "Yes (tsconfig.json present)" : "No"}
+${projectMeta}
+- **Workspace File Structure (excluding node_modules/dist/.git):**
+\`\`\`text
+${topLevelStructure || "(empty)"}
+\`\`\`
+`;
+}
+export class Memory {
+    messages = [];
+    maxMessages;
+    initialized = false;
+    scope = "project";
+    agentType = "coder";
+    constructor(maxMessages = 50) {
+        this.maxMessages = maxMessages;
+        this.messages.push({ role: "system", content: SYSTEM_PROMPT });
+    }
+    async init(scope = "project", agentType = "coder") {
+        if (this.initialized)
+            return;
+        this.scope = scope;
+        this.agentType = agentType;
+        const memoryPrompt = await loadAgentMemoryPrompt(agentType, scope);
+        const workspaceContext = await getWorkspaceContext();
+        this.messages[0].content = `${SYSTEM_PROMPT}\n\n${workspaceContext}\n\n${memoryPrompt}`;
+        this.initialized = true;
+    }
+    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))];
+        }
+    }
+    getAll() {
+        return this.messages;
+    }
+    clear() {
+        this.messages = [this.messages[0]]; // keep system prompt
+        console.log("  Memory cleared.");
+    }
+    summary() {
+        const turns = this.messages.filter(m => m.role === "user").length;
+        return `${turns} turn(s) in memory (${getMemoryScopeDisplay(this.scope)} scope)`;
+    }
+}

package/dist/tools.js

@@ -0,0 +1,342 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as fs from "fs/promises";
+import * as path from "path";
+const execAsync = promisify(exec);
+// ─── Tool Definitions (sent to Groq) ────────────────────────────────────────
+export const TOOL_DEFINITIONS = [
+    {
+        type: "function",
+        function: {
+            name: "read_file",
+            description: "Read the contents of a file from disk",
+            parameters: {
+                type: "object",
+                properties: {
+                    file_path: { type: "string", description: "Absolute or relative path to the file" },
+                },
+                required: ["file_path"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "write_file",
+            description: "Write or overwrite a file on disk",
+            parameters: {
+                type: "object",
+                properties: {
+                    file_path: { type: "string", description: "Path to write to" },
+                    content: { type: "string", description: "Content to write" },
+                },
+                required: ["file_path", "content"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "list_directory",
+            description: "List files and folders in a directory",
+            parameters: {
+                type: "object",
+                properties: {
+                    dir_path: { type: "string", description: "Directory path (default: current dir)" },
+                },
+                required: [],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "run_shell",
+            description: "Execute a shell command and return stdout/stderr. Use for running code, installing packages, git, etc.",
+            parameters: {
+                type: "object",
+                properties: {
+                    command: { type: "string", description: "Shell command to run" },
+                    cwd: { type: "string", description: "Working directory (optional). Must be a valid, existing directory. Do not use placeholders like 'current directory'." },
+                },
+                required: ["command"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "web_search",
+            description: "Search the web using DuckDuckGo instant answers API. Good for docs, errors, packages.",
+            parameters: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Search query" },
+                },
+                required: ["query"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "find_files",
+            description: "Recursively search for files in the project directory matching a search term or pattern. Excludes standard build/git/dependency directories.",
+            parameters: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Search query or pattern to match filenames (e.g. 'index' or 'agent.ts')" },
+                    dir_path: { type: "string", description: "Directory to start searching from (default: current dir)" }
+                },
+                required: ["query"]
+            }
+        }
+    },
+    {
+        type: "function",
+        function: {
+            name: "read_file_lines",
+            description: "Read a specific range of lines from a file on disk. Use this instead of read_file for large files to save token context.",
+            parameters: {
+                type: "object",
+                properties: {
+                    file_path: { type: "string", description: "Absolute or relative path to the file" },
+                    start_line: { type: "number", description: "First line to read (1-indexed, inclusive)" },
+                    end_line: { type: "number", description: "Last line to read (1-indexed, inclusive)" }
+                },
+                required: ["file_path", "start_line", "end_line"]
+            }
+        }
+    },
+    {
+        type: "function",
+        function: {
+            name: "search_grep",
+            description: "Search for a string pattern or regex across all project files recursively. Excludes dependencies and build directories.",
+            parameters: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Search query string or regex pattern to search for" },
+                    is_regex: { type: "boolean", description: "Whether to treat query as a regular expression (default: false)" }
+                },
+                required: ["query"]
+            }
+        }
+    },
+    {
+        type: "function",
+        function: {
+            name: "patch_file",
+            description: "Replace a specific contiguous block of text in a file with new code. This is much faster and safer than write_file for editing existing files.",
+            parameters: {
+                type: "object",
+                properties: {
+                    file_path: { type: "string", description: "Path to the file to modify" },
+                    target_code: { type: "string", description: "The exact block of code to find and replace. Must match exactly (including spacing)." },
+                    replacement_code: { type: "string", description: "The replacement block of code" }
+                },
+                required: ["file_path", "target_code", "replacement_code"]
+            }
+        }
+    }
+];
+// ─── Tool Implementations ────────────────────────────────────────────────────
+export async function read_file({ file_path }) {
+    try {
+        const content = await fs.readFile(file_path, "utf-8");
+        return content;
+    }
+    catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+}
+export async function write_file({ file_path, content }) {
+    try {
+        await fs.mkdir(path.dirname(file_path), { recursive: true });
+        await fs.writeFile(file_path, content, "utf-8");
+        return `✓ Written ${content.length} chars to ${file_path}`;
+    }
+    catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+}
+export async function list_directory({ dir_path = "." }) {
+    try {
+        const entries = await fs.readdir(dir_path, { withFileTypes: true });
+        const lines = entries.map((e) => `${e.isDirectory() ? "📁" : "📄"} ${e.name}`);
+        return lines.join("\n") || "(empty)";
+    }
+    catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+}
+export async function run_shell({ command, cwd }) {
+    try {
+        let targetCwd = process.cwd();
+        if (cwd) {
+            try {
+                const stats = await fs.stat(cwd);
+                if (!stats.isDirectory()) {
+                    return `ERROR: The specified working directory (cwd) "${cwd}" is a file, not a directory.`;
+                }
+                targetCwd = path.resolve(cwd);
+            }
+            catch (err) {
+                return `ERROR: The specified working directory (cwd) "${cwd}" does not exist. Please specify a valid, existing directory path or omit 'cwd'.`;
+            }
+        }
+        const { stdout, stderr } = await execAsync(command, {
+            cwd: targetCwd,
+            timeout: 30_000,
+        });
+        const out = [stdout.trim(), stderr.trim()].filter(Boolean).join("\n--- stderr ---\n");
+        return out || "(no output)";
+    }
+    catch (e) {
+        return `EXIT ${e.code ?? "?"}: ${e.stderr || e.message}`;
+    }
+}
+export async function web_search({ query }) {
+    try {
+        const url = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1&skip_disambig=1`;
+        const res = await fetch(url);
+        const data = (await res.json());
+        const parts = [];
+        if (data.AbstractText)
+            parts.push(`📖 ${data.AbstractText}`);
+        if (data.Answer)
+            parts.push(`⚡ ${data.Answer}`);
+        if (data.RelatedTopics?.length) {
+            const topics = data.RelatedTopics
+                .slice(0, 4)
+                .filter((t) => t.Text)
+                .map((t) => `• ${t.Text}`);
+            if (topics.length)
+                parts.push("Related:\n" + topics.join("\n"));
+        }
+        return parts.length ? parts.join("\n\n") : `No instant answer found for: "${query}". Try rephrasing.`;
+    }
+    catch (e) {
+        return `Search error: ${e.message}`;
+    }
+}
+async function walkDir(dir, fileList = []) {
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (["node_modules", ".git", "dist", "build", "__pycache__", ".next", "out"].includes(entry.name)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                await walkDir(fullPath, fileList);
+            }
+            else {
+                fileList.push(fullPath);
+            }
+        }
+    }
+    catch { }
+    return fileList;
+}
+export async function find_files({ query, dir_path = "." }) {
+    try {
+        const allFiles = await walkDir(dir_path);
+        const lowercaseQuery = query.toLowerCase();
+        const matches = allFiles
+            .map(f => path.relative(dir_path, f))
+            .filter(f => f.toLowerCase().includes(lowercaseQuery));
+        if (matches.length === 0) {
+            return `No files found matching: "${query}"`;
+        }
+        return matches.slice(0, 50).join("\n") + (matches.length > 50 ? `\n… (and ${matches.length - 50} more files)` : "");
+    }
+    catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+}
+export async function read_file_lines({ file_path, start_line, end_line }) {
+    try {
+        const content = await fs.readFile(file_path, "utf-8");
+        const lines = content.split(/\r?\n/);
+        const totalLines = lines.length;
+        const start = Math.max(1, start_line);
+        const end = Math.min(totalLines, end_line);
+        if (start > totalLines || start > end) {
+            return `ERROR: Invalid line range ${start_line}-${end_line}. Total lines in file: ${totalLines}.`;
+        }
+        const slice = lines.slice(start - 1, end);
+        const numberedLines = slice.map((line, idx) => `${start + idx}: ${line}`);
+        return `[Showing lines ${start}-${end} of ${totalLines} in ${file_path}]\n` + numberedLines.join("\n");
+    }
+    catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+}
+export async function search_grep({ query, is_regex = false }) {
+    try {
+        const allFiles = await walkDir(".");
+        const matches = [];
+        let regex;
+        if (is_regex) {
+            regex = new RegExp(query, "i");
+        }
+        else {
+            const escaped = query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            regex = new RegExp(escaped, "i");
+        }
+        for (const filePath of allFiles) {
+            try {
+                const content = await fs.readFile(filePath, "utf-8");
+                const lines = content.split(/\r?\n/);
+                for (let i = 0; i < lines.length; i++) {
+                    if (regex.test(lines[i])) {
+                        const relPath = path.relative(".", filePath);
+                        matches.push(`${relPath}:${i + 1}: ${lines[i].trim()}`);
+                    }
+                }
+            }
+            catch { }
+        }
+        if (matches.length === 0) {
+            return `No matches found for query: "${query}"`;
+        }
+        return matches.slice(0, 50).join("\n") + (matches.length > 50 ? `\n… (and ${matches.length - 50} more occurrences)` : "");
+    }
+    catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+}
+export async function patch_file({ file_path, target_code, replacement_code }) {
+    try {
+        const content = await fs.readFile(file_path, "utf-8");
+        if (!content.includes(target_code)) {
+            return `ERROR: Target code not found in file ${file_path}. Please verify target content.`;
+        }
+        const occurrences = content.split(target_code).length - 1;
+        if (occurrences > 1) {
+            return `ERROR: Target code matches ${occurrences} times in file ${file_path}. Please provide more unique context to target the exact edit.`;
+        }
+        const newContent = content.replace(target_code, replacement_code);
+        await fs.writeFile(file_path, newContent, "utf-8");
+        return `✓ Patched file ${file_path} successfully.`;
+    }
+    catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+}
+// ─── Dispatcher ──────────────────────────────────────────────────────────────
+export async function dispatchTool(name, args) {
+    switch (name) {
+        case "read_file": return read_file(args);
+        case "write_file": return write_file(args);
+        case "list_directory": return list_directory(args);
+        case "run_shell": return run_shell(args);
+        case "web_search": return web_search(args);
+        case "find_files": return find_files(args);
+        case "read_file_lines": return read_file_lines(args);
+        case "search_grep": return search_grep(args);
+        case "patch_file": return patch_file(args);
+        default: return `Unknown tool: ${name}`;
+    }
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "coder-agent",
+  "version": "2.0.0",
+  "description": "CLI coding agent powered by Google Gemini",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "coder": "dist/index.js",
+    "gemini-agent": "dist/index.js",
+    "groq-agent": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "preferGlobal": true,
+  "license": "MIT",
+  "keywords": [
+    "gemini",
+    "cli",
+    "agent",
+    "coding-agent",
+    "ai",
+    "coder"
+  ],
+  "scripts": {
+    "start": "tsx src/index.ts",
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc && node -e \"const fs = require('fs'); const f = 'dist/index.js'; let c = fs.readFileSync(f, 'utf8'); if (!c.startsWith('#!/usr/bin/env node')) c = '#!/usr/bin/env node\\n' + c; fs.writeFileSync(f, c.replace(/\\r\\n/g, '\\n'), 'utf8')\"",
+    "prepublishOnly": "npm run build",
+    "start:build": "node dist/index.js"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.4.0"
+  }
+}