@ikyyofc/gemini-cli 1.0.0

package/src/tools.js

@@ -0,0 +1,361 @@
+// src/tools.js — tool definitions (native Gemini schema) + executor
+import fs        from "fs";
+import path      from "path";
+import { promisify } from "util";
+import { exec }  from "child_process";
+import readline  from "readline";
+import chalk     from "chalk";
+
+const execAsync = promisify(exec);
+
+// ─────────────────────────────────────────────────────────────────
+//  FUNCTION DECLARATIONS  (sent directly in Gemini API payload)
+//  Format: OpenAPI-subset schema — type MUST be uppercase STRING/OBJECT/etc.
+// ─────────────────────────────────────────────────────────────────
+export const FUNCTION_DECLARATIONS = [
+    {
+        name: "read_file",
+        description: "Read the full contents of a file. Returns numbered lines. Always read a file before editing it.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                path: { type: "STRING", description: "Absolute or relative path to the file" }
+            },
+            required: ["path"]
+        }
+    },
+    {
+        name: "write_file",
+        description: "Create or overwrite a file with the provided content. Creates parent directories automatically.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                path:    { type: "STRING", description: "File path to write" },
+                content: { type: "STRING", description: "Complete file content to write" }
+            },
+            required: ["path", "content"]
+        }
+    },
+    {
+        name: "patch_file",
+        description: "Replace a specific unique string in a file with a new string. Use for targeted edits — much safer than rewriting whole files. The old_str must appear exactly once.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                path:    { type: "STRING", description: "File path to patch" },
+                old_str: { type: "STRING", description: "Exact unique string to find (with surrounding context if needed)" },
+                new_str: { type: "STRING", description: "Replacement string (can be empty to delete)" }
+            },
+            required: ["path", "old_str", "new_str"]
+        }
+    },
+    {
+        name: "append_file",
+        description: "Append text to the end of an existing file (or create it).",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                path:    { type: "STRING", description: "File path" },
+                content: { type: "STRING", description: "Content to append" }
+            },
+            required: ["path", "content"]
+        }
+    },
+    {
+        name: "list_dir",
+        description: "List files and subdirectories in a directory. Excludes node_modules and .git by default.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                path:      { type: "STRING", description: "Directory path (default: current working directory)" },
+                show_hidden: { type: "BOOLEAN", description: "Include hidden files (default false)" }
+            }
+        }
+    },
+    {
+        name: "find_files",
+        description: "Find files matching a name pattern (glob) recursively. Excludes node_modules and .git.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                pattern: { type: "STRING", description: "Name glob e.g. '*.js', 'index.*', 'GEMINI.md'" },
+                dir:     { type: "STRING", description: "Root directory to search (default: .)" }
+            },
+            required: ["pattern"]
+        }
+    },
+    {
+        name: "search_in_files",
+        description: "Search for a text pattern (grep) inside files recursively. Returns matching lines with filenames and line numbers.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                pattern:   { type: "STRING", description: "Text or regex pattern to search" },
+                dir:       { type: "STRING", description: "Directory to search (default: .)" },
+                extension: { type: "STRING", description: "File extension filter e.g. '.js', '.py'" },
+                case_insensitive: { type: "BOOLEAN", description: "Case-insensitive search (default false)" }
+            },
+            required: ["pattern"]
+        }
+    },
+    {
+        name: "run_shell",
+        description: "Execute any shell command. Use for: npm/pip install, git operations, running tests, building, compiling, curl, etc. Returns stdout and stderr.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                command: { type: "STRING", description: "Shell command to execute" },
+                cwd:     { type: "STRING", description: "Working directory (default: current)" },
+                timeout: { type: "NUMBER", description: "Timeout in milliseconds (default 30000)" }
+            },
+            required: ["command"]
+        }
+    },
+    {
+        name: "create_dir",
+        description: "Create a directory (and all parent directories). Equivalent to mkdir -p.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                path: { type: "STRING", description: "Directory path to create" }
+            },
+            required: ["path"]
+        }
+    },
+    {
+        name: "delete_file",
+        description: "Delete a file or empty directory permanently.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                path: { type: "STRING", description: "Path to delete" }
+            },
+            required: ["path"]
+        }
+    },
+    {
+        name: "move_file",
+        description: "Move or rename a file or directory.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                from: { type: "STRING", description: "Source path" },
+                to:   { type: "STRING", description: "Destination path" }
+            },
+            required: ["from", "to"]
+        }
+    },
+    {
+        name: "get_env",
+        description: "Get information about the current environment: working directory, platform, node version, git branch, etc.",
+        parameters: { type: "OBJECT", properties: {} }
+    },
+    {
+        name: "read_url",
+        description: "Fetch the raw content of a URL (web page, REST API, raw file). Returns up to 50KB.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                url:     { type: "STRING", description: "URL to fetch" },
+                headers: { type: "STRING", description: "JSON string of HTTP headers e.g. '{\"Authorization\":\"Bearer token\"}'" }
+            },
+            required: ["url"]
+        }
+    }
+];
+
+// The tools array to pass directly into the Gemini API payload
+export const GEMINI_TOOLS = [{ functionDeclarations: FUNCTION_DECLARATIONS }];
+
+// ─────────────────────────────────────────────────────────────────
+//  CONFIRMATION PROMPT
+// ─────────────────────────────────────────────────────────────────
+const DESTRUCTIVE = new Set(["write_file","patch_file","append_file","run_shell","create_dir","delete_file","move_file"]);
+
+export async function askConfirm(label, autoApprove) {
+    if (autoApprove) return true;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(res => {
+        rl.question(
+            "\n" +
+            chalk.hex("#DCDCAA")("  ⚡ ") + label + "\n" +
+            chalk.hex("#858585")("  Allow? ") + chalk.hex("#4EC9B0")("[y]") + chalk.hex("#858585")("/") + chalk.hex("#F44747")("[n]") + chalk.hex("#858585")(" › "),
+            ans => { rl.close(); res(ans.trim().toLowerCase() !== "n"); }
+        );
+    });
+}
+
+// ─────────────────────────────────────────────────────────────────
+//  TOOL EXECUTOR
+// ─────────────────────────────────────────────────────────────────
+export async function executeTool(name, args = {}, { autoApprove = false } = {}) {
+    if (DESTRUCTIVE.has(name)) {
+        const label = buildConfirmLabel(name, args);
+        const ok = await askConfirm(label, autoApprove);
+        if (!ok) return { error: `Tool "${name}" declined by user.` };
+    }
+
+    try {
+        switch (name) {
+            case "read_file": {
+                const p = path.resolve(args.path);
+                if (!fs.existsSync(p)) return { error: `File not found: ${p}` };
+                const content = fs.readFileSync(p, "utf8");
+                const lines = content.split("\n");
+                const MAX = 400;
+                const numbered = lines
+                    .slice(0, MAX)
+                    .map((l, i) => `${String(i+1).padStart(4)} │ ${l}`)
+                    .join("\n");
+                const suffix = lines.length > MAX ? `\n\n[...${lines.length - MAX} more lines not shown]` : "";
+                return { result: numbered + suffix, lines: lines.length, path: p };
+            }
+
+            case "write_file": {
+                const p = path.resolve(args.path);
+                fs.mkdirSync(path.dirname(p), { recursive: true });
+                fs.writeFileSync(p, args.content, "utf8");
+                const lines = (args.content.match(/\n/g) ?? []).length + 1;
+                return { result: `Written ${lines} lines to ${p}` };
+            }
+
+            case "patch_file": {
+                const p = path.resolve(args.path);
+                if (!fs.existsSync(p)) return { error: `File not found: ${p}` };
+                const src = fs.readFileSync(p, "utf8");
+                if (!src.includes(args.old_str))
+                    return { error: "old_str not found in file. Make sure it matches exactly (whitespace, newlines)." };
+                const count = src.split(args.old_str).length - 1;
+                if (count > 1)
+                    return { error: `old_str appears ${count} times — must be unique. Add more surrounding context.` };
+                fs.writeFileSync(p, src.replace(args.old_str, args.new_str), "utf8");
+                return { result: `Patched ${p} (1 replacement)` };
+            }
+
+            case "append_file": {
+                const p = path.resolve(args.path);
+                fs.mkdirSync(path.dirname(p), { recursive: true });
+                fs.appendFileSync(p, args.content, "utf8");
+                return { result: `Appended to ${p}` };
+            }
+
+            case "list_dir": {
+                const p = path.resolve(args.path || ".");
+                if (!fs.existsSync(p)) return { error: `Not found: ${p}` };
+                const items = fs.readdirSync(p, { withFileTypes: true });
+                const filtered = args.show_hidden ? items : items.filter(i => !i.name.startsWith("."));
+                const SKIP = new Set(["node_modules", ".git"]);
+                const rows = filtered
+                    .filter(i => !SKIP.has(i.name))
+                    .map(i => {
+                        const st   = fs.statSync(path.join(p, i.name));
+                        const size = i.isDirectory() ? "<DIR>" : fmtBytes(st.size);
+                        return `${size.padStart(8)}  ${i.isDirectory() ? chalk.hex("#569CD6")(i.name+"/") : i.name}`;
+                    });
+                return { result: `${p}\n${"─".repeat(50)}\n${rows.join("\n")}\n\n${rows.length} items` };
+            }
+
+            case "find_files": {
+                const dir = path.resolve(args.dir || ".");
+                const { stdout } = await execAsync(
+                    `find "${dir}" -name "${args.pattern}" -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null | head -200`
+                );
+                return { result: stdout.trim() || "No files found." };
+            }
+
+            case "search_in_files": {
+                const dir  = path.resolve(args.dir || ".");
+                const flag = args.case_insensitive ? "-i" : "";
+                const ext  = args.extension ? `--include="*${args.extension}"` : "";
+                const { stdout } = await execAsync(
+                    `grep -rn ${flag} ${ext} "${args.pattern}" "${dir}" --exclude-dir=node_modules --exclude-dir=.git 2>/dev/null | head -100`
+                ).catch(e => ({ stdout: e.stdout || "" }));
+                return { result: stdout.trim() || "No matches found." };
+            }
+
+            case "run_shell": {
+                const cwd     = args.cwd ? path.resolve(args.cwd) : process.cwd();
+                const timeout = args.timeout || 30000;
+                try {
+                    const { stdout, stderr } = await execAsync(args.command, { cwd, timeout, maxBuffer: 5*1024*1024 });
+                    const out = [stdout?.trim(), stderr?.trim() ? `[stderr]\n${stderr.trim()}` : null].filter(Boolean).join("\n");
+                    return { result: out || "(no output)", exitCode: 0 };
+                } catch (err) {
+                    const out = [err.stdout?.trim(), err.stderr?.trim() ? `[stderr]\n${err.stderr.trim()}` : null, `[exit ${err.code}]`].filter(Boolean).join("\n");
+                    return { result: out, exitCode: err.code };
+                }
+            }
+
+            case "create_dir": {
+                const p = path.resolve(args.path);
+                fs.mkdirSync(p, { recursive: true });
+                return { result: `Created: ${p}` };
+            }
+
+            case "delete_file": {
+                const p = path.resolve(args.path);
+                if (!fs.existsSync(p)) return { error: `Not found: ${p}` };
+                fs.statSync(p).isDirectory() ? fs.rmdirSync(p) : fs.unlinkSync(p);
+                return { result: `Deleted: ${p}` };
+            }
+
+            case "move_file": {
+                const from = path.resolve(args.from), to = path.resolve(args.to);
+                fs.mkdirSync(path.dirname(to), { recursive: true });
+                fs.renameSync(from, to);
+                return { result: `Moved: ${from} → ${to}` };
+            }
+
+            case "get_env": {
+                let branch = "";
+                try { branch = (await execAsync("git branch --show-current 2>/dev/null")).stdout.trim(); } catch {}
+                return {
+                    result: JSON.stringify({
+                        cwd:      process.cwd(),
+                        platform: process.platform,
+                        node:     process.version,
+                        git_branch: branch || null,
+                        home:     process.env.HOME,
+                        shell:    process.env.SHELL
+                    }, null, 2)
+                };
+            }
+
+            case "read_url": {
+                let hdrs = "";
+                if (args.headers) {
+                    try {
+                        const obj = JSON.parse(args.headers);
+                        hdrs = Object.entries(obj).map(([k,v]) => `-H "${k}: ${v}"`).join(" ");
+                    } catch {}
+                }
+                const { stdout } = await execAsync(`curl -sL --max-time 15 ${hdrs} "${args.url}" | head -c 51200`);
+                return { result: stdout.trim() || "(empty response)" };
+            }
+
+            default:
+                return { error: `Unknown tool: ${name}` };
+        }
+    } catch (err) {
+        return { error: `${name} failed: ${err.message}` };
+    }
+}
+
+function buildConfirmLabel(name, args) {
+    switch (name) {
+        case "write_file":  return `Write file: ${chalk.yellow(args.path)}`;
+        case "patch_file":  return `Patch file: ${chalk.yellow(args.path)}`;
+        case "append_file": return `Append to:  ${chalk.yellow(args.path)}`;
+        case "run_shell":   return `Run shell:  ${chalk.cyan(args.command)}`;
+        case "create_dir":  return `Create dir: ${chalk.yellow(args.path)}`;
+        case "delete_file": return `${chalk.red("DELETE")}:     ${chalk.yellow(args.path)}`;
+        case "move_file":   return `Move:       ${chalk.yellow(args.from)} → ${chalk.yellow(args.to)}`;
+        default:            return `Execute: ${name}`;
+    }
+}
+
+function fmtBytes(n) {
+    if (n < 1024) return n + "B";
+    if (n < 1048576) return (n/1024).toFixed(1) + "K";
+    return (n/1048576).toFixed(1) + "M";
+}