daemora 1.0.1 → 1.0.3

package/src/tools/cronTool.js

@@ -1,16 +1,16 @@
 /**
- * cron(action, paramsJson?) — Schedule recurring tasks from within the agent.
+ * cron(action, paramsJson?) - Schedule recurring tasks from within the agent.
  * Bridge to the existing Scheduler. Inspired by OpenClaw's cron tool.
  *
  * Actions:
- *   status  — show scheduler status
- *   list    — list all schedules
- *   add     — create a new schedule
- *   update  — patch an existing schedule (change expression, name, or taskInput)
- *   enable  — re-enable a disabled schedule
- *   disable — pause a schedule without deleting it
- *   remove  — delete a schedule permanently
- *   run     — trigger a schedule immediately (regardless of cron timing)
+ *   status  - show scheduler status
+ *   list    - list all schedules
+ *   add     - create a new schedule
+ *   update  - patch an existing schedule (change expression, name, or taskInput)
+ *   enable  - re-enable a disabled schedule
+ *   disable - pause a schedule without deleting it
+ *   remove  - delete a schedule permanently
+ *   run     - trigger a schedule immediately (regardless of cron timing)
  */
 import scheduler from "../scheduler/Scheduler.js";
 
@@ -35,14 +35,14 @@ export function cron(action, paramsJson) {
         return schedules
           .map(
             (s) =>
-              `• ${s.id.slice(0, 8)} — "${s.name}" | ${s.cronExpression} | ${s.enabled ? "enabled" : "DISABLED"} | runs: ${s.runCount} | last: ${s.lastRun || "never"}`
+              `• ${s.id.slice(0, 8)} - "${s.name}" | ${s.cronExpression} | ${s.enabled ? "enabled" : "DISABLED"} | runs: ${s.runCount} | last: ${s.lastRun || "never"}`
           )
           .join("\n");
       }
 
       case "add": {
         if (!params.cronExpression) return 'Error: cronExpression is required. Example: "0 9 * * *" for daily at 9am.';
-        if (!params.taskInput) return "Error: taskInput is required — the task/message to send when triggered.";
+        if (!params.taskInput) return "Error: taskInput is required - the task/message to send when triggered.";
         const schedule = scheduler.create({
           cronExpression: params.cronExpression,
           taskInput: params.taskInput,
@@ -67,13 +67,13 @@ export function cron(action, paramsJson) {
       case "enable": {
         if (!params.id) return 'Error: id is required.';
         const schedule = scheduler.update(params.id, { enabled: true });
-        return `Schedule "${schedule.name}" (${params.id.slice(0, 8)}) enabled — will run on next trigger.`;
+        return `Schedule "${schedule.name}" (${params.id.slice(0, 8)}) enabled - will run on next trigger.`;
       }
 
       case "disable": {
         if (!params.id) return 'Error: id is required.';
         const schedule = scheduler.update(params.id, { enabled: false });
-        return `Schedule "${schedule.name}" (${params.id.slice(0, 8)}) disabled — cron job paused, not deleted.`;
+        return `Schedule "${schedule.name}" (${params.id.slice(0, 8)}) disabled - cron job paused, not deleted.`;
       }
 
       case "remove": {
@@ -97,7 +97,7 @@ export function cron(action, paramsJson) {
 }
 
 export const cronDescription =
-  'cron(action, paramsJson?) — Manage scheduled recurring tasks. ' +
+  'cron(action, paramsJson?) - Manage scheduled recurring tasks. ' +
   'Actions: "status", "list", ' +
   '"add" ({"cronExpression":"0 9 * * *","taskInput":"Check emails","name":"Morning"}), ' +
   '"update" ({"id":"...","cronExpression":"0 10 * * *"}), ' +

package/src/tools/database.js

@@ -0,0 +1,165 @@
+/**
+ * database - Query databases: SQLite (built-in), PostgreSQL, MySQL.
+ * SQLite: uses better-sqlite3 or falls back to built-in node:sqlite (Node 22+).
+ * PostgreSQL/MySQL: requires pg / mysql2 package.
+ * Security: uses parameterized queries for all user-supplied values.
+ */
+
+export async function database(action, paramsJson) {
+  if (!action) return "Error: action required. Valid: query, execute, schema, list";
+  const params = paramsJson
+    ? (typeof paramsJson === "string" ? JSON.parse(paramsJson) : paramsJson)
+    : {};
+
+  const { type = "sqlite", dbPath, connectionString, query, values = [], table } = params;
+
+  // ── SQLite ──────────────────────────────────────────────────────────────
+  if (type === "sqlite") {
+    if (!dbPath) return "Error: dbPath is required for SQLite";
+
+    let db;
+    try {
+      // Try better-sqlite3 first (synchronous, easiest)
+      const { default: Database } = await import("better-sqlite3");
+      db = new Database(dbPath, { readonly: action === "query" || action === "schema" || action === "list" });
+    } catch {
+      // Fall back to node:sqlite (Node 22+)
+      try {
+        const { DatabaseSync } = await import("node:sqlite");
+        db = new DatabaseSync(dbPath, { open: true });
+      } catch {
+        return "Error: SQLite driver not found. Run: npm install better-sqlite3 (or use Node 22+ for built-in sqlite)";
+      }
+    }
+
+    try {
+      if (action === "query" || action === "execute") {
+        if (!query) return "Error: query is required";
+        // Detect if it's a select (returns rows) or write (returns changes)
+        const isSelect = /^\s*select\b/i.test(query);
+        if (isSelect || action === "query") {
+          const stmt = db.prepare(query);
+          const rows = stmt.all(...values);
+          if (!rows.length) return "Query returned 0 rows";
+          return JSON.stringify(rows, null, 2);
+        } else {
+          const stmt = db.prepare(query);
+          const info = stmt.run(...values);
+          return `OK: ${info.changes} row(s) affected, lastInsertRowid=${info.lastInsertRowid}`;
+        }
+      }
+
+      if (action === "schema") {
+        const tables = db.prepare("SELECT name, sql FROM sqlite_master WHERE type='table' ORDER BY name").all();
+        if (!tables.length) return "No tables found in database";
+        return tables.map(t => `-- ${t.name}\n${t.sql}`).join("\n\n");
+      }
+
+      if (action === "list") {
+        const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name").all();
+        return tables.length ? tables.map(t => t.name).join("\n") : "No tables found";
+      }
+    } catch (err) {
+      return `SQLite error: ${err.message}`;
+    } finally {
+      if (db?.close) db.close();
+    }
+  }
+
+  // ── PostgreSQL ──────────────────────────────────────────────────────────
+  if (type === "postgres" || type === "postgresql") {
+    const connStr = connectionString || process.env.DATABASE_URL || process.env.POSTGRES_URL;
+    if (!connStr) return "Error: connectionString or DATABASE_URL env var required for PostgreSQL";
+
+    let client;
+    try {
+      const { Client } = await import("pg");
+      client = new Client({ connectionString: connStr });
+      await client.connect();
+
+      if (action === "query" || action === "execute") {
+        if (!query) return "Error: query is required";
+        const result = await client.query(query, values);
+        if (result.rows.length === 0) return `OK: ${result.rowCount} row(s) affected`;
+        return JSON.stringify(result.rows, null, 2);
+      }
+
+      if (action === "schema") {
+        const tbl = table || "%";
+        const result = await client.query(
+          "SELECT table_name, column_name, data_type, is_nullable FROM information_schema.columns WHERE table_schema='public' AND table_name LIKE $1 ORDER BY table_name, ordinal_position",
+          [tbl]
+        );
+        if (!result.rows.length) return "No columns found";
+        const grouped = {};
+        for (const row of result.rows) {
+          if (!grouped[row.table_name]) grouped[row.table_name] = [];
+          grouped[row.table_name].push(`  ${row.column_name} ${row.data_type}${row.is_nullable === "NO" ? " NOT NULL" : ""}`);
+        }
+        return Object.entries(grouped).map(([t, cols]) => `-- ${t}\n${cols.join("\n")}`).join("\n\n");
+      }
+
+      if (action === "list") {
+        const result = await client.query(
+          "SELECT table_name FROM information_schema.tables WHERE table_schema='public' ORDER BY table_name"
+        );
+        return result.rows.map(r => r.table_name).join("\n") || "No tables found";
+      }
+    } catch (err) {
+      return `PostgreSQL error: ${err.message}`;
+    } finally {
+      if (client) await client.end().catch(() => {});
+    }
+  }
+
+  // ── MySQL ───────────────────────────────────────────────────────────────
+  if (type === "mysql") {
+    const connStr = connectionString || process.env.MYSQL_URL;
+    if (!connStr) return "Error: connectionString or MYSQL_URL env var required for MySQL";
+
+    let conn;
+    try {
+      const mysql = await import("mysql2/promise");
+      conn = await mysql.createConnection(connStr);
+
+      if (action === "query" || action === "execute") {
+        if (!query) return "Error: query is required";
+        const [rows] = await conn.execute(query, values);
+        if (!Array.isArray(rows)) return `OK: ${rows.affectedRows} row(s) affected`;
+        if (!rows.length) return "Query returned 0 rows";
+        return JSON.stringify(rows, null, 2);
+      }
+
+      if (action === "schema") {
+        const [rows] = await conn.execute("SHOW TABLES");
+        return rows.map(r => Object.values(r)[0]).join("\n") || "No tables found";
+      }
+
+      if (action === "list") {
+        const [rows] = await conn.execute("SHOW TABLES");
+        return rows.map(r => Object.values(r)[0]).join("\n") || "No tables found";
+      }
+    } catch (err) {
+      return `MySQL error: ${err.message}`;
+    } finally {
+      if (conn) await conn.end().catch(() => {});
+    }
+  }
+
+  return `Unknown database type: "${type}". Valid: sqlite, postgres, mysql`;
+}
+
+export const databaseDescription =
+  `database(action: string, paramsJson?: object) - Query SQLite, PostgreSQL, or MySQL databases.
+  action: "query" | "execute" | "schema" | "list"
+  params.type: "sqlite" (default) | "postgres" | "mysql"
+  sqlite: { dbPath: "/path/to/db.sqlite", query, values? }
+  postgres: { connectionString?, query, values? } (or DATABASE_URL env)
+  mysql: { connectionString?, query, values? } (or MYSQL_URL env)
+  Env vars: DATABASE_URL, POSTGRES_URL, MYSQL_URL
+  Note: Uses parameterized queries (values array) to prevent SQL injection.
+  Examples:
+    database("query", {"dbPath":"./app.db","query":"SELECT * FROM users LIMIT 10"})
+    database("execute", {"type":"postgres","query":"INSERT INTO logs(msg) VALUES($1)","values":["hello"]})
+    database("schema", {"type":"postgres"})
+    database("list", {"dbPath":"./data.db"})`;

package/src/tools/editFile.js

@@ -2,12 +2,12 @@ import { readFileSync, writeFileSync } from "node:fs";
 import filesystemGuard from "../safety/FilesystemGuard.js";
 
 /**
- * Multi-strategy file editing — inspired by Gemini CLI.
+ * Multi-strategy file editing - inspired by Gemini CLI.
  *
  * Strategy chain:
- * 1. EXACT match — direct string replacement
- * 2. FLEXIBLE match — line-by-line, ignoring leading/trailing whitespace
- * 3. If all fail — show helpful error with nearby context
+ * 1. EXACT match - direct string replacement
+ * 2. FLEXIBLE match - line-by-line, ignoring leading/trailing whitespace
+ * 3. If all fail - show helpful error with nearby context
  */
 
 function exactMatch(content, oldString, newString) {
@@ -74,12 +74,12 @@ function findNearbyContext(content, oldString, maxContext = 3) {
 }
 
 export function editFile(filePath, oldString, newString) {
-  // Parameter validation — model sometimes passes wrong number of args
+  // Parameter validation - model sometimes passes wrong number of args
   if (!filePath || typeof filePath !== "string") {
     return "Error: editFile requires filePath as the first parameter.";
   }
   if (!oldString || typeof oldString !== "string") {
-    return "Error: editFile requires oldString as the second parameter — the text to find and replace.";
+    return "Error: editFile requires oldString as the second parameter - the text to find and replace.";
   }
   if (newString === undefined || newString === null || typeof newString !== "string") {
     return "Error: editFile requires 3 parameters: editFile(filePath, oldString, newString). You only passed 2. oldString is the text to FIND in the file, newString is what to REPLACE it with. If you want to append content, use writeFile instead to rewrite the full file, or use editFile with an existing line as oldString and provide the replacement that includes the new content.";
@@ -103,7 +103,7 @@ export function editFile(filePath, oldString, newString) {
     let result = exactMatch(content, oldString, newString);
     if (result) {
       writeFileSync(filePath, result.updated, { encoding: "utf-8" });
-      console.log(`      [editFile] Done — ${result.strategy} match, replaced ${result.occurrences} occurrence(s)`);
+      console.log(`      [editFile] Done - ${result.strategy} match, replaced ${result.occurrences} occurrence(s)`);
       return `File ${filePath} edited successfully (${result.strategy} match). Replaced ${result.occurrences} occurrence(s).`;
     }
 
@@ -111,11 +111,11 @@ export function editFile(filePath, oldString, newString) {
     result = flexibleMatch(content, oldString, newString);
     if (result) {
       writeFileSync(filePath, result.updated, { encoding: "utf-8" });
-      console.log(`      [editFile] Done — ${result.strategy} match`);
+      console.log(`      [editFile] Done - ${result.strategy} match`);
       return `File ${filePath} edited successfully (${result.strategy} match). Replaced ${result.occurrences} occurrence(s).`;
     }
 
-    // All strategies failed — provide helpful error
+    // All strategies failed - provide helpful error
     const nearby = findNearbyContext(content, oldString);
     let errorMsg = `Error: Could not find the string to replace in ${filePath}.\n`;
     errorMsg += `Make sure oldString matches the file content (including whitespace/indentation).\n`;
@@ -127,7 +127,7 @@ export function editFile(filePath, oldString, newString) {
       }
     }
 
-    console.log(`      [editFile] Failed — no match found`);
+    console.log(`      [editFile] Failed - no match found`);
     return errorMsg;
   } catch (error) {
     console.log(`      [editFile] Failed: ${error.message}`);

package/src/tools/executeCommand.js

@@ -1,5 +1,5 @@
 /**
- * executeCommand(cmd, optionsJson?) — Execute a shell command with advanced options.
+ * executeCommand(cmd, optionsJson?) - Execute a shell command with advanced options.
  * Upgraded from 23-line basic version to support: cwd, timeout, env, background mode, stderr.
  *
  * Filesystem scoping:
@@ -12,6 +12,7 @@ import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { config } from "../config/default.js";
 import filesystemGuard from "../safety/FilesystemGuard.js";
+import { checkCommand } from "../safety/CommandGuard.js";
 
 const DEFAULT_TIMEOUT_MS = 120_000;   // 2 minutes default
 const MAX_TIMEOUT_MS = 600_000;       // 10 minutes hard max
@@ -36,6 +37,13 @@ export function executeCommand(cmd, optionsJson) {
     cwd = resolved;
   }
 
+  // ── Command security guard (always runs, regardless of filesystem config) ──
+  const cmdCheck = checkCommand(cmd);
+  if (!cmdCheck.allowed) {
+    return `Command blocked by security policy: ${cmdCheck.reason}`;
+  }
+  // ──────────────────────────────────────────────────────────────────────────
+
   // ── Filesystem scope enforcement ───────────────────────────────────────────
   const allowedPaths = config.filesystem?.allowedPaths || [];
   if (allowedPaths.length > 0) {
@@ -72,7 +80,7 @@ export function executeCommand(cmd, optionsJson) {
 
   console.log(`      [executeCommand] Running: ${cmd}${cwdRaw ? ` (cwd: ${cwdRaw})` : ""}${background ? " [background]" : ""}`);
 
-  // Background mode — spawn detached, return PID immediately
+  // Background mode - spawn detached, return PID immediately
   if (background) {
     try {
       const child = spawn("sh", ["-c", cmd], {
@@ -88,7 +96,7 @@ export function executeCommand(cmd, optionsJson) {
     }
   }
 
-  // Foreground mode — wait for result
+  // Foreground mode - wait for result
   try {
     const result = execSync(cmd, {
       encoding: "utf-8",

package/src/tools/generateImage.js

@@ -0,0 +1,79 @@
+/**
+ * generateImage - Generate images using OpenAI DALL-E 3 or DALL-E 2.
+ * Saves the image to /tmp and returns the file path for the agent to use.
+ */
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import tenantContext from "../tenants/TenantContext.js";
+
+export async function generateImage(prompt, optionsJson) {
+  if (!prompt) return "Error: prompt is required.";
+
+  let opts = {};
+  if (optionsJson) { try { opts = JSON.parse(optionsJson); } catch { return "Error: optionsJson must be valid JSON."; } }
+
+  const {
+    model = "dall-e-3",
+    size = "1024x1024",
+    quality = "standard",
+    style = "vivid",
+    n = 1,
+    outputPath = null,
+  } = opts;
+
+  const store = tenantContext.getStore();
+  const apiKeys = store?.apiKeys || {};
+  const apiKey = apiKeys.OPENAI_API_KEY || process.env.OPENAI_API_KEY;
+
+  if (!apiKey) return "Error: OPENAI_API_KEY not configured.";
+
+  const body = { model, prompt, n: Math.min(n, model === "dall-e-3" ? 1 : 10), size, response_format: "b64_json" };
+  if (model === "dall-e-3") {
+    body.quality = quality;
+    body.style = style;
+  }
+
+  try {
+    const res = await fetch("https://api.openai.com/v1/images/generations", {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
+      body: JSON.stringify(body),
+    });
+
+    const data = await res.json();
+    if (!res.ok) return `Error: ${data.error?.message || res.status}`;
+
+    const images = data.data || [];
+    if (images.length === 0) return "Error: No images returned.";
+
+    const saved = [];
+    const dir = join(tmpdir(), "daemora-images");
+    mkdirSync(dir, { recursive: true });
+
+    for (let i = 0; i < images.length; i++) {
+      const b64 = images[i].b64_json;
+      const revised = images[i].revised_prompt || prompt;
+      const filePath = outputPath || join(dir, `image-${Date.now()}-${i}.png`);
+      writeFileSync(filePath, Buffer.from(b64, "base64"));
+      saved.push({ path: filePath, revisedPrompt: revised });
+    }
+
+    const lines = saved.map(s =>
+      `Saved: ${s.path}${s.revisedPrompt !== prompt ? `\nRevised prompt: ${s.revisedPrompt}` : ""}`
+    );
+    return `Generated ${saved.length} image(s):\n${lines.join("\n")}`;
+  } catch (err) {
+    return `Error generating image: ${err.message}`;
+  }
+}
+
+export const generateImageDescription =
+  `generateImage(prompt: string, optionsJson?: string) - Generate images with DALL-E.
+  prompt: description of the image to generate
+  optionsJson: {"model":"dall-e-3","size":"1024x1024","quality":"standard","style":"vivid","n":1,"outputPath":"/tmp/out.png"}
+  model: "dall-e-3" (default, best quality) or "dall-e-2"
+  size: "1024x1024" | "1792x1024" | "1024x1792" (dall-e-3) or "256x256"|"512x512"|"1024x1024" (dall-e-2)
+  quality: "standard" | "hd" (dall-e-3 only)
+  style: "vivid" | "natural" (dall-e-3 only)
+  Returns the file path of the saved image.`;

package/src/tools/gitTool.js

@@ -0,0 +1,141 @@
+/**
+ * gitTool - Git operations: clone, status, diff, log, commit, push, pull, branch, checkout, stash.
+ */
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import filesystemGuard from "../safety/FilesystemGuard.js";
+
+const MAX_OUTPUT = 8000;
+
+function run(cmd, cwd) {
+  return execSync(cmd, { encoding: "utf-8", cwd, timeout: 60000, maxBuffer: 10 * 1024 * 1024, stdio: ["pipe", "pipe", "pipe"] }).trim();
+}
+
+export async function gitTool(action, paramsJson) {
+  if (!action) return 'Error: action required. Valid: clone, status, diff, log, commit, push, pull, branch, checkout, stash, add, reset, remote';
+
+  const params = paramsJson ? (typeof paramsJson === "string" ? JSON.parse(paramsJson) : paramsJson) : {};
+
+  const repoPath = params.path ? resolve(params.path) : process.cwd();
+
+  if (action !== "clone") {
+    const guard = filesystemGuard.checkRead(repoPath);
+    if (!guard.allowed) return `Access denied: ${guard.reason}`;
+  }
+
+  try {
+    switch (action) {
+
+      case "clone": {
+        const { url, dest, branch } = params;
+        if (!url) return "Error: url is required for clone.";
+        if (!dest) return "Error: dest is required for clone.";
+        const destResolved = resolve(dest);
+        const parentGuard = filesystemGuard.checkWrite(destResolved);
+        if (!parentGuard.allowed) return `Access denied: ${parentGuard.reason}`;
+        const branchFlag = branch ? `-b ${branch}` : "";
+        return run(`git clone ${branchFlag} "${url}" "${destResolved}"`);
+      }
+
+      case "status":
+        return run(`git status`, repoPath);
+
+      case "diff": {
+        const { staged = false, file = "" } = params;
+        const flag = staged ? "--staged" : "";
+        const out = run(`git diff ${flag} ${file}`.trim(), repoPath);
+        return out.slice(0, MAX_OUTPUT) || "(no changes)";
+      }
+
+      case "log": {
+        const { n = 20, oneline = true } = params;
+        const fmt = oneline ? "--oneline" : `--pretty=format:"%h %an %ar - %s"`;
+        return run(`git log ${fmt} -n ${n}`, repoPath);
+      }
+
+      case "add": {
+        const { files = "." } = params;
+        const fileList = Array.isArray(files) ? files.join(" ") : files;
+        run(`git add ${fileList}`, repoPath);
+        return `Staged: ${fileList}`;
+      }
+
+      case "commit": {
+        const { message, all = false } = params;
+        if (!message) return "Error: message is required for commit.";
+        const allFlag = all ? "-a" : "";
+        return run(`git commit ${allFlag} -m ${JSON.stringify(message)}`, repoPath);
+      }
+
+      case "push": {
+        const { remote = "origin", branch: br = "", force = false } = params;
+        const forceFlag = force ? "--force-with-lease" : "";
+        return run(`git push ${forceFlag} ${remote} ${br}`.trim(), repoPath);
+      }
+
+      case "pull": {
+        const { remote = "origin", branch: br = "", rebase = false } = params;
+        const rebaseFlag = rebase ? "--rebase" : "";
+        return run(`git pull ${rebaseFlag} ${remote} ${br}`.trim(), repoPath);
+      }
+
+      case "branch": {
+        const { name, delete: del, list = false } = params;
+        if (list || !name) return run(`git branch -a`, repoPath);
+        if (del) return run(`git branch -d "${name}"`, repoPath);
+        return run(`git branch "${name}"`, repoPath);
+      }
+
+      case "checkout": {
+        const { branch: br, file, create = false } = params;
+        if (file) return run(`git checkout -- "${file}"`, repoPath);
+        if (!br) return "Error: branch is required for checkout.";
+        const createFlag = create ? "-b" : "";
+        return run(`git checkout ${createFlag} "${br}"`, repoPath);
+      }
+
+      case "stash": {
+        const { sub = "push", message: msg = "" } = params;
+        if (sub === "push") return run(`git stash push ${msg ? `-m ${JSON.stringify(msg)}` : ""}`, repoPath);
+        if (sub === "pop")  return run(`git stash pop`, repoPath);
+        if (sub === "list") return run(`git stash list`, repoPath);
+        if (sub === "drop") return run(`git stash drop`, repoPath);
+        return `Unknown stash subcommand: ${sub}`;
+      }
+
+      case "reset": {
+        const { hard = false, file } = params;
+        if (file) return run(`git reset HEAD "${file}"`, repoPath);
+        return run(`git reset ${hard ? "--hard" : "--soft"} HEAD~1`, repoPath);
+      }
+
+      case "remote":
+        return run(`git remote -v`, repoPath);
+
+      default:
+        return `Unknown action: "${action}". Valid: clone, status, diff, log, add, commit, push, pull, branch, checkout, stash, reset, remote`;
+    }
+  } catch (err) {
+    const stderr = err.stderr?.toString().trim() || "";
+    const stdout = err.stdout?.toString().trim() || "";
+    return `Git error: ${stderr || stdout || err.message}`;
+  }
+}
+
+export const gitToolDescription =
+  `gitTool(action: string, paramsJson?: string) - Git operations on a repository.
+  Actions:
+    clone    - {"url":"https://github.com/...","dest":"./myrepo","branch":"main"}
+    status   - {"path":"./myrepo"}
+    diff     - {"path":"./myrepo","staged":false,"file":"src/index.js"}
+    log      - {"path":"./myrepo","n":20,"oneline":true}
+    add      - {"path":"./myrepo","files":["src/index.js","README.md"]}
+    commit   - {"path":"./myrepo","message":"fix: bug in auth","all":false}
+    push     - {"path":"./myrepo","remote":"origin","branch":"main","force":false}
+    pull     - {"path":"./myrepo","remote":"origin","rebase":false}
+    branch   - {"path":"./myrepo","name":"feature/x"} or {"list":true}
+    checkout - {"path":"./myrepo","branch":"main"} or {"create":true,"branch":"feature/x"}
+    stash    - {"path":"./myrepo","sub":"push|pop|list|drop","message":"wip"}
+    reset    - {"path":"./myrepo","hard":false}
+    remote   - {"path":"./myrepo"}`;

package/src/tools/glob.js

@@ -1,5 +1,5 @@
 /**
- * glob(pattern, directory?) — Pattern-based file search with modification time sorting.
+ * glob(pattern, directory?) - Pattern-based file search with modification time sorting.
  * Inspired by Claude Code's Glob tool and Gemini CLI's FindFiles.
  */
 import { glob as globFn } from "glob";