@schuttdev/gigai 0.2.8 → 0.2.9

package/dist/{dist-Z7XWWQBF.js → dist-YWMCMOTP.js}

@@ -239,7 +239,7 @@ var ScriptToolConfigSchema = z.object({
 var BuiltinToolConfigSchema = z.object({
   type: z.literal("builtin"),
   name: z.string(),
-  builtin: z.enum(["filesystem", "shell"]),
+  builtin: z.enum(["filesystem", "shell", "read", "write", "edit", "glob", "grep", "bash"]),
   description: z.string(),
   config: z.record(z.unknown()).optional()
 });
@@ -280,24 +280,29 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { readFileSync } from "fs";
 import { resolve } from "path";
-import { readFile as fsReadFile, readdir } from "fs/promises";
+import {
+  readFile as fsReadFile,
+  writeFile as fsWriteFile,
+  readdir
+} from "fs/promises";
 import { resolve as resolve2, relative, join } from "path";
 import { realpath } from "fs/promises";
 import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { writeFile, readFile, unlink, mkdir } from "fs/promises";
 import { join as join2 } from "path";
 import { tmpdir } from "os";
 import { nanoid as nanoid3 } from "nanoid";
-import { execFile, spawn as spawn3 } from "child_process";
+import { execFile, spawn as spawn4 } from "child_process";
 import { promisify } from "util";
 import { readFile as readFile2 } from "fs/promises";
 import { resolve as resolve3 } from "path";
-import { spawn as spawn4 } from "child_process";
 import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import { input, select, checkbox, confirm } from "@inquirer/prompts";
 import { writeFile as writeFile2 } from "fs/promises";
 import { resolve as resolve4 } from "path";
-import { execFile as execFile2, spawn as spawn6 } from "child_process";
+import { execFile as execFile2, spawn as spawn7 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { input as input2 } from "@inquirer/prompts";
 import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
@@ -841,6 +846,26 @@ async function toolRoutes(server) {
   server.get("/tools", async () => {
     return { tools: server.registry.list() };
   });
+  server.get("/tools/search", async (request) => {
+    const query = request.query.q?.toLowerCase().trim();
+    if (!query) {
+      return { tools: server.registry.list() };
+    }
+    const all = server.registry.list();
+    const keywords = query.split(/\s+/);
+    const scored = all.map((tool) => {
+      const text = `${tool.name} ${tool.description}`.toLowerCase();
+      let score = 0;
+      for (const kw of keywords) {
+        if (tool.name.toLowerCase() === kw) score += 10;
+        else if (tool.name.toLowerCase().includes(kw)) score += 5;
+        if (tool.description.toLowerCase().includes(kw)) score += 2;
+      }
+      return { tool, score };
+    });
+    const matches = scored.filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, 10).map((s) => s.tool);
+    return { tools: matches };
+  });
   server.get("/tools/:name", async (request) => {
     const { name } = request.params;
     const detail = server.registry.getDetail(name);
@@ -864,6 +889,8 @@ async function toolRoutes(server) {
     return { tools: mcpTools };
   });
 }
+var MAX_OUTPUT_SIZE2 = 10 * 1024 * 1024;
+var MAX_READ_SIZE = 2 * 1024 * 1024;
 async function validatePath(targetPath, allowedPaths) {
   const resolved = resolve2(targetPath);
   let real;
@@ -921,6 +948,250 @@ async function searchFilesSafe(path, pattern, allowedPaths) {
   await walk(safePath);
   return results;
 }
+async function readBuiltin(args, allowedPaths) {
+  const filePath = args[0];
+  if (!filePath) {
+    throw new GigaiError(ErrorCode.VALIDATION_ERROR, "Usage: read <file> [offset] [limit]");
+  }
+  const safePath = await validatePath(filePath, allowedPaths);
+  const content = await fsReadFile(safePath, "utf8");
+  if (content.length > MAX_READ_SIZE) {
+    throw new GigaiError(
+      ErrorCode.VALIDATION_ERROR,
+      `File too large (${(content.length / 1024 / 1024).toFixed(1)}MB). Max: ${MAX_READ_SIZE / 1024 / 1024}MB. Use offset/limit.`
+    );
+  }
+  const offset = args[1] ? parseInt(args[1], 10) : 0;
+  const limit = args[2] ? parseInt(args[2], 10) : 0;
+  if (offset || limit) {
+    const lines = content.split("\n");
+    const start = Math.max(0, offset);
+    const end = limit ? start + limit : lines.length;
+    const sliced = lines.slice(start, end);
+    return { stdout: sliced.join("\n"), stderr: "", exitCode: 0 };
+  }
+  return { stdout: content, stderr: "", exitCode: 0 };
+}
+async function writeBuiltin(args, allowedPaths) {
+  const filePath = args[0];
+  const content = args[1];
+  if (!filePath || content === void 0) {
+    throw new GigaiError(ErrorCode.VALIDATION_ERROR, "Usage: write <file> <content>");
+  }
+  const safePath = await validatePath(filePath, allowedPaths);
+  const { mkdir: mkdir2 } = await import("fs/promises");
+  const { dirname } = await import("path");
+  await mkdir2(dirname(safePath), { recursive: true });
+  await fsWriteFile(safePath, content, "utf8");
+  return { stdout: `Written: ${safePath}`, stderr: "", exitCode: 0 };
+}
+async function editBuiltin(args, allowedPaths) {
+  const filePath = args[0];
+  const oldStr = args[1];
+  const newStr = args[2];
+  const replaceAll = args.includes("--all");
+  if (!filePath || oldStr === void 0 || newStr === void 0) {
+    throw new GigaiError(ErrorCode.VALIDATION_ERROR, "Usage: edit <file> <old_string> <new_string> [--all]");
+  }
+  const safePath = await validatePath(filePath, allowedPaths);
+  const content = await fsReadFile(safePath, "utf8");
+  if (!content.includes(oldStr)) {
+    throw new GigaiError(ErrorCode.VALIDATION_ERROR, "old_string not found in file");
+  }
+  if (!replaceAll) {
+    const firstIdx = content.indexOf(oldStr);
+    const secondIdx = content.indexOf(oldStr, firstIdx + 1);
+    if (secondIdx !== -1) {
+      throw new GigaiError(
+        ErrorCode.VALIDATION_ERROR,
+        "old_string matches multiple locations. Use --all to replace all, or provide more context to make it unique."
+      );
+    }
+  }
+  const updated = replaceAll ? content.split(oldStr).join(newStr) : content.replace(oldStr, newStr);
+  await fsWriteFile(safePath, updated, "utf8");
+  const count = replaceAll ? content.split(oldStr).length - 1 : 1;
+  return { stdout: `Replaced ${count} occurrence(s) in ${safePath}`, stderr: "", exitCode: 0 };
+}
+async function globBuiltin(args, allowedPaths) {
+  const pattern = args[0];
+  if (!pattern) {
+    throw new GigaiError(ErrorCode.VALIDATION_ERROR, "Usage: glob <pattern> [path]");
+  }
+  const searchPath = args[1] ?? ".";
+  const safePath = await validatePath(searchPath, allowedPaths);
+  const results = [];
+  const globRegex = globToRegex(pattern);
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      const relPath = relative(safePath, fullPath);
+      if (globRegex.test(relPath) || globRegex.test(entry.name)) {
+        results.push(relPath);
+      }
+      if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+        await walk(fullPath);
+      }
+      if (results.length >= 1e3) return;
+    }
+  }
+  await walk(safePath);
+  return { stdout: results.join("\n"), stderr: "", exitCode: 0 };
+}
+async function grepBuiltin(args, allowedPaths) {
+  if (args.length === 0) {
+    throw new GigaiError(ErrorCode.VALIDATION_ERROR, "Usage: grep <pattern> [path] [--glob <filter>] [-i] [-n] [-C <num>]");
+  }
+  const positional = [];
+  const flags = [];
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === "--glob" && args[i + 1]) {
+      flags.push("--glob", args[i + 1]);
+      i += 2;
+    } else if (arg === "--type" && args[i + 1]) {
+      flags.push("--type", args[i + 1]);
+      i += 2;
+    } else if (arg === "-C" && args[i + 1]) {
+      flags.push("-C", args[i + 1]);
+      i += 2;
+    } else if (arg === "-i" || arg === "-n" || arg === "-l") {
+      flags.push(arg);
+      i++;
+    } else {
+      positional.push(arg);
+      i++;
+    }
+  }
+  const pattern = positional[0];
+  if (!pattern) {
+    throw new GigaiError(ErrorCode.VALIDATION_ERROR, "No search pattern provided");
+  }
+  const searchPath = positional[1] ?? ".";
+  const safePath = await validatePath(searchPath, allowedPaths);
+  try {
+    return await spawnGrep("rg", [pattern, safePath, "-n", ...flags]);
+  } catch {
+    try {
+      return await spawnGrep("grep", ["-rn", ...flags, pattern, safePath]);
+    } catch {
+      return jsGrep(pattern, safePath);
+    }
+  }
+}
+function spawnGrep(cmd, args) {
+  return new Promise((resolve7, reject) => {
+    const child = spawn2(cmd, args, { shell: false, stdio: ["ignore", "pipe", "pipe"] });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let totalSize = 0;
+    child.stdout.on("data", (chunk) => {
+      totalSize += chunk.length;
+      if (totalSize <= MAX_OUTPUT_SIZE2) stdoutChunks.push(chunk);
+      else child.kill("SIGTERM");
+    });
+    child.stderr.on("data", (chunk) => {
+      totalSize += chunk.length;
+      if (totalSize <= MAX_OUTPUT_SIZE2) stderrChunks.push(chunk);
+    });
+    child.on("error", () => reject(new Error(`${cmd} not available`)));
+    child.on("close", (exitCode) => {
+      resolve7({
+        stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf8"),
+        exitCode: exitCode ?? 1
+      });
+    });
+  });
+}
+async function jsGrep(pattern, searchPath) {
+  let regex;
+  try {
+    regex = new RegExp(pattern);
+  } catch {
+    throw new GigaiError(ErrorCode.VALIDATION_ERROR, `Invalid pattern: ${pattern}`);
+  }
+  const results = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (results.length >= 500) return;
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
+          await walk(fullPath);
+        }
+      } else {
+        try {
+          const content = await fsReadFile(fullPath, "utf8");
+          const lines = content.split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            if (regex.test(lines[i])) {
+              results.push(`${relative(searchPath, fullPath)}:${i + 1}:${lines[i]}`);
+              if (results.length >= 500) return;
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  await walk(searchPath);
+  return {
+    stdout: results.join("\n"),
+    stderr: results.length >= 500 ? "Results truncated at 500 matches" : "",
+    exitCode: results.length > 0 ? 0 : 1
+  };
+}
+function globToRegex(pattern) {
+  let regex = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        regex += ".*";
+        i += 2;
+        if (pattern[i] === "/") i++;
+      } else {
+        regex += "[^/]*";
+        i++;
+      }
+    } else if (c === "?") {
+      regex += "[^/]";
+      i++;
+    } else if (c === "{") {
+      const end = pattern.indexOf("}", i);
+      if (end !== -1) {
+        const options = pattern.slice(i + 1, end).split(",");
+        regex += `(?:${options.map(escapeRegex).join("|")})`;
+        i = end + 1;
+      } else {
+        regex += escapeRegex(c);
+        i++;
+      }
+    } else {
+      regex += escapeRegex(c);
+      i++;
+    }
+  }
+  return new RegExp(regex);
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 var SHELL_INTERPRETERS = /* @__PURE__ */ new Set([
   "sh",
   "bash",
@@ -936,7 +1207,7 @@ var SHELL_INTERPRETERS = /* @__PURE__ */ new Set([
   "strace",
   "ltrace"
 ]);
-var MAX_OUTPUT_SIZE2 = 10 * 1024 * 1024;
+var MAX_OUTPUT_SIZE3 = 10 * 1024 * 1024;
 async function execCommandSafe(command, args, config) {
   if (!config.allowlist.includes(command)) {
     throw new GigaiError(
@@ -959,7 +1230,7 @@ async function execCommandSafe(command, args, config) {
     }
   }
   return new Promise((resolve7, reject) => {
-    const child = spawn2(command, args, {
+    const child = spawn3(command, args, {
       shell: false,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -968,12 +1239,12 @@ async function execCommandSafe(command, args, config) {
     let totalSize = 0;
     child.stdout.on("data", (chunk) => {
       totalSize += chunk.length;
-      if (totalSize <= MAX_OUTPUT_SIZE2) stdoutChunks.push(chunk);
+      if (totalSize <= MAX_OUTPUT_SIZE3) stdoutChunks.push(chunk);
       else child.kill("SIGTERM");
     });
     child.stderr.on("data", (chunk) => {
       totalSize += chunk.length;
-      if (totalSize <= MAX_OUTPUT_SIZE2) stderrChunks.push(chunk);
+      if (totalSize <= MAX_OUTPUT_SIZE3) stderrChunks.push(chunk);
       else child.kill("SIGTERM");
     });
     child.on("error", (err) => {
@@ -1047,6 +1318,7 @@ async function execRoutes(server) {
 async function handleBuiltin(config, args) {
   const builtinConfig = config.config ?? {};
   switch (config.builtin) {
+    // Legacy combined filesystem tool
     case "filesystem": {
       const allowedPaths = builtinConfig.allowedPaths ?? ["."];
       const subcommand = args[0];
@@ -1062,6 +1334,7 @@ async function handleBuiltin(config, args) {
           throw new GigaiError(ErrorCode.VALIDATION_ERROR, `Unknown filesystem subcommand: ${subcommand}. Use: read, list, search`);
       }
     }
+    // Legacy shell tool
     case "shell": {
       const allowlist = builtinConfig.allowlist ?? [];
       const allowSudo = builtinConfig.allowSudo ?? false;
@@ -1072,6 +1345,37 @@ async function handleBuiltin(config, args) {
       const result = await execCommandSafe(command, args.slice(1), { allowlist, allowSudo });
       return { ...result, durationMs: 0 };
     }
+    // --- New builtins ---
+    case "read": {
+      const allowedPaths = builtinConfig.allowedPaths ?? ["."];
+      return { ...await readBuiltin(args, allowedPaths), durationMs: 0 };
+    }
+    case "write": {
+      const allowedPaths = builtinConfig.allowedPaths ?? ["."];
+      return { ...await writeBuiltin(args, allowedPaths), durationMs: 0 };
+    }
+    case "edit": {
+      const allowedPaths = builtinConfig.allowedPaths ?? ["."];
+      return { ...await editBuiltin(args, allowedPaths), durationMs: 0 };
+    }
+    case "glob": {
+      const allowedPaths = builtinConfig.allowedPaths ?? ["."];
+      return { ...await globBuiltin(args, allowedPaths), durationMs: 0 };
+    }
+    case "grep": {
+      const allowedPaths = builtinConfig.allowedPaths ?? ["."];
+      return { ...await grepBuiltin(args, allowedPaths), durationMs: 0 };
+    }
+    case "bash": {
+      const allowlist = builtinConfig.allowlist ?? [];
+      const allowSudo = builtinConfig.allowSudo ?? false;
+      const command = args[0];
+      if (!command) {
+        throw new GigaiError(ErrorCode.VALIDATION_ERROR, "No command specified");
+      }
+      const result = await execCommandSafe(command, args.slice(1), { allowlist, allowSudo });
+      return { ...result, durationMs: 0 };
+    }
     default:
       throw new GigaiError(ErrorCode.VALIDATION_ERROR, `Unknown builtin: ${config.builtin}`);
   }
@@ -1160,7 +1464,7 @@ async function adminRoutes(server) {
         args.push("--dev");
       }
       await server.close();
-      const child = spawn3("gigai", args, {
+      const child = spawn4("gigai", args, {
         detached: true,
         stdio: "ignore",
         cwd: process.cwd()
@@ -1228,7 +1532,7 @@ async function loadConfig(path) {
 }
 function runCommand(command, args) {
   return new Promise((resolve7, reject) => {
-    const child = spawn4(command, args, { shell: false, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn5(command, args, { shell: false, stdio: ["ignore", "pipe", "pipe"] });
     const chunks = [];
     child.stdout.on("data", (chunk) => chunks.push(chunk));
     child.on("error", reject);
@@ -1269,7 +1573,7 @@ async function disableFunnel(port) {
   await runCommand("tailscale", ["funnel", "--bg", "off", `${port}`]);
 }
 function runTunnel(tunnelName, localPort) {
-  const child = spawn5("cloudflared", [
+  const child = spawn6("cloudflared", [
     "tunnel",
     "--url",
     `http://localhost:${localPort}`,
@@ -1487,7 +1791,7 @@ async function runInit() {
   console.log("\n  Starting server...");
   const serverArgs = ["start", "--config", configPath];
   if (!httpsConfig) serverArgs.push("--dev");
-  const child = spawn6("gigai", serverArgs, {
+  const child = spawn7("gigai", serverArgs, {
     detached: true,
     stdio: "ignore",
     cwd: resolve4(".")

package/dist/index.js

@@ -4,12 +4,12 @@
 import { defineCommand, runMain } from "citty";
 
 // src/version.ts
-var VERSION = "0.2.8";
+var VERSION = "0.2.9";
 
 // src/index.ts
 async function requireServer() {
   try {
-    return await import("./dist-Z7XWWQBF.js");
+    return await import("./dist-YWMCMOTP.js");
   } catch {
     console.error("Server dependencies not installed.");
     console.error("Run: npm install -g @schuttdev/gigai");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schuttdev/gigai",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "type": "module",
   "bin": {
     "gigai": "dist/index.js"