@avasis-ai/synthcode 1.0.0

package/dist/chunk-53ZOIXM4.js

@@ -0,0 +1,624 @@
+import {
+  globToRegExp
+} from "./chunk-W6OLZ2OI.js";
+import {
+  defineTool
+} from "./chunk-FK7S2S7V.js";
+import {
+  fuzzyReplace
+} from "./chunk-MQ7XP6VT.js";
+
+// src/tools/orchestrator.ts
+var Semaphore = class {
+  constructor(max) {
+    this.max = max;
+  }
+  max;
+  current = 0;
+  queue = [];
+  acquire() {
+    if (this.current < this.max) {
+      this.current++;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.queue.push(resolve);
+    });
+  }
+  release() {
+    this.current--;
+    const next = this.queue.shift();
+    if (next) {
+      this.current++;
+      next();
+    }
+  }
+};
+function partitionToolCalls(toolCalls, registry) {
+  const batches = [];
+  let currentBatch = [];
+  let currentBatchIsConcurrent = false;
+  for (const call of toolCalls) {
+    const tool = registry.get(call.name);
+    const isConcurrent = tool ? tool.isReadOnly && tool.isConcurrencySafe : false;
+    if (isConcurrent && currentBatchIsConcurrent) {
+      currentBatch.push(call);
+    } else {
+      if (currentBatch.length > 0) {
+        batches.push(currentBatch);
+      }
+      currentBatch = [call];
+      currentBatchIsConcurrent = isConcurrent;
+    }
+  }
+  if (currentBatch.length > 0) {
+    batches.push(currentBatch);
+  }
+  return batches;
+}
+async function executeToolCall(call, registry, context, permissionCheck, abortSignal) {
+  if (abortSignal?.aborted) {
+    return {
+      id: call.id,
+      name: call.name,
+      output: "Execution aborted",
+      isError: true,
+      durationMs: 0
+    };
+  }
+  const tool = registry.get(call.name);
+  if (!tool) {
+    return {
+      id: call.id,
+      name: call.name,
+      output: `Unknown tool: ${call.name}`,
+      isError: true,
+      durationMs: 0
+    };
+  }
+  const start = performance.now();
+  try {
+    const parseResult = tool.inputSchema.safeParse(call.input);
+    if (!parseResult.success) {
+      return {
+        id: call.id,
+        name: call.name,
+        output: `Invalid input for ${call.name}: ${parseResult.error.issues.map((i) => i.message).join(", ")}`,
+        isError: true,
+        durationMs: Math.round(performance.now() - start)
+      };
+    }
+    if (permissionCheck) {
+      const allowed = await permissionCheck(call.name, call.input);
+      if (!allowed) {
+        return {
+          id: call.id,
+          name: call.name,
+          output: `Permission denied for tool: ${call.name}`,
+          isError: true,
+          durationMs: Math.round(performance.now() - start)
+        };
+      }
+    }
+    const output = await tool.execute(parseResult.data, context);
+    return {
+      id: call.id,
+      name: call.name,
+      output,
+      isError: false,
+      durationMs: Math.round(performance.now() - start)
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      id: call.id,
+      name: call.name,
+      output: `Error executing ${call.name}: ${message}`,
+      isError: true,
+      durationMs: Math.round(performance.now() - start)
+    };
+  }
+}
+async function orchestrateTools(tools, toolCalls, context, permissionCheck, abortSignal) {
+  const batches = partitionToolCalls(toolCalls, tools);
+  const results = [];
+  for (const batch of batches) {
+    if (abortSignal?.aborted) {
+      for (const call of batch) {
+        results.push({
+          id: call.id,
+          name: call.name,
+          output: "Execution aborted",
+          isError: true,
+          durationMs: 0
+        });
+      }
+      continue;
+    }
+    if (batch.length > 1) {
+      const semaphore = new Semaphore(10);
+      const promises = batch.map(
+        (call) => semaphore.acquire().then(async () => {
+          try {
+            return await executeToolCall(call, tools, context, permissionCheck, abortSignal);
+          } finally {
+            semaphore.release();
+          }
+        })
+      );
+      const settled = await Promise.allSettled(promises);
+      for (let i = 0; i < settled.length; i++) {
+        const s = settled[i];
+        if (s.status === "fulfilled") {
+          results.push(s.value);
+        } else {
+          results.push({
+            id: batch[i].id,
+            name: batch[i].name,
+            output: `Unexpected error: ${s.reason instanceof Error ? s.reason.message : String(s.reason)}`,
+            isError: true,
+            durationMs: 0
+          });
+        }
+      }
+    } else {
+      const result = await executeToolCall(batch[0], tools, context, permissionCheck, abortSignal);
+      results.push(result);
+    }
+  }
+  return results;
+}
+
+// src/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  constructor(tools) {
+    if (tools) {
+      for (const tool of tools) {
+        this.add(tool);
+      }
+    }
+  }
+  /** Add a tool to the registry. Duplicate names are ignored (first one wins). */
+  add(tool) {
+    if (this.tools.has(tool.name)) {
+      console.warn(`[ToolRegistry] Duplicate tool "${tool.name}" ignored (first one wins)`);
+      return;
+    }
+    this.tools.set(tool.name, tool);
+  }
+  /** Get a tool by name. */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /** Check if a tool exists by name. */
+  has(name) {
+    return this.tools.has(name);
+  }
+  /** Find tool by case-insensitive name. Returns undefined if not found. */
+  findCaseInsensitive(name) {
+    const lower = name.toLowerCase();
+    if (this.tools.has(name)) return name;
+    for (const key of this.tools.keys()) {
+      if (key.toLowerCase() === lower) return key;
+    }
+    return void 0;
+  }
+  /** List all registered tool names. */
+  listNames() {
+    return Array.from(this.tools.keys());
+  }
+  /** Get all registered tools. */
+  getAll() {
+    return Array.from(this.tools.values());
+  }
+  /** Get all tools in API format, sorted by name for cache stability. */
+  getAPI() {
+    return this.getAll().sort((a, b) => a.name.localeCompare(b.name)).map((t) => t.toAPI());
+  }
+  /** Number of registered tools. */
+  get size() {
+    return this.tools.size;
+  }
+};
+
+// src/tools/bash.ts
+import { exec } from "child_process";
+import { z } from "zod";
+var MAX_OUTPUT = 50 * 1024;
+var TRUNCATE_HALF = 25 * 1024;
+function truncateOutput(output) {
+  if (output.length <= MAX_OUTPUT) return output;
+  const notice = `
+
+... [output truncated: showing first ${TRUNCATE_HALF} and last ${TRUNCATE_HALF} of ${output.length} characters] ...
+
+`;
+  return output.slice(0, TRUNCATE_HALF) + notice + output.slice(-TRUNCATE_HALF);
+}
+var BashTool = defineTool({
+  name: "bash",
+  description: "Execute a shell command. Returns stdout and stderr. Use for running build commands, git operations, package managers, and other CLI tools.",
+  inputSchema: z.object({
+    command: z.string().describe("The shell command to execute"),
+    timeout: z.number().optional().describe("Timeout in milliseconds (default 120000)"),
+    workdir: z.string().optional().describe("Working directory for the command")
+  }),
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  execute: async ({ command, timeout = 12e4, workdir }, context) => {
+    return new Promise((resolve) => {
+      let settled = false;
+      const done = (result) => {
+        if (settled) return;
+        settled = true;
+        resolve(result);
+      };
+      if (context.abortSignal?.aborted) {
+        done("Command aborted before execution");
+        return;
+      }
+      const child = exec(
+        command,
+        {
+          cwd: workdir ?? context.cwd,
+          timeout,
+          maxBuffer: 10 * 1024 * 1024,
+          killSignal: "SIGKILL"
+        },
+        (error, stdout, stderr) => {
+          let output = "";
+          if (stdout) output += `STDOUT:
+${stdout}
+
+`;
+          if (stderr) output += `STDERR:
+${stderr}
+
+`;
+          output += `Exit code: ${error?.code ?? 0}`;
+          if (error && error.killed) {
+            output = `Command timed out after ${timeout}ms
+
+${output}`;
+          }
+          done(truncateOutput(output));
+        }
+      );
+      child.on("error", (err) => {
+        done(`Failed to execute command: ${err.message}`);
+      });
+      if (context.abortSignal) {
+        context.abortSignal.addEventListener(
+          "abort",
+          () => {
+            child.kill("SIGKILL");
+            done("Command aborted");
+          },
+          { once: true }
+        );
+      }
+    });
+  }
+});
+
+// src/tools/file-read.ts
+import fs from "fs/promises";
+import path from "path";
+import { z as z2 } from "zod";
+var MAX_LINE_LENGTH = 2e3;
+var FileReadTool = defineTool({
+  name: "file_read",
+  description: "Read the contents of a file. Returns the file content with line numbers. Use GlobTool to find files first.",
+  inputSchema: z2.object({
+    path: z2.string().describe("Absolute or relative path to the file"),
+    offset: z2.number().optional().describe("Line number to start reading from (1-indexed)"),
+    limit: z2.number().optional().describe("Maximum number of lines to read")
+  }),
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  execute: async ({ path: filePath, offset, limit }, context) => {
+    try {
+      const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(context.cwd, filePath);
+      const content = await fs.readFile(resolved, "utf-8");
+      const lines = content.split("\n");
+      const startLine = offset ? Math.max(1, offset) : 1;
+      const startIndex = startLine - 1;
+      const endIndex = limit != null ? startIndex + limit : lines.length;
+      const selected = lines.slice(startIndex, endIndex);
+      const formatted = selected.map((line, i) => {
+        const lineNum = startLine + i;
+        const truncated = line.length > MAX_LINE_LENGTH ? line.slice(0, MAX_LINE_LENGTH) + "..." : line;
+        return `${lineNum}: ${truncated}`;
+      }).join("\n");
+      return formatted;
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return `Error: File not found: ${filePath}`;
+      }
+      if (err.code === "EISDIR") {
+        return `Error: Path is a directory: ${filePath}`;
+      }
+      return `Error reading file: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+
+// src/tools/file-write.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import { z as z3 } from "zod";
+var FileWriteTool = defineTool({
+  name: "file_write",
+  description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Parent directories are created automatically.",
+  inputSchema: z3.object({
+    path: z3.string().describe("Path to the file"),
+    content: z3.string().describe("Content to write")
+  }),
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  execute: async ({ path: filePath, content }, context) => {
+    try {
+      const resolved = path2.isAbsolute(filePath) ? filePath : path2.resolve(context.cwd, filePath);
+      const dir = path2.dirname(resolved);
+      await fs2.mkdir(dir, { recursive: true });
+      await fs2.writeFile(resolved, content, "utf-8");
+      return `Wrote ${content.length} characters to ${filePath}`;
+    } catch (err) {
+      return `Error writing file: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+
+// src/tools/file-edit.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+import { z as z4 } from "zod";
+var FileEditTool = defineTool({
+  name: "file_edit",
+  description: "Edit an existing file by replacing a string match with new content. Uses 9-strategy fuzzy matching (exact, line-trimmed, block-anchor with Levenshtein, whitespace-normalized, indentation-flexible, escape-normalized, trimmed-boundary, context-aware, multi-occurrence) so the oldString does not need to be a perfect character-for-character match. For multi-line edits, include enough surrounding context to ensure uniqueness.",
+  inputSchema: z4.object({
+    path: z4.string().describe("Path to the file"),
+    oldString: z4.string().describe("The string to find and replace (fuzzy-matched)"),
+    newString: z4.string().describe("The replacement string"),
+    replaceAll: z4.boolean().optional().describe("Replace all occurrences instead of just the first")
+  }),
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  execute: async ({ path: filePath, oldString, newString, replaceAll = false }, context) => {
+    try {
+      const resolved = path3.isAbsolute(filePath) ? filePath : path3.resolve(context.cwd, filePath);
+      const content = await fs3.readFile(resolved, "utf-8");
+      let newContent;
+      let count = 0;
+      if (replaceAll) {
+        const occurrences = content.split(oldString).length - 1;
+        if (occurrences === 0) {
+          try {
+            newContent = fuzzyReplace(content, oldString, newString, true);
+            count = 1;
+          } catch {
+            return `Error: oldString not found in ${filePath} (tried 9 fuzzy strategies)`;
+          }
+        } else {
+          newContent = content.split(oldString).join(newString);
+          count = occurrences;
+        }
+      } else {
+        try {
+          newContent = fuzzyReplace(content, oldString, newString, false);
+          count = 1;
+        } catch (err) {
+          const kind = err.kind;
+          if (kind === "ambiguous") {
+            return `Error: Multiple matches for oldString in ${filePath}. Provide more surrounding context or set replaceAll to true.`;
+          }
+          return `Error: oldString not found in ${filePath} (tried 9 fuzzy strategies)`;
+        }
+      }
+      await fs3.writeFile(resolved, newContent, "utf-8");
+      return `Replaced ${count} occurrence(s) in ${filePath}`;
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return `Error: File not found: ${filePath}`;
+      }
+      return `Error editing file: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+
+// src/tools/glob.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+import { z as z5 } from "zod";
+var MAX_RESULTS = 200;
+async function walkDir(dir) {
+  const { walkDir: walk } = await import("./utils-TF4TBXQJ.js");
+  const entries = await walk(dir);
+  return entries.map((e) => e.path);
+}
+function matchInclude(filePath, includePattern) {
+  if (!includePattern) return true;
+  const base = path4.basename(filePath);
+  const re = globToRegExp(includePattern);
+  return re.test(base);
+}
+var GlobTool = defineTool({
+  name: "glob",
+  description: "Find files matching a glob pattern. Returns matching file paths sorted by modification time.",
+  inputSchema: z5.object({
+    pattern: z5.string().describe('Glob pattern (e.g., "**/*.ts", "src/**/*.tsx")'),
+    path: z5.string().optional().describe("Directory to search in (default: current directory)"),
+    include: z5.string().optional().describe('File extension or pattern to include (e.g., "*.ts")')
+  }),
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  execute: async ({ pattern, path: searchPath, include }, context) => {
+    try {
+      const searchDir = searchPath ? path4.isAbsolute(searchPath) ? searchPath : path4.resolve(context.cwd, searchPath) : context.cwd;
+      const allFiles = await walkDir(searchDir);
+      const re = globToRegExp(pattern);
+      const matched = [];
+      for (const filePath of allFiles) {
+        const relative = path4.relative(searchDir, filePath);
+        if (re.test(relative) && matchInclude(relative, include)) {
+          try {
+            const stat = await fs4.stat(filePath);
+            matched.push({ filePath: relative, mtimeMs: stat.mtimeMs });
+          } catch {
+            matched.push({ filePath: relative, mtimeMs: 0 });
+          }
+        }
+      }
+      matched.sort((a, b) => b.mtimeMs - a.mtimeMs);
+      const limited = matched.slice(0, MAX_RESULTS);
+      return limited.map((m) => m.filePath).join("\n");
+    } catch (err) {
+      return `Error searching files: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+
+// src/tools/grep.ts
+import fs5 from "fs/promises";
+import path5 from "path";
+import { z as z6 } from "zod";
+var MAX_MATCHES = 200;
+async function walkDir2(dir) {
+  const { walkDir: walk } = await import("./utils-TF4TBXQJ.js");
+  const entries = await walk(dir);
+  return entries.map((e) => e.path);
+}
+var GrepTool = defineTool({
+  name: "grep",
+  description: "Search file contents using a regular expression. Returns matching file paths with line numbers.",
+  inputSchema: z6.object({
+    pattern: z6.string().describe("Regular expression to search for"),
+    path: z6.string().optional().describe("Directory to search in"),
+    include: z6.string().optional().describe('File pattern to include (e.g., "*.ts")')
+  }),
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  execute: async ({ pattern, path: searchPath, include }, context) => {
+    try {
+      let regex;
+      try {
+        regex = new RegExp(pattern);
+      } catch {
+        return `Error: Invalid regular expression: ${pattern}`;
+      }
+      const searchDir = searchPath ? path5.isAbsolute(searchPath) ? searchPath : path5.resolve(context.cwd, searchPath) : context.cwd;
+      const includeRe = include ? globToRegExp(include) : null;
+      const allFiles = await walkDir2(searchDir);
+      const matches = [];
+      for (const filePath of allFiles) {
+        if (matches.length >= MAX_MATCHES) break;
+        if (includeRe) {
+          const base = path5.basename(filePath);
+          if (!includeRe.test(base)) continue;
+        }
+        let content;
+        try {
+          content = await fs5.readFile(filePath, "utf-8");
+        } catch {
+          continue;
+        }
+        const lines = content.split("\n");
+        const relative = path5.relative(searchDir, filePath);
+        for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+          if (matches.length >= MAX_MATCHES) break;
+          const line = lines[lineIdx];
+          if (regex.test(line)) {
+            matches.push(`${relative}:${lineIdx + 1}: ${line}`);
+            regex.lastIndex = 0;
+          } else {
+            regex.lastIndex = 0;
+          }
+        }
+      }
+      if (matches.length === 0) {
+        return "No matches found.";
+      }
+      return matches.join("\n");
+    } catch (err) {
+      return `Error searching files: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+
+// src/tools/web-fetch.ts
+import { z as z7 } from "zod";
+var MAX_RESPONSE_SIZE = 100 * 1024;
+var WebFetchTool = defineTool({
+  name: "web_fetch",
+  description: "Fetch content from a URL. Returns the response body as text. Supports HTTP and HTTPS.",
+  inputSchema: z7.object({
+    url: z7.string().url().describe("The URL to fetch"),
+    method: z7.enum(["GET", "POST", "PUT", "DELETE"]).optional().describe("HTTP method (default: GET)"),
+    headers: z7.record(z7.string()).optional().describe("Request headers"),
+    body: z7.string().optional().describe("Request body (for POST/PUT)")
+  }),
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  execute: async ({ url, method = "GET", headers, body }, context) => {
+    try {
+      if (context.abortSignal?.aborted) {
+        return "Request aborted before execution";
+      }
+      const timeoutSignal = AbortSignal.timeout(3e4);
+      let signal;
+      if (context.abortSignal) {
+        signal = AbortSignal.any([context.abortSignal, timeoutSignal]);
+      } else {
+        signal = timeoutSignal;
+      }
+      const fetchOptions = {
+        method,
+        headers,
+        signal,
+        redirect: "follow"
+      };
+      if (body && method !== "GET") {
+        fetchOptions.body = body;
+      }
+      const response = await fetch(url, fetchOptions);
+      const contentType = response.headers.get("content-type") ?? "unknown";
+      const status = response.status;
+      const text = await response.text();
+      let result = `Status: ${status}
+Content-Type: ${contentType}
+
+`;
+      if (text.length > MAX_RESPONSE_SIZE) {
+        const half = Math.floor(MAX_RESPONSE_SIZE / 2);
+        const notice = `
+
+... [response truncated: showing first ${half} and last ${half} of ${text.length} characters] ...
+
+`;
+        result += text.slice(0, half) + notice + text.slice(-half);
+      } else {
+        result += text;
+      }
+      return result;
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        return "Request aborted";
+      }
+      return `Error fetching URL: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+
+export {
+  orchestrateTools,
+  ToolRegistry,
+  BashTool,
+  FileReadTool,
+  FileWriteTool,
+  FileEditTool,
+  GlobTool,
+  GrepTool,
+  WebFetchTool
+};
+//# sourceMappingURL=chunk-53ZOIXM4.js.map