@dexto/core 1.1.11 → 1.2.0

package/dist/tools/internal-tools/implementations/bash-exec-tool.cjs

@@ -0,0 +1,106 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bash_exec_tool_exports = {};
+__export(bash_exec_tool_exports, {
+  createBashExecTool: () => createBashExecTool
+});
+module.exports = __toCommonJS(bash_exec_tool_exports);
+var path = __toESM(require("node:path"), 1);
+var import_zod = require("zod");
+var import_types2 = require("../../../approval/types.js");
+var import_errors = require("../../../process/errors.js");
+const BashExecInputSchema = import_zod.z.object({
+  command: import_zod.z.string().describe("Shell command to execute"),
+  description: import_zod.z.string().optional().describe("Human-readable description of what the command does (5-10 words)"),
+  timeout: import_zod.z.number().int().positive().max(6e5).optional().default(12e4).describe(
+    "Timeout in milliseconds (max: 600000 = 10 minutes, default: 120000 = 2 minutes)"
+  ),
+  run_in_background: import_zod.z.boolean().optional().default(false).describe("Execute command in background (default: false)"),
+  cwd: import_zod.z.string().optional().describe("Working directory for command execution (optional)")
+}).strict();
+function createBashExecTool(processService, approvalManager) {
+  return {
+    id: "bash_exec",
+    description: "Execute a shell command. Returns stdout, stderr, exit code, and duration. Use run_in_background=true for long-running commands (use bash_output to retrieve results later). Requires approval for all commands. Dangerous commands (rm, git push, etc.) require additional per-command approval. Always quote file paths with spaces. Set timeout to prevent hanging commands. Security: dangerous commands are blocked, injection attempts are detected.",
+    inputSchema: BashExecInputSchema,
+    execute: async (input, context) => {
+      const { command, description, timeout, run_in_background, cwd } = input;
+      let validatedCwd = cwd;
+      if (cwd) {
+        const baseDir = processService.getConfig().workingDirectory || process.cwd();
+        const candidatePath = path.isAbsolute(cwd) ? path.resolve(cwd) : path.resolve(baseDir, cwd);
+        const relativePath = path.relative(baseDir, candidatePath);
+        const isOutsideBase = relativePath.startsWith("..") || path.isAbsolute(relativePath);
+        if (isOutsideBase) {
+          throw import_errors.ProcessError.invalidWorkingDirectory(
+            cwd,
+            `Working directory must be within ${baseDir}`
+          );
+        }
+        validatedCwd = candidatePath;
+      }
+      const result = await processService.executeCommand(command, {
+        description,
+        timeout,
+        runInBackground: run_in_background,
+        cwd: validatedCwd,
+        // Provide approval function for dangerous commands
+        approvalFunction: async (normalizedCommand) => {
+          const metadata = {
+            toolName: "bash_exec",
+            command: normalizedCommand,
+            originalCommand: command
+          };
+          if (context?.sessionId) {
+            metadata.sessionId = context.sessionId;
+          }
+          const response = await approvalManager.requestCommandConfirmation(metadata);
+          return response.status === import_types2.ApprovalStatus.APPROVED;
+        }
+      });
+      if ("stdout" in result) {
+        return {
+          stdout: result.stdout,
+          stderr: result.stderr,
+          exit_code: result.exitCode,
+          duration: result.duration
+        };
+      } else {
+        return {
+          process_id: result.processId,
+          message: `Command started in background with ID: ${result.processId}. Use bash_output to retrieve output.`
+        };
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBashExecTool
+});

package/dist/tools/internal-tools/implementations/bash-exec-tool.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Bash Execute Tool
+ *
+ * Internal tool for executing shell commands (requires approval)
+ */
+import { InternalTool } from '../../types.js';
+import { ProcessService } from '../../../process/index.js';
+import type { ApprovalManager } from '../../../approval/manager.js';
+/**
+ * Create the bash_exec internal tool
+ */
+export declare function createBashExecTool(processService: ProcessService, approvalManager: ApprovalManager): InternalTool;
+//# sourceMappingURL=bash-exec-tool.d.ts.map

package/dist/tools/internal-tools/implementations/bash-exec-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash-exec-tool.d.ts","sourceRoot":"","sources":["../../../../src/tools/internal-tools/implementations/bash-exec-tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,YAAY,EAAwB,MAAM,gBAAgB,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAgCpE;;GAEG;AACH,wBAAgB,kBAAkB,CAC9B,cAAc,EAAE,cAAc,EAC9B,eAAe,EAAE,eAAe,GACjC,YAAY,CAoFd"}

package/dist/tools/internal-tools/implementations/bash-exec-tool.js

@@ -0,0 +1,73 @@
+import "../../../chunk-C6A6W6XS.js";
+import * as path from "node:path";
+import { z } from "zod";
+import { ApprovalStatus } from "../../../approval/types.js";
+import { ProcessError } from "../../../process/errors.js";
+const BashExecInputSchema = z.object({
+  command: z.string().describe("Shell command to execute"),
+  description: z.string().optional().describe("Human-readable description of what the command does (5-10 words)"),
+  timeout: z.number().int().positive().max(6e5).optional().default(12e4).describe(
+    "Timeout in milliseconds (max: 600000 = 10 minutes, default: 120000 = 2 minutes)"
+  ),
+  run_in_background: z.boolean().optional().default(false).describe("Execute command in background (default: false)"),
+  cwd: z.string().optional().describe("Working directory for command execution (optional)")
+}).strict();
+function createBashExecTool(processService, approvalManager) {
+  return {
+    id: "bash_exec",
+    description: "Execute a shell command. Returns stdout, stderr, exit code, and duration. Use run_in_background=true for long-running commands (use bash_output to retrieve results later). Requires approval for all commands. Dangerous commands (rm, git push, etc.) require additional per-command approval. Always quote file paths with spaces. Set timeout to prevent hanging commands. Security: dangerous commands are blocked, injection attempts are detected.",
+    inputSchema: BashExecInputSchema,
+    execute: async (input, context) => {
+      const { command, description, timeout, run_in_background, cwd } = input;
+      let validatedCwd = cwd;
+      if (cwd) {
+        const baseDir = processService.getConfig().workingDirectory || process.cwd();
+        const candidatePath = path.isAbsolute(cwd) ? path.resolve(cwd) : path.resolve(baseDir, cwd);
+        const relativePath = path.relative(baseDir, candidatePath);
+        const isOutsideBase = relativePath.startsWith("..") || path.isAbsolute(relativePath);
+        if (isOutsideBase) {
+          throw ProcessError.invalidWorkingDirectory(
+            cwd,
+            `Working directory must be within ${baseDir}`
+          );
+        }
+        validatedCwd = candidatePath;
+      }
+      const result = await processService.executeCommand(command, {
+        description,
+        timeout,
+        runInBackground: run_in_background,
+        cwd: validatedCwd,
+        // Provide approval function for dangerous commands
+        approvalFunction: async (normalizedCommand) => {
+          const metadata = {
+            toolName: "bash_exec",
+            command: normalizedCommand,
+            originalCommand: command
+          };
+          if (context?.sessionId) {
+            metadata.sessionId = context.sessionId;
+          }
+          const response = await approvalManager.requestCommandConfirmation(metadata);
+          return response.status === ApprovalStatus.APPROVED;
+        }
+      });
+      if ("stdout" in result) {
+        return {
+          stdout: result.stdout,
+          stderr: result.stderr,
+          exit_code: result.exitCode,
+          duration: result.duration
+        };
+      } else {
+        return {
+          process_id: result.processId,
+          message: `Command started in background with ID: ${result.processId}. Use bash_output to retrieve output.`
+        };
+      }
+    }
+  };
+}
+export {
+  createBashExecTool
+};

package/dist/tools/internal-tools/implementations/bash-output-tool.cjs

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bash_output_tool_exports = {};
+__export(bash_output_tool_exports, {
+  createBashOutputTool: () => createBashOutputTool
+});
+module.exports = __toCommonJS(bash_output_tool_exports);
+var import_zod = require("zod");
+const BashOutputInputSchema = import_zod.z.object({
+  process_id: import_zod.z.string().describe("Process ID from bash_exec (when run_in_background=true)")
+}).strict();
+function createBashOutputTool(processService) {
+  return {
+    id: "bash_output",
+    description: "Retrieve output from a background process started with bash_exec. Returns stdout, stderr, status (running/completed/failed), exit code, and duration. Each call returns only new output since last read. The output buffer is cleared after reading. Use this tool to monitor long-running commands.",
+    inputSchema: BashOutputInputSchema,
+    execute: async (input, _context) => {
+      const { process_id } = input;
+      const result = await processService.getProcessOutput(process_id);
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        status: result.status,
+        ...result.exitCode !== void 0 && { exit_code: result.exitCode },
+        ...result.duration !== void 0 && { duration: result.duration }
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBashOutputTool
+});

package/dist/tools/internal-tools/implementations/bash-output-tool.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Bash Output Tool
+ *
+ * Internal tool for retrieving output from background processes
+ */
+import { InternalTool } from '../../types.js';
+import { ProcessService } from '../../../process/index.js';
+/**
+ * Create the bash_output internal tool
+ */
+export declare function createBashOutputTool(processService: ProcessService): InternalTool;
+//# sourceMappingURL=bash-output-tool.d.ts.map

package/dist/tools/internal-tools/implementations/bash-output-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash-output-tool.d.ts","sourceRoot":"","sources":["../../../../src/tools/internal-tools/implementations/bash-output-tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,YAAY,EAAwB,MAAM,gBAAgB,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAU3D;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,cAAc,GAAG,YAAY,CAsBjF"}

package/dist/tools/internal-tools/implementations/bash-output-tool.js

@@ -0,0 +1,26 @@
+import "../../../chunk-C6A6W6XS.js";
+import { z } from "zod";
+const BashOutputInputSchema = z.object({
+  process_id: z.string().describe("Process ID from bash_exec (when run_in_background=true)")
+}).strict();
+function createBashOutputTool(processService) {
+  return {
+    id: "bash_output",
+    description: "Retrieve output from a background process started with bash_exec. Returns stdout, stderr, status (running/completed/failed), exit code, and duration. Each call returns only new output since last read. The output buffer is cleared after reading. Use this tool to monitor long-running commands.",
+    inputSchema: BashOutputInputSchema,
+    execute: async (input, _context) => {
+      const { process_id } = input;
+      const result = await processService.getProcessOutput(process_id);
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        status: result.status,
+        ...result.exitCode !== void 0 && { exit_code: result.exitCode },
+        ...result.duration !== void 0 && { duration: result.duration }
+      };
+    }
+  };
+}
+export {
+  createBashOutputTool
+};

package/dist/tools/internal-tools/implementations/edit-file-tool.cjs

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var edit_file_tool_exports = {};
+__export(edit_file_tool_exports, {
+  createEditFileTool: () => createEditFileTool
+});
+module.exports = __toCommonJS(edit_file_tool_exports);
+var import_zod = require("zod");
+const EditFileInputSchema = import_zod.z.object({
+  file_path: import_zod.z.string().describe("Absolute path to the file to edit"),
+  old_string: import_zod.z.string().describe("Text to replace (must be unique unless replace_all is true)"),
+  new_string: import_zod.z.string().describe("Replacement text"),
+  replace_all: import_zod.z.boolean().optional().default(false).describe("Replace all occurrences (default: false, requires unique match)")
+}).strict();
+function createEditFileTool(fileSystemService) {
+  return {
+    id: "edit_file",
+    description: "Edit a file by replacing text. By default, old_string must be unique in the file (will error if found multiple times). Set replace_all=true to replace all occurrences. Automatically creates backup before editing. Requires approval. Returns success status, path, number of changes made, and backup path.",
+    inputSchema: EditFileInputSchema,
+    execute: async (input, _context) => {
+      const { file_path, old_string, new_string, replace_all } = input;
+      const result = await fileSystemService.editFile(
+        file_path,
+        {
+          oldString: old_string,
+          newString: new_string,
+          replaceAll: replace_all
+        },
+        {
+          backup: true
+          // Always create backup for internal tools
+        }
+      );
+      return {
+        success: result.success,
+        path: result.path,
+        changes_count: result.changesCount,
+        ...result.backupPath && { backup_path: result.backupPath }
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEditFileTool
+});

package/dist/tools/internal-tools/implementations/edit-file-tool.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Edit File Tool
+ *
+ * Internal tool for editing files by replacing text (requires approval)
+ */
+import { InternalTool } from '../../types.js';
+import { FileSystemService } from '../../../filesystem/index.js';
+/**
+ * Create the edit_file internal tool
+ */
+export declare function createEditFileTool(fileSystemService: FileSystemService): InternalTool;
+//# sourceMappingURL=edit-file-tool.d.ts.map

package/dist/tools/internal-tools/implementations/edit-file-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-file-tool.d.ts","sourceRoot":"","sources":["../../../../src/tools/internal-tools/implementations/edit-file-tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,YAAY,EAAwB,MAAM,gBAAgB,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAmBjE;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,iBAAiB,EAAE,iBAAiB,GAAG,YAAY,CA+BrF"}

package/dist/tools/internal-tools/implementations/edit-file-tool.js

@@ -0,0 +1,39 @@
+import "../../../chunk-C6A6W6XS.js";
+import { z } from "zod";
+const EditFileInputSchema = z.object({
+  file_path: z.string().describe("Absolute path to the file to edit"),
+  old_string: z.string().describe("Text to replace (must be unique unless replace_all is true)"),
+  new_string: z.string().describe("Replacement text"),
+  replace_all: z.boolean().optional().default(false).describe("Replace all occurrences (default: false, requires unique match)")
+}).strict();
+function createEditFileTool(fileSystemService) {
+  return {
+    id: "edit_file",
+    description: "Edit a file by replacing text. By default, old_string must be unique in the file (will error if found multiple times). Set replace_all=true to replace all occurrences. Automatically creates backup before editing. Requires approval. Returns success status, path, number of changes made, and backup path.",
+    inputSchema: EditFileInputSchema,
+    execute: async (input, _context) => {
+      const { file_path, old_string, new_string, replace_all } = input;
+      const result = await fileSystemService.editFile(
+        file_path,
+        {
+          oldString: old_string,
+          newString: new_string,
+          replaceAll: replace_all
+        },
+        {
+          backup: true
+          // Always create backup for internal tools
+        }
+      );
+      return {
+        success: result.success,
+        path: result.path,
+        changes_count: result.changesCount,
+        ...result.backupPath && { backup_path: result.backupPath }
+      };
+    }
+  };
+}
+export {
+  createEditFileTool
+};

package/dist/tools/internal-tools/implementations/glob-files-tool.cjs

@@ -0,0 +1,57 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var glob_files_tool_exports = {};
+__export(glob_files_tool_exports, {
+  createGlobFilesTool: () => createGlobFilesTool
+});
+module.exports = __toCommonJS(glob_files_tool_exports);
+var import_zod = require("zod");
+const GlobFilesInputSchema = import_zod.z.object({
+  pattern: import_zod.z.string().describe('Glob pattern to match files (e.g., "**/*.ts", "src/**/*.js")'),
+  path: import_zod.z.string().optional().describe("Base directory to search from (defaults to working directory)"),
+  max_results: import_zod.z.number().int().positive().optional().default(1e3).describe("Maximum number of results to return (default: 1000)")
+}).strict();
+function createGlobFilesTool(fileSystemService) {
+  return {
+    id: "glob_files",
+    description: "Find files matching a glob pattern. Supports standard glob syntax like **/*.js for recursive matches, *.ts for files in current directory, and src/**/*.tsx for nested paths. Returns array of file paths with metadata (size, modified date). Results are limited to allowed paths only.",
+    inputSchema: GlobFilesInputSchema,
+    execute: async (input, _context) => {
+      const { pattern, path, max_results } = input;
+      const result = await fileSystemService.globFiles(pattern, {
+        cwd: path,
+        maxResults: max_results,
+        includeMetadata: true
+      });
+      return {
+        files: result.files.map((file) => ({
+          path: file.path,
+          size: file.size,
+          modified: file.modified.toISOString()
+        })),
+        total_found: result.totalFound,
+        truncated: result.truncated
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createGlobFilesTool
+});

package/dist/tools/internal-tools/implementations/glob-files-tool.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Glob Files Tool
+ *
+ * Internal tool for finding files using glob patterns
+ */
+import { InternalTool } from '../../types.js';
+import { FileSystemService } from '../../../filesystem/index.js';
+/**
+ * Create the glob_files internal tool
+ */
+export declare function createGlobFilesTool(fileSystemService: FileSystemService): InternalTool;
+//# sourceMappingURL=glob-files-tool.d.ts.map

package/dist/tools/internal-tools/implementations/glob-files-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob-files-tool.d.ts","sourceRoot":"","sources":["../../../../src/tools/internal-tools/implementations/glob-files-tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,YAAY,EAAwB,MAAM,gBAAgB,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAuBjE;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,iBAAiB,EAAE,iBAAiB,GAAG,YAAY,CA4BtF"}

package/dist/tools/internal-tools/implementations/glob-files-tool.js

@@ -0,0 +1,34 @@
+import "../../../chunk-C6A6W6XS.js";
+import { z } from "zod";
+const GlobFilesInputSchema = z.object({
+  pattern: z.string().describe('Glob pattern to match files (e.g., "**/*.ts", "src/**/*.js")'),
+  path: z.string().optional().describe("Base directory to search from (defaults to working directory)"),
+  max_results: z.number().int().positive().optional().default(1e3).describe("Maximum number of results to return (default: 1000)")
+}).strict();
+function createGlobFilesTool(fileSystemService) {
+  return {
+    id: "glob_files",
+    description: "Find files matching a glob pattern. Supports standard glob syntax like **/*.js for recursive matches, *.ts for files in current directory, and src/**/*.tsx for nested paths. Returns array of file paths with metadata (size, modified date). Results are limited to allowed paths only.",
+    inputSchema: GlobFilesInputSchema,
+    execute: async (input, _context) => {
+      const { pattern, path, max_results } = input;
+      const result = await fileSystemService.globFiles(pattern, {
+        cwd: path,
+        maxResults: max_results,
+        includeMetadata: true
+      });
+      return {
+        files: result.files.map((file) => ({
+          path: file.path,
+          size: file.size,
+          modified: file.modified.toISOString()
+        })),
+        total_found: result.totalFound,
+        truncated: result.truncated
+      };
+    }
+  };
+}
+export {
+  createGlobFilesTool
+};

package/dist/tools/internal-tools/implementations/grep-content-tool.cjs

@@ -0,0 +1,71 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var grep_content_tool_exports = {};
+__export(grep_content_tool_exports, {
+  createGrepContentTool: () => createGrepContentTool
+});
+module.exports = __toCommonJS(grep_content_tool_exports);
+var import_zod = require("zod");
+const GrepContentInputSchema = import_zod.z.object({
+  pattern: import_zod.z.string().describe("Regular expression pattern to search for"),
+  path: import_zod.z.string().optional().describe("Directory to search in (defaults to working directory)"),
+  glob: import_zod.z.string().optional().describe('Glob pattern to filter files (e.g., "*.ts", "**/*.js")'),
+  context_lines: import_zod.z.number().int().min(0).optional().default(0).describe(
+    "Number of context lines to include before and after each match (default: 0)"
+  ),
+  case_insensitive: import_zod.z.boolean().optional().default(false).describe("Perform case-insensitive search (default: false)"),
+  max_results: import_zod.z.number().int().positive().optional().default(100).describe("Maximum number of results to return (default: 100)")
+}).strict();
+function createGrepContentTool(fileSystemService) {
+  return {
+    id: "grep_content",
+    description: 'Search for text patterns in files using regular expressions. Returns matching lines with file path, line number, and optional context lines. Use glob parameter to filter specific file types (e.g., "*.ts"). Supports case-insensitive search. Great for finding code patterns, function definitions, or specific text across multiple files.',
+    inputSchema: GrepContentInputSchema,
+    execute: async (input, _context) => {
+      const { pattern, path, glob, context_lines, case_insensitive, max_results } = input;
+      const result = await fileSystemService.searchContent(pattern, {
+        path,
+        glob,
+        contextLines: context_lines,
+        caseInsensitive: case_insensitive,
+        maxResults: max_results
+      });
+      return {
+        matches: result.matches.map((match) => ({
+          file: match.file,
+          line_number: match.lineNumber,
+          line: match.line,
+          ...match.context && {
+            context: {
+              before: match.context.before,
+              after: match.context.after
+            }
+          }
+        })),
+        total_matches: result.totalMatches,
+        files_searched: result.filesSearched,
+        truncated: result.truncated
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createGrepContentTool
+});

package/dist/tools/internal-tools/implementations/grep-content-tool.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Grep Content Tool
+ *
+ * Internal tool for searching file contents using regex patterns
+ */
+import { InternalTool } from '../../types.js';
+import { FileSystemService } from '../../../filesystem/index.js';
+/**
+ * Create the grep_content internal tool
+ */
+export declare function createGrepContentTool(fileSystemService: FileSystemService): InternalTool;
+//# sourceMappingURL=grep-content-tool.d.ts.map

package/dist/tools/internal-tools/implementations/grep-content-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grep-content-tool.d.ts","sourceRoot":"","sources":["../../../../src/tools/internal-tools/implementations/grep-content-tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,YAAY,EAAwB,MAAM,gBAAgB,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAuCjE;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,iBAAiB,EAAE,iBAAiB,GAAG,YAAY,CAsCxF"}

package/dist/tools/internal-tools/implementations/grep-content-tool.js

@@ -0,0 +1,48 @@
+import "../../../chunk-C6A6W6XS.js";
+import { z } from "zod";
+const GrepContentInputSchema = z.object({
+  pattern: z.string().describe("Regular expression pattern to search for"),
+  path: z.string().optional().describe("Directory to search in (defaults to working directory)"),
+  glob: z.string().optional().describe('Glob pattern to filter files (e.g., "*.ts", "**/*.js")'),
+  context_lines: z.number().int().min(0).optional().default(0).describe(
+    "Number of context lines to include before and after each match (default: 0)"
+  ),
+  case_insensitive: z.boolean().optional().default(false).describe("Perform case-insensitive search (default: false)"),
+  max_results: z.number().int().positive().optional().default(100).describe("Maximum number of results to return (default: 100)")
+}).strict();
+function createGrepContentTool(fileSystemService) {
+  return {
+    id: "grep_content",
+    description: 'Search for text patterns in files using regular expressions. Returns matching lines with file path, line number, and optional context lines. Use glob parameter to filter specific file types (e.g., "*.ts"). Supports case-insensitive search. Great for finding code patterns, function definitions, or specific text across multiple files.',
+    inputSchema: GrepContentInputSchema,
+    execute: async (input, _context) => {
+      const { pattern, path, glob, context_lines, case_insensitive, max_results } = input;
+      const result = await fileSystemService.searchContent(pattern, {
+        path,
+        glob,
+        contextLines: context_lines,
+        caseInsensitive: case_insensitive,
+        maxResults: max_results
+      });
+      return {
+        matches: result.matches.map((match) => ({
+          file: match.file,
+          line_number: match.lineNumber,
+          line: match.line,
+          ...match.context && {
+            context: {
+              before: match.context.before,
+              after: match.context.after
+            }
+          }
+        })),
+        total_matches: result.totalMatches,
+        files_searched: result.filesSearched,
+        truncated: result.truncated
+      };
+    }
+  };
+}
+export {
+  createGrepContentTool
+};