@ikyyofc/gemini-cli 3.0.7 → 3.0.9

package/README.md

@@ -1,6 +1,6 @@
 # Gemini CLI 🤖
 
-> AI Agent CLI — native function calling · GEMINI.md context · extension system
+> AI Agent CLI — native function calling · Skills · GEMINI.md context · extension system
 
 ```
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -8,19 +8,7 @@
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
-Gemini CLI adalah asisten terminal bertenaga AI yang menggunakan model Gemini dari Google. CLI ini bukan sekadar antarmuka chat biasa, melainkan sebuah **AI Agent** yang dapat berinteraksi langsung dengan sistem file dan environment lokal Anda menggunakan *native function calling*.
-
----
-
-## 📚 Dokumentasi Lengkap
-
-Untuk detail lebih lanjut mengenai arsitektur dan fitur spesifik, silakan baca dokumentasi berikut:
-
-- [**Architecture Overview**](./docs/ARCHITECTURE.md) - Penjelasan tentang ReAct loop dan cara kerja agent.
-- [**API Reference**](./docs/API.md) - Referensi fungsi utama (`callGemini`, `chat`).
-- [**Tools (Function Calling)**](./docs/TOOLS.md) - Daftar lengkap tool yang tersedia untuk agent (baca file, jalankan shell, dll).
-- [**Extensions System**](./docs/EXTENSIONS.md) - Cara membuat dan mengelola ekstensi serta custom commands.
-- [**Memory & Context**](./docs/MEMORY.md) - Panduan menggunakan `GEMINI.md` untuk memberikan konteks pada agent.
+Gemini CLI adalah asisten terminal bertenaga AI yang menggunakan model Gemini dari Google. CLI ini bukan sekadar antarmuka chat biasa, melainkan sebuah **AI Agent** yang dapat berinteraksi langsung dengan sistem file, menjalankan perintah shell, dan menggunakan *skills* pihak ketiga secara mandiri (*native function calling*).
 
 ---
 
@@ -39,23 +27,27 @@ npm link    # optional: pakai sebagai `gemini` di terminal
 Anda dapat menggunakan Gemini CLI dalam mode interaktif (REPL) atau mode *one-shot* langsung dari terminal.
 
 ```bash
-gemini                                    # Masuk ke mode interactive agent
-gemini "buatkan REST API di ./api"        # One-shot task
+gemini                                         # Masuk ke mode interactive agent
+gemini "buatkan REST API di ./api"             # One-shot task
 gemini --system "Kamu senior backend engineer" # Set system prompt
 gemini --file ./app.js "jelaskan kode ini"     # Lampirkan file
 gemini --yolo "refactor semua file di src/"    # Skip semua konfirmasi tool (HATI-HATI)
-gemini --chat                             # Plain chat tanpa tools (bukan agent)
+gemini --chat                                  # Plain chat tanpa tools (bukan agent)
 ```
 
 ### Interactive Commands
 
 Saat berada di dalam mode interaktif, Anda dapat menggunakan perintah berikut:
 
-```
+```text
 /agent                 → Toggle agent mode (tools on/off)
 /yolo                  → Skip all tool confirmations
 /file <path>           → Attach file to next message
 /system <text>         → Set system instruction
+/skill                 → Manage skills (/skill list, add, remove, find, update, init)
+/memory                → Manage memory/context (/memory show, reload, add)
+/ext                   → Manage extensions (/ext list, install, uninstall, enable, disable)
+/proxy                 → Toggle proxy rotation (/proxy on, /proxy off)
 /history               → Show conversation turns
 /export <file>         → Export history to JSON
 /cd <path>             → Change working directory
@@ -71,34 +63,42 @@ Saat berada di dalam mode interaktif, Anda dapat menggunakan perintah berikut:
 ## 🧠 Fitur Utama
 
 ### 1. Native Function Calling (Tools)
-Agent dapat membaca file, menulis file, menjalankan perintah shell, dan mencari file secara mandiri untuk menyelesaikan tugas yang Anda berikan. [Baca selengkapnya](./docs/TOOLS.md).
+Agent dapat membaca file, menulis file, menjalankan perintah shell, dan mencari file secara mandiri untuk menyelesaikan tugas yang Anda berikan.
+
+### 2. Skills System
+Gemini CLI mendukung integrasi *Skills* melalui `npx skills`. Anda dapat menginstal keahlian tambahan yang akan otomatis dimuat ke dalam prompt system agent.
+Contoh: `/skill add anthropics/skills --skill frontend-design`
+
+### 3. Hierarchical Context (`GEMINI.md`)
+Berikan instruksi spesifik proyek atau global menggunakan file `GEMINI.md`. Agent akan memuat konteks ini secara otomatis. Gunakan `/memory` untuk mengatur teks konteks di memori secara dinamis selama sesi berlangsung.
 
-### 2. Hierarchical Context (`GEMINI.md`)
-Anda dapat memberikan instruksi spesifik proyek atau global menggunakan file `GEMINI.md`. Agent akan memuat konteks ini secara otomatis. [Baca selengkapnya](./docs/MEMORY.md).
+### 4. Extension System
+Perluas kemampuan CLI dengan membuat ekstensi yang berisi custom commands dan konteks tambahan. Kelola menggunakan perintah `/ext`.
 
-### 3. Extension System
-Perluas kemampuan CLI dengan membuat ekstensi yang berisi custom commands dan konteks tambahan. [Baca selengkapnya](./docs/EXTENSIONS.md).
+### 5. Proxy Rotation
+Sistem menggunakan proxy rotasi secara otomatis (`src/utils/proxy.js`) sehingga requests Anda stabil. Status dapat diatur menggunakan perintah `/proxy`.
 
 ---
 
 ## 📂 Struktur Direktori
 
-```
+```text
 gemini-cli/
 ├── index.js                   ← CLI entry + REPL + commands
 ├── package.json
-├── docs/                      ← Dokumentasi lengkap
 ├── src/
 │   ├── gemini.js              ← API client (native function calling)
 │   ├── tools.js               ← functionDeclarations + executor
 │   ├── agent.js               ← ReAct loop
 │   ├── memory.js              ← GEMINI.md hierarchy loader
 │   ├── extensions.js          ← Extension manager
+│   ├── skills.js              ← Skills manager via npx skills
 │   ├── renderer.js            ← Terminal UI + markdown
-│   └── input.js               ← Bracketed paste via Transform stream
-└── utils/
-    └── proxy-manager.js       ← Global proxy manager
-
+│   ├── input.js               ← Bracketed paste via Transform stream
+│   └── utils/
+│       ├── proxy.js           ← Global proxy manager
+│       └── spinner.js         ← Loading spinner
+│
 ~/.gemini/                     ← Global config dir (dibuat otomatis)
 ├── GEMINI.md                  ← Global context
 ├── extensions/                ← Folder instalasi ekstensi

package/index.js

@@ -27,7 +27,7 @@ import { Spinner } from "./src/utils/spinner.js";
 import {
     listInstalledSkills, installSkill, removeSkillNpx,
     findSkills, listNpxSkills, updateSkill, initSkill,
-    ensureSkillsDirs, loadSkills,
+    ensureSkillsDirs, loadSkills, cleanLockFile,
 } from "./src/skills.js";
 
 // ─────────────────────────────────────────────────────────────────
@@ -35,6 +35,7 @@ import {
 // ─────────────────────────────────────────────────────────────────
 ensureGlobalDir();
 ensureSkillsDirs();
+cleanLockFile();     // remove skills-lock.json from cwd on every startup
 setupGlobalProxy();   // aktifkan rotasi proxy sebelum request apapun
 
 let extensions    = loadExtensions();
@@ -133,10 +134,23 @@ function attachFile(fp) {
 //  Send message
 // ─────────────────────────────────────────────────────────────────
 async function send(rawLine) {
-    // Decode \x00 → \n from paste encoding
     const userText = restorePaste(rawLine).trim();
     if (!userText) return;
 
+    // Clear terminal when there's previous history so it stays light.
+    // Keep last exchange visible by reprinting it first.
+    if (history.length >= 2) {
+        process.stdout.write("\x1Bc");
+        // Reprint the last assistant response as context
+        const lastAssistant = history.filter(m => m.role === "assistant").at(-1);
+        if (lastAssistant) {
+            process.stdout.write(chalk.hex("#4A4A5E").dim(
+                `  (${Math.ceil(history.length / 2)} turns in memory)\n`
+            ));
+            printAssistant(lastAssistant.content);
+        }
+    }
+
     printUser(userText + (pendingFile ? chalk.dim(` [${path.basename(pendingPath)}]`) : ""));
 
     if (agentMode) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikyyofc/gemini-cli",
-  "version": "3.0.7",
+  "version": "3.0.9",
   "description": "AI Agent CLI — native function calling · GEMINI.md context · extensions",
   "type": "module",
   "bin": { "gemini": "./index.js" },

package/src/skills.js

@@ -25,6 +25,14 @@ export function ensureSkillsDirs() {
     fs.mkdirSync(AGENTS_DIR, { recursive: true });
 }
 
+// ─────────────────────────────────────────────────────────────────
+//  Delete skills-lock.json from cwd (npx skills drops this on install)
+// ─────────────────────────────────────────────────────────────────
+export function cleanLockFile(cwd = process.cwd()) {
+    const p = path.join(cwd, "skills-lock.json");
+    try { if (fs.existsSync(p)) fs.unlinkSync(p); } catch {}
+}
+
 // ─────────────────────────────────────────────────────────────────
 //  Scan a dir tree for SKILL.md files
 // ─────────────────────────────────────────────────────────────────
@@ -127,6 +135,9 @@ export async function installSkill(rawSource, opts = {}) {
 
     const { stdout, stderr } = await npxSkills(parts.join(" "));
 
+    // Cleanup skills-lock.json that npx skills drops in cwd
+    cleanLockFile();
+
     // Report what was newly installed
     const after   = loadSkills().map(s => s.slug);
     const newSlugs = after.filter(s => !before.has(s));

package/src/tools.js

@@ -161,6 +161,202 @@ export const FUNCTION_DECLARATIONS = [
             },
             required: ["url"]
         }
+    },
+    // ── NEW TOOLS ────────────────────────────────────────────────
+    {
+        name: "copy_file",
+        description: "Copy a file or directory to a new location.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                from:      { type: "STRING", description: "Source path" },
+                to:        { type: "STRING", description: "Destination path" },
+                recursive: { type: "BOOLEAN", description: "Copy directory recursively (default true)" }
+            },
+            required: ["from", "to"]
+        }
+    },
+    {
+        name: "read_file_lines",
+        description: "Read a specific range of lines from a file. Use for large files.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                path:  { type: "STRING", description: "File path" },
+                start: { type: "NUMBER", description: "Start line number (1-based)" },
+                end:   { type: "NUMBER", description: "End line number (inclusive)" }
+            },
+            required: ["path", "start", "end"]
+        }
+    },
+    {
+        name: "tree",
+        description: "Show directory structure as a tree. Good for understanding project layout.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                path:        { type: "STRING", description: "Root directory (default: .)" },
+                depth:       { type: "NUMBER", description: "Max depth (default: 3)" },
+                show_hidden: { type: "BOOLEAN", description: "Include hidden files" }
+            }
+        }
+    },
+    {
+        name: "file_info",
+        description: "Get file or directory metadata: size, permissions, modified date, type.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                path: { type: "STRING", description: "File or directory path" }
+            },
+            required: ["path"]
+        }
+    },
+    {
+        name: "diff_files",
+        description: "Show line-by-line differences between two files.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                file_a: { type: "STRING", description: "First file path" },
+                file_b: { type: "STRING", description: "Second file path" }
+            },
+            required: ["file_a", "file_b"]
+        }
+    },
+    {
+        name: "http_request",
+        description: "Make an HTTP request (GET/POST/PUT/PATCH/DELETE) with headers and body.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                url:     { type: "STRING", description: "URL to request" },
+                method:  { type: "STRING", description: "HTTP method (default: GET)" },
+                headers: { type: "STRING", description: "JSON string of request headers" },
+                body:    { type: "STRING", description: "Request body for POST/PUT/PATCH" }
+            },
+            required: ["url"]
+        }
+    },
+    {
+        name: "download_file",
+        description: "Download a file from a URL and save it to disk.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                url:  { type: "STRING", description: "URL to download" },
+                dest: { type: "STRING", description: "Destination file path" }
+            },
+            required: ["url", "dest"]
+        }
+    },
+    {
+        name: "hash_file",
+        description: "Calculate hash of a file (md5, sha1, sha256).",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                path:      { type: "STRING", description: "File path" },
+                algorithm: { type: "STRING", description: "md5 | sha1 | sha256 (default: sha256)" }
+            },
+            required: ["path"]
+        }
+    },
+    {
+        name: "base64",
+        description: "Encode or decode base64. Works on strings or files.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                action:  { type: "STRING", description: "encode or decode" },
+                input:   { type: "STRING", description: "String to process, or file path if is_file=true" },
+                is_file: { type: "BOOLEAN", description: "If true, input is treated as a file path" }
+            },
+            required: ["action", "input"]
+        }
+    },
+    {
+        name: "json_query",
+        description: "Parse and query JSON using a dot-notation key path. e.g. 'user.name', 'items[0].id'.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                input:   { type: "STRING", description: "JSON file path or raw JSON string" },
+                query:   { type: "STRING", description: "Key path e.g. 'user.name' (empty = pretty-print all)" },
+                is_file: { type: "BOOLEAN", description: "If true, input is a file path" }
+            },
+            required: ["input"]
+        }
+    },
+    {
+        name: "extract",
+        description: "Extract a zip, tar, tar.gz, or tar.bz2 archive.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                archive: { type: "STRING", description: "Path to the archive file" },
+                dest:    { type: "STRING", description: "Destination directory (default: same as archive)" }
+            },
+            required: ["archive"]
+        }
+    },
+    {
+        name: "compress",
+        description: "Compress files or a directory into a zip or tar.gz archive.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                source: { type: "STRING", description: "File or directory to compress" },
+                dest:   { type: "STRING", description: "Output archive path (.zip or .tar.gz)" }
+            },
+            required: ["source", "dest"]
+        }
+    },
+    {
+        name: "git",
+        description: "Run git operations: status, log, diff, add, commit, push, pull, clone, checkout, branch, init, stash.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                action: { type: "STRING", description: "status | log | diff | add | commit | push | pull | clone | checkout | branch | init | stash" },
+                args:   { type: "STRING", description: "Additional arguments (commit message, branch name, remote, etc.)" },
+                cwd:    { type: "STRING", description: "Working directory (default: current)" }
+            },
+            required: ["action"]
+        }
+    },
+    {
+        name: "process_list",
+        description: "List running processes. Filter by name optionally.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                filter: { type: "STRING", description: "Filter by process name (optional)" }
+            }
+        }
+    },
+    {
+        name: "disk_usage",
+        description: "Check disk usage of a path (du) or total disk space (df). Use path='/' for overall.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                path: { type: "STRING", description: "Path to check (default: current dir)" }
+            }
+        }
+    },
+    {
+        name: "chmod",
+        description: "Change file permissions. e.g. '755', '+x', 'a+r'.",
+        parameters: {
+            type: "OBJECT",
+            properties: {
+                path:        { type: "STRING", description: "File or directory path" },
+                permissions: { type: "STRING", description: "Permission string: '755', '+x', 'a+r', etc." },
+                recursive:   { type: "BOOLEAN", description: "Apply recursively" }
+            },
+            required: ["path", "permissions"]
+        }
     }
 ];
 
@@ -333,6 +529,232 @@ export async function executeTool(name, args = {}, { autoApprove = false } = {})
                 return { result: stdout.trim() || "(empty response)" };
             }
 
+            // ── NEW TOOLS ──────────────────────────────────────────────
+            case "copy_file": {
+                const from = path.resolve(args.from);
+                const to   = path.resolve(args.to);
+                if (!fs.existsSync(from)) return { error: `Not found: ${from}` };
+                fs.mkdirSync(path.dirname(to), { recursive: true });
+                const rec = args.recursive !== false;
+                const flag = rec ? "-r" : "";
+                await execAsync(`cp ${flag} "${from}" "${to}"`);
+                return { result: `Copied: ${from} → ${to}` };
+            }
+
+            case "read_file_lines": {
+                const p = path.resolve(args.path);
+                if (!fs.existsSync(p)) return { error: `File not found: ${p}` };
+                const lines = fs.readFileSync(p, "utf8").split("\n");
+                const start = Math.max(1, args.start) - 1;
+                const end   = Math.min(lines.length, args.end);
+                const slice = lines.slice(start, end);
+                const numbered = slice.map((l, i) =>
+                    `${String(start + i + 1).padStart(4)} │ ${l}`
+                ).join("\n");
+                return { result: numbered, total_lines: lines.length };
+            }
+
+            case "tree": {
+                const p     = path.resolve(args.path || ".");
+                const depth = args.depth ?? 3;
+                const showH = args.show_hidden ?? false;
+                const SKIP  = new Set(["node_modules", ".git", "dist", "build"]);
+                const lines = [];
+
+                const walk = (dir, prefix, d) => {
+                    if (d > depth) return;
+                    const entries = fs.readdirSync(dir, { withFileTypes: true })
+                        .filter(e => showH || !e.name.startsWith("."))
+                        .filter(e => !SKIP.has(e.name));
+                    entries.forEach((e, i) => {
+                        const last   = i === entries.length - 1;
+                        const branch = last ? "└── " : "├── ";
+                        const child  = last ? "    " : "│   ";
+                        lines.push(prefix + branch + (e.isDirectory() ? e.name + "/" : e.name));
+                        if (e.isDirectory()) walk(path.join(dir, e.name), prefix + child, d + 1);
+                    });
+                };
+
+                lines.push(p);
+                walk(p, "", 0);
+                return { result: lines.join("\n") };
+            }
+
+            case "file_info": {
+                const p = path.resolve(args.path);
+                if (!fs.existsSync(p)) return { error: `Not found: ${p}` };
+                const st = fs.statSync(p);
+                return {
+                    result: JSON.stringify({
+                        path:     p,
+                        type:     st.isDirectory() ? "directory" : "file",
+                        size:     fmtBytes(st.size),
+                        bytes:    st.size,
+                        mode:     "0" + (st.mode & 0o777).toString(8),
+                        modified: st.mtime.toISOString(),
+                        created:  st.birthtime.toISOString(),
+                    }, null, 2)
+                };
+            }
+
+            case "diff_files": {
+                const a = path.resolve(args.file_a);
+                const b = path.resolve(args.file_b);
+                const { stdout } = await execAsync(`diff -u "${a}" "${b}"`).catch(e => ({ stdout: e.stdout || "" }));
+                return { result: stdout || "Files are identical." };
+            }
+
+            case "http_request": {
+                const method  = (args.method ?? "GET").toUpperCase();
+                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 bodyFlag = args.body ? `-d '${args.body.replace(/'/g, "'\\''")}'` : "";
+                const cmd = `curl -s -X ${method} ${hdrs} ${bodyFlag} --max-time 20 "${args.url}" | head -c 102400`;
+                const { stdout } = await execAsync(cmd);
+                return { result: stdout.trim() || "(empty response)" };
+            }
+
+            case "download_file": {
+                const dest = path.resolve(args.dest);
+                fs.mkdirSync(path.dirname(dest), { recursive: true });
+                await execAsync(`curl -L --max-time 60 -o "${dest}" "${args.url}"`);
+                const size = fmtBytes(fs.statSync(dest).size);
+                return { result: `Downloaded to ${dest} (${size})` };
+            }
+
+            case "hash_file": {
+                const p   = path.resolve(args.path);
+                if (!fs.existsSync(p)) return { error: `Not found: ${p}` };
+                const alg = args.algorithm ?? "sha256";
+                const cmd = alg === "md5"
+                    ? `md5sum "${p}" 2>/dev/null || md5 -q "${p}"`
+                    : `sha${alg === "sha256" ? "256" : alg === "sha1" ? "1" : "256"}sum "${p}" 2>/dev/null || shasum -a ${alg === "sha1" ? "1" : "256"} "${p}"`;
+                const { stdout } = await execAsync(cmd);
+                return { result: stdout.trim().split(" ")[0], algorithm: alg, path: p };
+            }
+
+            case "base64": {
+                const action = args.action.toLowerCase();
+                let input = args.input;
+                if (args.is_file) {
+                    const p = path.resolve(input);
+                    if (!fs.existsSync(p)) return { error: `File not found: ${p}` };
+                    input = fs.readFileSync(p, "utf8");
+                }
+                if (action === "encode") {
+                    return { result: Buffer.from(input).toString("base64") };
+                } else {
+                    return { result: Buffer.from(input, "base64").toString("utf8") };
+                }
+            }
+
+            case "json_query": {
+                let data;
+                if (args.is_file) {
+                    const p = path.resolve(args.input);
+                    if (!fs.existsSync(p)) return { error: `File not found: ${p}` };
+                    data = JSON.parse(fs.readFileSync(p, "utf8"));
+                } else {
+                    data = JSON.parse(args.input);
+                }
+                if (!args.query) return { result: JSON.stringify(data, null, 2) };
+                // Simple dot+bracket notation traversal
+                const keys = args.query.replace(/\[(\d+)\]/g, ".$1").split(".");
+                let val = data;
+                for (const k of keys) {
+                    if (val == null) return { error: `Key "${k}" not found` };
+                    val = val[k];
+                }
+                return { result: typeof val === "object" ? JSON.stringify(val, null, 2) : String(val) };
+            }
+
+            case "extract": {
+                const archive = path.resolve(args.archive);
+                if (!fs.existsSync(archive)) return { error: `Archive not found: ${archive}` };
+                const dest = path.resolve(args.dest ?? path.dirname(archive));
+                fs.mkdirSync(dest, { recursive: true });
+                const ext = archive.toLowerCase();
+                let cmd;
+                if      (ext.endsWith(".zip"))              cmd = `unzip -o "${archive}" -d "${dest}"`;
+                else if (ext.endsWith(".tar.gz") || ext.endsWith(".tgz"))  cmd = `tar -xzf "${archive}" -C "${dest}"`;
+                else if (ext.endsWith(".tar.bz2"))          cmd = `tar -xjf "${archive}" -C "${dest}"`;
+                else if (ext.endsWith(".tar"))              cmd = `tar -xf "${archive}" -C "${dest}"`;
+                else if (ext.endsWith(".gz"))               cmd = `gunzip -k "${archive}"`;
+                else return { error: `Unsupported archive format: ${archive}` };
+                const { stdout, stderr } = await execAsync(cmd);
+                return { result: `Extracted to ${dest}` };
+            }
+
+            case "compress": {
+                const source = path.resolve(args.source);
+                const dest   = path.resolve(args.dest);
+                if (!fs.existsSync(source)) return { error: `Not found: ${source}` };
+                fs.mkdirSync(path.dirname(dest), { recursive: true });
+                let cmd;
+                if      (dest.endsWith(".zip"))    cmd = `zip -r "${dest}" "${source}"`;
+                else if (dest.endsWith(".tar.gz") || dest.endsWith(".tgz")) cmd = `tar -czf "${dest}" "${source}"`;
+                else if (dest.endsWith(".tar"))    cmd = `tar -cf "${dest}" "${source}"`;
+                else return { error: "Unsupported format. Use .zip or .tar.gz" };
+                await execAsync(cmd);
+                const size = fmtBytes(fs.statSync(dest).size);
+                return { result: `Compressed to ${dest} (${size})` };
+            }
+
+            case "git": {
+                const cwd = args.cwd ? path.resolve(args.cwd) : process.cwd();
+                const a   = args.action.toLowerCase();
+                const extra = args.args ?? "";
+                const gitCmds = {
+                    status:   `git status`,
+                    log:      `git log --oneline -20 ${extra}`,
+                    diff:     `git diff ${extra}`,
+                    add:      `git add ${extra || "."}`,
+                    commit:   `git commit -m "${extra}"`,
+                    push:     `git push ${extra}`,
+                    pull:     `git pull ${extra}`,
+                    clone:    `git clone ${extra}`,
+                    checkout: `git checkout ${extra}`,
+                    branch:   `git branch ${extra}`,
+                    init:     `git init ${extra}`,
+                    stash:    `git stash ${extra}`,
+                };
+                const cmd = gitCmds[a];
+                if (!cmd) return { error: `Unknown git action: ${a}` };
+                const { stdout, stderr } = await execAsync(cmd, { cwd }).catch(e => ({
+                    stdout: e.stdout || "", stderr: e.stderr || ""
+                }));
+                return { result: (stdout + (stderr ? "\n" + stderr : "")).trim() || "(no output)" };
+            }
+
+            case "process_list": {
+                const filter = args.filter ?? "";
+                const cmd    = filter
+                    ? `ps aux | grep -i "${filter}" | grep -v grep`
+                    : `ps aux | head -30`;
+                const { stdout } = await execAsync(cmd).catch(e => ({ stdout: e.stdout || "" }));
+                return { result: stdout.trim() || "No processes found." };
+            }
+
+            case "disk_usage": {
+                const p = args.path ? path.resolve(args.path) : process.cwd();
+                const { stdout: du } = await execAsync(`du -sh "${p}" 2>/dev/null`).catch(() => ({ stdout: "" }));
+                const { stdout: df } = await execAsync(`df -h "${p}" 2>/dev/null`).catch(() => ({ stdout: "" }));
+                return { result: [du.trim(), df.trim()].filter(Boolean).join("\n\n") || "(unavailable)" };
+            }
+
+            case "chmod": {
+                const p   = path.resolve(args.path);
+                if (!fs.existsSync(p)) return { error: `Not found: ${p}` };
+                const rec = args.recursive ? "-R" : "";
+                await execAsync(`chmod ${rec} ${args.permissions} "${p}"`);
+                return { result: `chmod ${args.permissions} applied to ${p}` };
+            }
+
             default:
                 return { error: `Unknown tool: ${name}` };
         }