@ddlqhd/agent-sdk 0.1.0 → 0.1.1

package/dist/{chunk-OHXW2YM6.js → chunk-THKEF32L.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { zodToJsonSchema } from './chunk-WH3APNQ5.js';
+import { zodToJsonSchema } from './chunk-LOYIGOBZ.js';
 import { mkdir, writeFile, readFile } from 'fs/promises';
-import { join, dirname } from 'path';
+import { join, dirname, win32 } from 'path';
 import { homedir } from 'os';
-import { z } from 'zod';
 import iconv from 'iconv-lite';
 import fg from 'fast-glob';
+import { z } from 'zod';
 import { analyse } from 'chardet';
 import { execSync, spawn } from 'child_process';
 import { existsSync } from 'fs';
@@ -223,6 +223,8 @@ var OutputHandler = class {
 function createOutputHandler(userBasePath) {
   return new OutputHandler(userBasePath);
 }
+
+// src/tools/registry.ts
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
   categories = /* @__PURE__ */ new Map();
@@ -381,7 +383,18 @@ var ToolRegistry = class {
     }
     let workingInput = rawArgsObj;
     try {
-      workingInput = tool.parameters.parse(args);
+      const initial = tool.parameters.safeParse(args);
+      if (!initial.success) {
+        const msg = `Invalid arguments for tool "${name}": ${initial.error.issues.map((i) => i.message).join(", ")}`;
+        await hookMgr?.executePostToolUseFailure(
+          this.buildHookContext("postToolUseFailure", name, rawArgsObj, options, {
+            errorMessage: msg,
+            failureKind: "validation"
+          })
+        );
+        return { content: msg, isError: true };
+      }
+      workingInput = initial.data;
       if (hookMgr) {
         const pre = await hookMgr.executePreToolUse(
           this.buildHookContext("preToolUse", name, workingInput, options)
@@ -392,21 +405,18 @@ var ToolRegistry = class {
             isError: true
           };
         }
-        try {
-          workingInput = tool.parameters.parse(pre.updatedInput ?? workingInput);
-        } catch (err) {
-          if (err instanceof z.ZodError) {
-            const msg = `Invalid arguments after hook merge for tool "${name}": ${err.errors.map((e) => e.message).join(", ")}`;
-            await hookMgr.executePostToolUseFailure(
-              this.buildHookContext("postToolUseFailure", name, workingInput, options, {
-                errorMessage: msg,
-                failureKind: "validation"
-              })
-            );
-            return { content: msg, isError: true };
-          }
-          throw err;
+        const merged = tool.parameters.safeParse(pre.updatedInput ?? workingInput);
+        if (!merged.success) {
+          const msg = `Invalid arguments after hook merge for tool "${name}": ${merged.error.issues.map((i) => i.message).join(", ")}`;
+          await hookMgr.executePostToolUseFailure(
+            this.buildHookContext("postToolUseFailure", name, workingInput, options, {
+              errorMessage: msg,
+              failureKind: "validation"
+            })
+          );
+          return { content: msg, isError: true };
         }
+        workingInput = merged.data;
       }
       const handlerArgs = workingInput;
       const executionContext = {
@@ -442,19 +452,6 @@ var ToolRegistry = class {
       );
       return finalResult;
     } catch (error) {
-      if (error instanceof z.ZodError) {
-        const msg2 = `Invalid arguments for tool "${name}": ${error.errors.map((e) => e.message).join(", ")}`;
-        await hookMgr?.executePostToolUseFailure(
-          this.buildHookContext("postToolUseFailure", name, rawArgsObj, options, {
-            errorMessage: msg2,
-            failureKind: "validation"
-          })
-        );
-        return {
-          content: msg2,
-          isError: true
-        };
-      }
       const msg = `Error executing tool "${name}": ${error instanceof Error ? error.message : String(error)}`;
       await hookMgr?.executePostToolUseFailure(
         this.buildHookContext("postToolUseFailure", name, workingInput, options, {
@@ -802,10 +799,94 @@ var MAX_LINE_LENGTH = 2e3;
 var MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH} chars)`;
 var MAX_BYTES = 50 * 1024;
 var MAX_BYTES_LABEL = `${MAX_BYTES / 1024} KB`;
+var EDIT_MAX_FILE_BYTES = 1024 ** 3;
+function detectDominantEol(content) {
+  let crlf = 0;
+  for (let i = 0; i < content.length - 1; i++) {
+    if (content[i] === "\r" && content[i + 1] === "\n") {
+      crlf++;
+    }
+  }
+  let nl = 0;
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] === "\n") {
+      nl++;
+    }
+  }
+  const bareLf = nl - crlf;
+  if (crlf > bareLf) {
+    return "\r\n";
+  }
+  return "\n";
+}
+function normalizeNewStringEols(text, eol) {
+  const unified = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (eol === "\n") {
+    return unified;
+  }
+  return unified.replace(/\n/g, "\r\n");
+}
+function buildNeedleCandidates(oldString, dominantEol) {
+  const out = [oldString];
+  if (dominantEol === "\r\n") {
+    if (!oldString.includes("\r")) {
+      const v = oldString.replace(/\n/g, "\r\n");
+      if (v !== oldString) {
+        out.push(v);
+      }
+    }
+  } else {
+    if (oldString.includes("\r\n")) {
+      const v = oldString.replace(/\r\n/g, "\n");
+      if (v !== oldString) {
+        out.push(v);
+      }
+    } else if (oldString.includes("\r")) {
+      const v = oldString.replace(/\r/g, "\n");
+      if (v !== oldString) {
+        out.push(v);
+      }
+    }
+  }
+  return out;
+}
+function countOccurrences(haystack, needle) {
+  if (needle.length === 0) {
+    return 0;
+  }
+  let n = 0;
+  let from = 0;
+  let i = 0;
+  while ((i = haystack.indexOf(needle, from)) !== -1) {
+    n++;
+    from = i + needle.length;
+  }
+  return n;
+}
+function replaceNonOverlapping(content, needle, replacement, replaceAll) {
+  if (!replaceAll) {
+    const i2 = content.indexOf(needle);
+    if (i2 === -1) {
+      throw new Error("Edit: needle not found after resolution (internal inconsistency)");
+    }
+    return content.slice(0, i2) + replacement + content.slice(i2 + needle.length);
+  }
+  let out = "";
+  let from = 0;
+  let i = 0;
+  while ((i = content.indexOf(needle, from)) !== -1) {
+    out += content.slice(from, i) + replacement;
+    from = i + needle.length;
+  }
+  out += content.slice(from);
+  return out;
+}
 var readFileTool = createTool({
   name: "Read",
   category: "filesystem",
-  description: `Reads a file from the local filesystem. You can access any file directly by using this tool.
+  description: `Reads human-readable text from the local filesystem: source code, configuration, logs, Markdown, and structured text (JSON, XML, YAML, etc.).
+
+Do NOT use Read for binary formats. This tool decodes the file as text; for binaries the result is garbage or misleading. Examples: images (png, jpg, gif, webp, ico), Office/OpenXML (xlsx, docx, pptx), PDF, audio/video, archives (zip, gz, etc.), and compiled binaries. Prefer format-specific tooling, a small script or library in the user's environment, or ask the user for an exported/plain-text view.
 
 Usage:
 - The file_path parameter must be an absolute path, not a relative path
@@ -814,10 +895,12 @@ Usage:
 - Results are returned using cat -n style, with line numbers starting at 1
 - Lines longer than 2000 characters are truncated
 - Use the offset and limit parameters to read specific line ranges of large files
-- If you read a file that exists but has empty contents you will receive an error message
+- An empty file (no lines) returns successfully with no numbered lines and a suffix noting zero total lines\u2014it is not an error
 - Text encoding is detected automatically from the file (BOM, UTF-8 validity, charset analysis). You rarely need to set encoding; use it only to override detection (e.g. gbk, gb18030, cp936 maps to gbk)`,
   parameters: z.object({
-    file_path: z.string().describe("The absolute path to the file to read"),
+    file_path: z.string().describe(
+      "Absolute path to a text or text-decodable source file (not binary formats such as images, xlsx, or pdf)."
+    ),
     encoding: z.string().optional().describe(
       'Optional. Omit or use "auto" for automatic detection (default). Set only to force a specific encoding (utf8, gbk, gb18030, latin1, etc.; cp936 is treated as gbk).'
     ),
@@ -988,7 +1071,9 @@ var editTool = createTool({
 
 Usage:
 - You must use the Read tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file
+- Files at or above 1 GiB cannot be edited with this tool (use another workflow for huge files)
 - When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: line number + tab. Everything after that is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string
+- old_string may use \\n line breaks; CRLF files are matched and new_string is rewritten to the file's dominant line ending style (\\r\\n vs \\n)
 - ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required
 - Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked
 - The edit will FAIL if old_string is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use replace_all to change every instance of old_string
@@ -996,7 +1081,7 @@ Usage:
 - For non-UTF-8 files, set encoding to the same value you used with Read (default is utf8)`,
   parameters: z.object({
     file_path: z.string().describe("The absolute path to the file to modify"),
-    old_string: z.string().describe("The text to replace"),
+    old_string: z.string().min(1).describe("The text to replace (non-empty)"),
     new_string: z.string().describe("The text to replace it with (must be different from old_string)"),
     replace_all: z.boolean().default(false).describe("Replace all occurrences of old_string (default false)"),
     encoding: z.string().optional().describe(
@@ -1018,25 +1103,46 @@ Usage:
           isError: true
         };
       }
+      const fs = await import('fs/promises');
+      const stat = await fs.stat(file_path);
+      if (!stat.isFile()) {
+        return {
+          content: `Error: ${file_path} is not a file`,
+          isError: true
+        };
+      }
+      if (stat.size >= EDIT_MAX_FILE_BYTES) {
+        return {
+          content: `Error: file is too large to edit (${stat.size} bytes). Maximum size is ${EDIT_MAX_FILE_BYTES} bytes (1 GiB). Use a different tool or split the work.`,
+          isError: true
+        };
+      }
       const content = await readFileAsUnicodeString(file_path, normalized);
-      if (!content.includes(old_string)) {
+      const dominantEol = detectDominantEol(content);
+      const candidates = buildNeedleCandidates(old_string, dominantEol);
+      let needle = null;
+      for (const c of candidates) {
+        if (countOccurrences(content, c) > 0) {
+          needle = c;
+          break;
+        }
+      }
+      if (needle === null) {
         return {
           content: `old_string not found in ${file_path}`,
           isError: true
         };
       }
-      if (!replace_all) {
-        const occurrences2 = content.split(old_string).length - 1;
-        if (occurrences2 > 1) {
-          return {
-            content: `Found ${occurrences2} matches for old_string. Provide more context to make it unique, or set replace_all to true.`,
-            isError: true
-          };
-        }
+      const occurrences = countOccurrences(content, needle);
+      if (!replace_all && occurrences > 1) {
+        return {
+          content: `Found ${occurrences} matches for old_string. Provide more context to make it unique, or set replace_all to true.`,
+          isError: true
+        };
       }
-      const newContent = replace_all ? content.replaceAll(old_string, new_string) : content.replace(old_string, new_string);
+      const normalizedNew = normalizeNewStringEols(new_string, dominantEol);
+      const newContent = replaceNonOverlapping(content, needle, normalizedNew, replace_all);
       await writeFileFromUnicodeString(file_path, newContent, normalized);
-      const occurrences = replace_all ? content.split(old_string).length - 1 : 1;
       return {
         content: `Successfully edited ${file_path} (${occurrences} replacement${occurrences > 1 ? "s" : ""})`
       };
@@ -1118,6 +1224,53 @@ function findInPath(executable) {
     return null;
   }
 }
+function findGitBashNextToGitExe(gitExe) {
+  if (!existsSync(gitExe)) {
+    return null;
+  }
+  const dir = win32.dirname(gitExe);
+  const siblingBash = win32.join(dir, "bash.exe");
+  if (existsSync(siblingBash)) {
+    return siblingBash;
+  }
+  let walk = dir;
+  for (let i = 0; i < 4; i++) {
+    const bashPath = win32.join(walk, "bin", "bash.exe");
+    if (existsSync(bashPath)) {
+      return bashPath;
+    }
+    const parent = win32.dirname(walk);
+    if (parent === walk) {
+      break;
+    }
+    walk = parent;
+  }
+  return null;
+}
+function findBashViaGitInstall() {
+  const gitExe = findInPath("git");
+  if (!gitExe) {
+    return null;
+  }
+  return findGitBashNextToGitExe(gitExe);
+}
+function findGitBashInDefaultInstallDirs() {
+  const drives = ["C", "D", "E"];
+  const relatives = [
+    ["Program Files", "Git", "bin", "bash.exe"],
+    ["Program Files (x86)", "Git", "bin", "bash.exe"]
+  ];
+  for (const drive of drives) {
+    const root = `${drive}:\\`;
+    for (const parts of relatives) {
+      const p = win32.join(root, ...parts);
+      if (existsSync(p)) {
+        return p;
+      }
+    }
+  }
+  return null;
+}
 function getShellPath() {
   if (cachedShellPath !== null) {
     return cachedShellPath;
@@ -1128,15 +1281,15 @@ function getShellPath() {
       cachedShellPath = bashPath;
       return bashPath;
     }
-    const gitBashPaths = [
-      "C:\\Program Files\\Git\\bin\\bash.exe",
-      "C:\\Program Files (x86)\\Git\\bin\\bash.exe"
-    ];
-    for (const path of gitBashPaths) {
-      if (existsSync(path)) {
-        cachedShellPath = path;
-        return path;
-      }
+    const viaGit = findBashViaGitInstall();
+    if (viaGit) {
+      cachedShellPath = viaGit;
+      return viaGit;
+    }
+    const fromDirs = findGitBashInDefaultInstallDirs();
+    if (fromDirs) {
+      cachedShellPath = fromDirs;
+      return fromDirs;
     }
     const pwshPath = findInPath("pwsh");
     if (pwshPath) {
@@ -2704,5 +2857,5 @@ function createFunctionHook(config) {
 }
 
 export { DEFAULT_GREP_HEAD_LIMIT, FileStorageStrategy, HookManager, MAX_LINE_LENGTH2 as MAX_LINE_LENGTH, OUTPUT_CONFIG, OutputHandler, PaginationHintStrategy, SmartTruncateStrategy, ToolRegistry, agentTool, bashTool, buildHookEnv, createAgentTool, createAskUserQuestionTool, createFunctionHook, createOutputHandler, createSkillTool, createTool, editTool, formatAnswerSummary, formatAskUserQuestionPrompt, formatEnvironmentSection, getAllBuiltinTools, getEnvironmentInfo, getFileSystemTools, getGlobalRegistry, getGrepTools, getInteractionTools, getSafeBuiltinTools, getShellTools, getSkillTools, getSubagentTools, getTaskTools, getWebTools, globTool, grepTool, loadHooksSettingsFromProject, loadHooksSettingsFromUser, matchTool, mergeCommandHookLayers, parseHooksSettingsFile, questionTool, readFileTool, subagentRequestSchema, taskCreateTool, taskListTool, taskUpdateTool, truncateMatchLineForDisplay, webFetchTool, webSearchTool, writeFileTool };
-//# sourceMappingURL=chunk-OHXW2YM6.js.map
-//# sourceMappingURL=chunk-OHXW2YM6.js.map
+//# sourceMappingURL=chunk-THKEF32L.js.map
+//# sourceMappingURL=chunk-THKEF32L.js.map