@perstack/base 0.0.21 → 0.0.22

package/dist/chunk-CDWG4Z4N.js

@@ -0,0 +1,1125 @@
+import { realpathSync, existsSync, statSync } from 'fs';
+import fs, { appendFile, mkdir, rm, rmdir, unlink, readFile, writeFile, readdir, rename, stat } from 'fs/promises';
+import { dedent } from 'ts-dedent';
+import { z } from 'zod';
+import os from 'os';
+import path, { dirname, extname, basename, resolve, join } from 'path';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import mime from 'mime-types';
+
+// src/tools/append-text-file.ts
+var workspacePath = realpathSync(expandHome(process.cwd()));
+function expandHome(filepath) {
+  if (filepath.startsWith("~/") || filepath === "~") {
+    return path.join(os.homedir(), filepath.slice(1));
+  }
+  return filepath;
+}
+async function validatePath(requestedPath) {
+  const expandedPath = expandHome(requestedPath);
+  const absolute = path.isAbsolute(expandedPath) ? path.resolve(expandedPath) : path.resolve(process.cwd(), expandedPath);
+  if (absolute === `${workspacePath}/perstack`) {
+    throw new Error("Access denied - perstack directory is not allowed");
+  }
+  try {
+    const realAbsolute = await fs.realpath(absolute);
+    if (!realAbsolute.startsWith(workspacePath)) {
+      throw new Error("Access denied - symlink target outside allowed directories");
+    }
+    return realAbsolute;
+  } catch (error) {
+    const parentDir = path.dirname(absolute);
+    try {
+      const realParentPath = await fs.realpath(parentDir);
+      if (!realParentPath.startsWith(workspacePath)) {
+        throw new Error("Access denied - parent directory outside allowed directories");
+      }
+      return absolute;
+    } catch {
+      if (!absolute.startsWith(workspacePath)) {
+        throw new Error(
+          `Access denied - path outside allowed directories: ${absolute} not in ${workspacePath}`
+        );
+      }
+      throw new Error(`Parent directory does not exist: ${parentDir}`);
+    }
+  }
+}
+
+// src/lib/tool-result.ts
+function successToolResult(result) {
+  return { content: [{ type: "text", text: JSON.stringify(result) }] };
+}
+function errorToolResult(e) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: e.name, message: e.message }) }]
+  };
+}
+
+// src/tools/append-text-file.ts
+var inputSchema = z.object({
+  path: z.string().describe("Target file path to append to."),
+  text: z.string().min(1).max(2e3).describe("Text to append to the file. Max 2000 characters.")
+});
+async function appendTextFile(input) {
+  const { path: path2, text } = input;
+  const validatedPath = await validatePath(path2);
+  if (!existsSync(validatedPath)) {
+    throw new Error(`File ${path2} does not exist.`);
+  }
+  const stats = statSync(validatedPath);
+  if (!(stats.mode & 128)) {
+    throw new Error(`File ${path2} is not writable`);
+  }
+  await appendFile(validatedPath, text);
+  return { path: validatedPath, text };
+}
+function registerAppendTextFile(server) {
+  server.registerTool(
+    "appendTextFile",
+    {
+      title: "Append text file",
+      description: dedent`
+      Adding content to the end of existing files.
+
+      Use cases:
+      - Adding entries to log files
+      - Appending data to CSV or JSON files
+      - Adding new sections to documentation
+      - Extending configuration files
+      - Building files incrementally
+
+      How it works:
+      - Appends text to the end of an existing file
+      - Does not modify existing content
+      - Creates a new line before appending if needed
+      - Returns the appended file path
+
+      Rules:
+      - FILE MUST EXIST BEFORE APPENDING
+      - YOU MUST PROVIDE A VALID UTF-8 STRING FOR THE TEXT
+      - THERE IS A LIMIT ON THE NUMBER OF TOKENS THAT CAN BE GENERATED, SO DO NOT APPEND ALL THE CONTENT AT ONCE
+      - IF YOU WANT TO APPEND MORE THAN 2000 CHARACTERS, USE THIS TOOL MULTIPLE TIMES
+    `,
+      inputSchema: inputSchema.shape
+    },
+    async (input) => {
+      try {
+        return successToolResult(await appendTextFile(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var inputSchema2 = z.object({});
+async function attemptCompletion(_input) {
+  return {
+    message: "End the agent loop and provide a final report"
+  };
+}
+function registerAttemptCompletion(server) {
+  server.registerTool(
+    "attemptCompletion",
+    {
+      title: "Attempt completion",
+      description: dedent`
+      Task completion signal that triggers immediate final report generation.
+      Use cases:
+      - Signaling task completion to Perstack runtime
+      - Triggering final report generation
+      - Ending the current expert's work cycle
+      How it works:
+      - Sends completion signal to Perstack runtime
+      - Runtime immediately proceeds to final report generation
+      - No confirmation or approval step required
+      - No parameters needed for this signal
+      Notes:
+      - Triggers immediate transition to final report
+      - Should only be used when task is fully complete
+      - Cannot be reverted once called
+    `,
+      inputSchema: inputSchema2.shape
+    },
+    async (input) => {
+      try {
+        return successToolResult(await attemptCompletion(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var inputSchema3 = z.object({
+  path: z.string()
+});
+async function createDirectory(input) {
+  const { path: path2 } = input;
+  const validatedPath = await validatePath(path2);
+  const exists = existsSync(validatedPath);
+  if (exists) {
+    throw new Error(`Directory ${path2} already exists`);
+  }
+  const parentDir = dirname(validatedPath);
+  if (existsSync(parentDir)) {
+    const parentStats = statSync(parentDir);
+    if (!(parentStats.mode & 128)) {
+      throw new Error(`Parent directory ${parentDir} is not writable`);
+    }
+  }
+  await mkdir(validatedPath, { recursive: true });
+  return {
+    path: validatedPath
+  };
+}
+function registerCreateDirectory(server) {
+  server.registerTool(
+    "createDirectory",
+    {
+      title: "Create directory",
+      description: dedent`
+        Directory creator for establishing folder structures in the workspace.
+
+        Use cases:
+        - Setting up project directory structure
+        - Creating output folders for generated content
+        - Organizing files into logical groups
+        - Preparing directory hierarchies
+
+        How it works:
+        - Creates directories recursively
+        - Handles existing directories gracefully
+        - Creates parent directories as needed
+        - Returns creation status
+        
+        Parameters:
+        - path: Directory path to create
+      `,
+      inputSchema: inputSchema3.shape
+    },
+    async (input) => {
+      try {
+        return successToolResult(await createDirectory(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var inputSchema4 = z.object({
+  path: z.string(),
+  recursive: z.boolean().optional().describe("Whether to delete contents recursively. Required for non-empty directories.")
+});
+async function deleteDirectory(input) {
+  const { path: path2, recursive } = input;
+  const validatedPath = await validatePath(path2);
+  if (!existsSync(validatedPath)) {
+    throw new Error(`Directory ${path2} does not exist.`);
+  }
+  const stats = statSync(validatedPath);
+  if (!stats.isDirectory()) {
+    throw new Error(`Path ${path2} is not a directory. Use deleteFile tool instead.`);
+  }
+  if (!(stats.mode & 128)) {
+    throw new Error(`Directory ${path2} is not writable`);
+  }
+  if (recursive) {
+    await rm(validatedPath, { recursive: true });
+  } else {
+    await rmdir(validatedPath);
+  }
+  return {
+    path: validatedPath
+  };
+}
+function registerDeleteDirectory(server) {
+  server.registerTool(
+    "deleteDirectory",
+    {
+      title: "Delete directory",
+      description: dedent`
+        Directory deleter for removing directories from the workspace.
+
+        Use cases:
+        - Removing temporary directories
+        - Cleaning up build artifacts
+        - Deleting empty directories after moving files
+
+        How it works:
+        - Validates directory existence and permissions
+        - Removes directory (and contents if recursive is true)
+        - Returns deletion status
+
+        Parameters:
+        - path: Directory path to delete
+        - recursive: Set to true to delete non-empty directories
+      `,
+      inputSchema: inputSchema4.shape
+    },
+    async (input) => {
+      try {
+        return successToolResult(await deleteDirectory(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var inputSchema5 = z.object({
+  path: z.string()
+});
+async function deleteFile(input) {
+  const { path: path2 } = input;
+  const validatedPath = await validatePath(path2);
+  if (!existsSync(validatedPath)) {
+    throw new Error(`File ${path2} does not exist.`);
+  }
+  const stats = statSync(validatedPath);
+  if (stats.isDirectory()) {
+    throw new Error(`Path ${path2} is a directory. Use delete directory tool instead.`);
+  }
+  if (!(stats.mode & 128)) {
+    throw new Error(`File ${path2} is not writable`);
+  }
+  await unlink(validatedPath);
+  return {
+    path: validatedPath
+  };
+}
+function registerDeleteFile(server) {
+  server.registerTool(
+    "deleteFile",
+    {
+      title: "Delete file",
+      description: dedent`
+        File deleter for removing files from the workspace.
+
+        Use cases:
+        - Removing temporary files
+        - Cleaning up generated files
+        - Deleting outdated configuration files
+        - Removing unwanted artifacts
+
+        How it works:
+        - Validates file existence and permissions
+        - Performs atomic delete operation
+        - Returns deletion status
+        
+        Parameters:
+        - path: File path to delete
+      `,
+      inputSchema: inputSchema5.shape
+    },
+    async (input) => {
+      try {
+        return successToolResult(await deleteFile(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var inputSchema6 = z.object({
+  path: z.string().describe("Target file path to edit."),
+  newText: z.string().min(1).max(2e3).describe("Text to append to the file. Max 2000 characters."),
+  oldText: z.string().min(1).max(2e3).describe("Exact text to find and replace. Max 2000 characters.")
+});
+async function editTextFile(input) {
+  const { path: path2, newText, oldText } = input;
+  const validatedPath = await validatePath(path2);
+  if (!existsSync(validatedPath)) {
+    throw new Error(`File ${path2} does not exist.`);
+  }
+  const stats = statSync(validatedPath);
+  if (!(stats.mode & 128)) {
+    throw new Error(`File ${path2} is not writable`);
+  }
+  await applyFileEdit(validatedPath, newText, oldText);
+  return {
+    path: validatedPath,
+    newText,
+    oldText
+  };
+}
+function normalizeLineEndings(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+async function applyFileEdit(filePath, newText, oldText) {
+  const content = normalizeLineEndings(await readFile(filePath, "utf-8"));
+  const normalizedOld = normalizeLineEndings(oldText);
+  const normalizedNew = normalizeLineEndings(newText);
+  if (!content.includes(normalizedOld)) {
+    throw new Error(`Could not find exact match for oldText in file ${filePath}`);
+  }
+  const modifiedContent = content.replace(normalizedOld, normalizedNew);
+  await writeFile(filePath, modifiedContent, "utf-8");
+}
+function registerEditTextFile(server) {
+  server.registerTool(
+    "editTextFile",
+    {
+      title: "Edit text file",
+      description: dedent`
+        Text file editor for modifying existing files with precise text replacement.
+
+        Use cases:
+        - Updating configuration values
+        - Modifying code snippets
+        - Replacing specific text blocks
+        - Making targeted edits to files
+
+        How it works:
+        - Reads existing file content
+        - Performs exact text replacement of oldText with newText
+        - Normalizes line endings for consistent behavior
+        - Returns summary of changes made
+        - For appending text to files, use the appendTextFile tool instead
+        
+        Rules:
+        - YOU MUST PROVIDE A VALID UTF-8 STRING FOR THE TEXT
+        - THERE IS A LIMIT ON THE NUMBER OF TOKENS THAT CAN BE GENERATED, SO DO NOT WRITE ALL THE CONTENT AT ONCE (IT WILL CAUSE AN ERROR)
+        - IF YOU WANT TO EDIT MORE THAN 2000 CHARACTERS, USE THIS TOOL MULTIPLE TIMES
+        - DO NOT USE THIS TOOL FOR APPENDING TEXT TO FILES - USE appendTextFile TOOL INSTEAD
+      `,
+      inputSchema: inputSchema6.shape
+    },
+    async (input) => {
+      try {
+        return successToolResult(await editTextFile(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var execFileAsync = promisify(execFile);
+var inputSchema7 = z.object({
+  command: z.string().describe("The command to execute"),
+  args: z.array(z.string()).describe("The arguments to pass to the command"),
+  env: z.record(z.string(), z.string()).describe("The environment variables to set"),
+  cwd: z.string().describe("The working directory to execute the command in"),
+  stdout: z.boolean().describe("Whether to capture the standard output"),
+  stderr: z.boolean().describe("Whether to capture the standard error"),
+  timeout: z.number().optional().describe("Timeout in milliseconds")
+});
+async function exec(input) {
+  const validatedCwd = await validatePath(input.cwd);
+  const { stdout, stderr } = await execFileAsync(input.command, input.args, {
+    cwd: validatedCwd,
+    env: { ...process.env, ...input.env },
+    timeout: input.timeout
+  });
+  let output = "";
+  if (input.stdout) {
+    output += stdout;
+  }
+  if (input.stderr) {
+    output += stderr;
+  }
+  if (!output.trim()) {
+    output = "Command executed successfully, but produced no output.";
+  }
+  return { output };
+}
+function registerExec(server) {
+  server.registerTool(
+    "exec",
+    {
+      title: "Execute Command",
+      description: dedent`
+        Command executor for running system commands and scripts.
+
+        Use cases:
+        - Running system tasks or scripts
+        - Automating command-line tools or utilities
+        - Executing build commands or test runners
+
+        How it works:
+        - Executes the specified command with arguments
+        - Captures stdout and/or stderr based on flags
+        - Returns command output or error information
+
+        Parameters:
+        - command: The command to execute (e.g., ls, python)
+        - args: Arguments to pass to the command
+        - env: Environment variables for the execution
+        - cwd: Working directory for command execution
+        - stdout: Whether to capture standard output
+        - stderr: Whether to capture standard error
+        - timeout: Timeout in milliseconds (optional)
+
+        Rules:
+        - Only execute commands from trusted sources
+        - Do not execute long-running foreground commands (e.g., tail -f)
+        - Be cautious with resource-intensive commands
+      `,
+      inputSchema: inputSchema7.shape
+    },
+    async (input) => {
+      try {
+        return successToolResult(await exec(input));
+      } catch (error) {
+        const execError = error;
+        let message = "";
+        if (execError && (execError.killed || execError.signal === "SIGTERM") && typeof input.timeout === "number") {
+          message = `Command timed out after ${input.timeout}ms.`;
+        } else if (error instanceof Error) {
+          if (error.message.includes("timeout")) {
+            message = `Command timed out after ${input.timeout}ms.`;
+          } else {
+            message = error.message;
+          }
+        } else {
+          message = "An unknown error occurred.";
+        }
+        const result = { error: message };
+        if (execError.stdout && input.stdout) {
+          result.stdout = execError.stdout;
+        }
+        if (execError.stderr && input.stderr) {
+          result.stderr = execError.stderr;
+        }
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      }
+    }
+  );
+}
+var inputSchema8 = z.object({
+  path: z.string()
+});
+async function getFileInfo(input) {
+  const { path: path2 } = input;
+  const validatedPath = await validatePath(path2);
+  if (!existsSync(validatedPath)) {
+    throw new Error(`File or directory ${path2} does not exist`);
+  }
+  const stats = statSync(validatedPath);
+  const isDirectory = stats.isDirectory();
+  const mimeType = isDirectory ? null : mime.lookup(validatedPath) || "application/octet-stream";
+  const formatSize = (bytes) => {
+    if (bytes === 0) return "0 B";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return `${(bytes / 1024 ** i).toFixed(2)} ${units[i]}`;
+  };
+  return {
+    exists: true,
+    path: validatedPath,
+    absolutePath: resolve(validatedPath),
+    name: basename(validatedPath),
+    directory: dirname(validatedPath),
+    extension: isDirectory ? null : extname(validatedPath),
+    type: isDirectory ? "directory" : "file",
+    mimeType,
+    size: stats.size,
+    sizeFormatted: formatSize(stats.size),
+    created: stats.birthtime.toISOString(),
+    modified: stats.mtime.toISOString(),
+    accessed: stats.atime.toISOString(),
+    permissions: {
+      readable: true,
+      writable: Boolean(stats.mode & 128),
+      executable: Boolean(stats.mode & 64)
+    }
+  };
+}
+function registerGetFileInfo(server) {
+  server.registerTool(
+    "getFileInfo",
+    {
+      title: "Get file info",
+      description: dedent`
+        File information retriever for detailed metadata about files and directories.
+
+        Use cases:
+        - Checking file existence and type
+        - Getting file size and timestamps
+        - Determining MIME types
+        - Validating file accessibility
+
+        How it works:
+        - Retrieves comprehensive file system metadata
+        - Detects MIME type from file extension
+        - Provides both absolute and relative paths
+        - Returns human-readable file sizes
+        
+        Parameters:
+        - path: File or directory path to inspect
+      `,
+      inputSchema: inputSchema8.shape
+    },
+    async (input) => {
+      try {
+        return successToolResult(await getFileInfo(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var inputSchema9 = z.object({
+  path: z.string()
+});
+async function listDirectory(input) {
+  const { path: path2 } = input;
+  const validatedPath = await validatePath(path2);
+  if (!existsSync(validatedPath)) {
+    throw new Error(`Directory ${path2} does not exist.`);
+  }
+  const stats = statSync(validatedPath);
+  if (!stats.isDirectory()) {
+    throw new Error(`Path ${path2} is not a directory.`);
+  }
+  const entries = await readdir(validatedPath);
+  const items = [];
+  for (const entry of entries.sort()) {
+    try {
+      const fullPath = await validatePath(join(validatedPath, entry));
+      const entryStats = statSync(fullPath);
+      const item = {
+        name: entry,
+        path: entry,
+        type: entryStats.isDirectory() ? "directory" : "file",
+        size: entryStats.size,
+        modified: entryStats.mtime.toISOString()
+      };
+      items.push(item);
+    } catch (e) {
+      if (e instanceof Error && e.message.includes("perstack directory is not allowed")) {
+        continue;
+      }
+      throw e;
+    }
+  }
+  return {
+    path: validatedPath,
+    items
+  };
+}
+function registerListDirectory(server) {
+  server.registerTool(
+    "listDirectory",
+    {
+      title: "List directory",
+      description: dedent`
+        Directory content lister with detailed file information.
+
+        Use cases:
+        - Exploring project structure
+        - Finding files in a directory
+        - Checking directory contents before operations
+        - Understanding file organization
+
+        How it works:
+        - Lists all files and subdirectories in specified directory only
+        - Provides file type, size, and modification time
+        - Sorts entries alphabetically
+        - Handles empty directories
+        
+        Parameters:
+        - path: Directory path to list (optional, defaults to workspace root)
+      `,
+      inputSchema: inputSchema9.shape
+    },
+    async (input) => {
+      try {
+        return successToolResult(await listDirectory(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var inputSchema10 = z.object({
+  source: z.string(),
+  destination: z.string()
+});
+async function moveFile(input) {
+  const { source, destination } = input;
+  const validatedSource = await validatePath(source);
+  const validatedDestination = await validatePath(destination);
+  if (!existsSync(validatedSource)) {
+    throw new Error(`Source file ${source} does not exist.`);
+  }
+  const sourceStats = statSync(validatedSource);
+  if (!(sourceStats.mode & 128)) {
+    throw new Error(`Source file ${source} is not writable`);
+  }
+  if (existsSync(validatedDestination)) {
+    throw new Error(`Destination ${destination} already exists.`);
+  }
+  const destDir = dirname(validatedDestination);
+  await mkdir(destDir, { recursive: true });
+  await rename(validatedSource, validatedDestination);
+  return {
+    source: validatedSource,
+    destination: validatedDestination
+  };
+}
+function registerMoveFile(server) {
+  server.registerTool(
+    "moveFile",
+    {
+      title: "Move file",
+      description: dedent`
+        File mover for relocating or renaming files within the workspace.
+
+        Use cases:
+        - Renaming files to follow naming conventions
+        - Moving files to different directories
+        - Organizing project structure
+        - Backing up files before modifications
+
+        How it works:
+        - Validates source file existence
+        - Creates destination directory if needed
+        - Performs atomic move operation
+        - Preserves file permissions and timestamps
+        
+        Parameters:
+        - source: Current file path
+        - destination: Target file path
+      `,
+      inputSchema: inputSchema10.shape
+    },
+    async (input) => {
+      try {
+        return successToolResult(await moveFile(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var MAX_IMAGE_SIZE = 15 * 1024 * 1024;
+var inputSchema11 = z.object({
+  path: z.string()
+});
+async function readImageFile(input) {
+  const { path: path2 } = input;
+  const validatedPath = await validatePath(path2);
+  const isFile = existsSync(validatedPath);
+  if (!isFile) {
+    throw new Error(`File ${path2} does not exist.`);
+  }
+  const mimeType = mime.lookup(validatedPath);
+  if (!mimeType || !["image/png", "image/jpeg", "image/gif", "image/webp"].includes(mimeType)) {
+    throw new Error(`File ${path2} is not supported.`);
+  }
+  const fileStats = await stat(validatedPath);
+  const fileSizeMB = fileStats.size / (1024 * 1024);
+  if (fileStats.size > MAX_IMAGE_SIZE) {
+    throw new Error(
+      `Image file too large (${fileSizeMB.toFixed(1)}MB). Maximum supported size is ${MAX_IMAGE_SIZE / (1024 * 1024)}MB. Please use a smaller image file.`
+    );
+  }
+  return {
+    path: validatedPath,
+    mimeType,
+    size: fileStats.size
+  };
+}
+function registerReadImageFile(server) {
+  server.registerTool(
+    "readImageFile",
+    {
+      title: "Read image file",
+      description: dedent`
+        Image file reader that converts images to base64 encoded strings with MIME type validation.
+
+        Use cases:
+        - Loading images for LLM to process
+        - Retrieving image data for analysis or display
+        - Converting workspace image files to base64 format
+
+        How it works:
+        - Validates file existence and MIME type before reading
+        - Encodes file content as base64 string
+        - Returns image data with correct MIME type for proper handling
+        - Rejects unsupported formats with clear error messages
+
+        Supported formats:
+        - PNG (image/png)
+        - JPEG/JPG (image/jpeg)
+        - GIF (image/gif) - static only, animated not supported
+        - WebP (image/webp)
+        
+        Notes:
+        - Maximum file size: 15MB (larger files will be rejected)
+      `,
+      inputSchema: inputSchema11.shape
+    },
+    async (input) => {
+      try {
+        return successToolResult(await readImageFile(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var MAX_PDF_SIZE = 30 * 1024 * 1024;
+var inputSchema12 = z.object({
+  path: z.string()
+});
+async function readPdfFile(input) {
+  const { path: path2 } = input;
+  const validatedPath = await validatePath(path2);
+  const isFile = existsSync(validatedPath);
+  if (!isFile) {
+    throw new Error(`File ${path2} does not exist.`);
+  }
+  const mimeType = mime.lookup(validatedPath);
+  if (mimeType !== "application/pdf") {
+    throw new Error(`File ${path2} is not a PDF file.`);
+  }
+  const fileStats = await stat(validatedPath);
+  const fileSizeMB = fileStats.size / (1024 * 1024);
+  if (fileStats.size > MAX_PDF_SIZE) {
+    throw new Error(
+      `PDF file too large (${fileSizeMB.toFixed(1)}MB). Maximum supported size is ${MAX_PDF_SIZE / (1024 * 1024)}MB. Please use a smaller PDF file.`
+    );
+  }
+  return {
+    path: validatedPath,
+    mimeType,
+    size: fileStats.size
+  };
+}
+function registerReadPdfFile(server) {
+  server.registerTool(
+    "readPdfFile",
+    {
+      title: "Read PDF file",
+      description: dedent`
+        PDF file reader that converts documents to base64 encoded resources.
+
+        Use cases:
+        - Extracting content from PDF documents for analysis
+        - Loading PDF files for LLM processing
+        - Retrieving PDF data for conversion or manipulation
+
+        How it works:
+        - Validates file existence and MIME type (application/pdf)
+        - Encodes PDF content as base64 blob
+        - Returns as resource type with proper MIME type and URI
+        - Rejects non-PDF files with clear error messages
+
+        Notes:
+        - Returns entire PDF content, no page range support
+        - Maximum file size: 10MB (larger files will be rejected)
+        - Text extraction not performed, returns raw PDF data
+      `,
+      inputSchema: inputSchema12.shape
+    },
+    async (input) => {
+      try {
+        return successToolResult(await readPdfFile(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var inputSchema13 = z.object({
+  path: z.string(),
+  from: z.number().optional().describe("The line number to start reading from."),
+  to: z.number().optional().describe("The line number to stop reading at.")
+});
+async function readTextFile(input) {
+  const { path: path2, from, to } = input;
+  const validatedPath = await validatePath(path2);
+  const isFile = existsSync(validatedPath);
+  if (!isFile) {
+    throw new Error(`File ${path2} does not exist.`);
+  }
+  const fileContent = await readFile(validatedPath, "utf-8");
+  const lines = fileContent.split("\n");
+  const fromLine = from ?? 0;
+  const toLine = to ?? lines.length;
+  const selectedLines = lines.slice(fromLine, toLine);
+  const content = selectedLines.join("\n");
+  return {
+    path: path2,
+    content,
+    from: fromLine,
+    to: toLine
+  };
+}
+function registerReadTextFile(server) {
+  server.registerTool(
+    "readTextFile",
+    {
+      title: "Read text file",
+      description: dedent`
+        Text file reader with line range support for UTF-8 encoded files.
+
+        Use cases:
+        - Reading source code files for analysis
+        - Extracting specific sections from large text files
+        - Loading configuration or documentation files
+        - Viewing log files or data files
+
+        How it works:
+        - Reads files as UTF-8 encoded text without format validation
+        - Supports partial file reading via line number ranges
+        - Returns content wrapped in JSON with metadata
+        - WARNING: Binary files will cause errors or corrupted output
+
+        Common file types:
+        - Source code: .ts, .js, .py, .java, .cpp, etc.
+        - Documentation: .md, .txt, .rst
+        - Configuration: .json, .yaml, .toml, .ini
+        - Data files: .csv, .log, .sql
+      `,
+      inputSchema: inputSchema13.shape
+    },
+    async (input) => {
+      try {
+        return successToolResult(await readTextFile(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var inputSchema14 = z.object({
+  thought: z.string().describe("Your current thinking step"),
+  nextThoughtNeeded: z.boolean().optional().describe("true if you need more thinking, even if at what seemed like the end")
+});
+var Thought = class {
+  thoughtHistory = [];
+  branches = {};
+  processThought(input) {
+    const { nextThoughtNeeded } = input;
+    this.thoughtHistory.push(input);
+    return {
+      nextThoughtNeeded,
+      thoughtHistoryLength: this.thoughtHistory.length
+    };
+  }
+};
+var thought = new Thought();
+async function think(input) {
+  return thought.processThought(input);
+}
+function registerThink(server) {
+  server.registerTool(
+    "think",
+    {
+      title: "think",
+      description: dedent`
+      Sequential thinking tool for step-by-step problem analysis and solution development.
+
+      Use cases:
+      - Breaking down complex problems into manageable steps
+      - Developing solutions through iterative reasoning
+      - Analyzing problems that require multiple perspectives
+      - Planning tasks with dependencies and considerations
+
+      How it works:
+      - Records each thinking step sequentially
+      - Maintains thought history for context
+      - Continues until solution is reached
+      - Returns thought count and continuation status
+
+      Parameters:
+      - thought: Current reasoning step or analysis
+      - nextThoughtNeeded: Whether additional thinking is required (optional)
+
+      Best practices:
+      - Use multiple calls for sophisticated reasoning chains
+      - Progress from high-level overview to detailed analysis (drill-down approach)
+      - Capture insights and eureka moments as they emerge
+      - Engage in reflective introspection and constructive self-critique
+      - Set nextThoughtNeeded to false only when fully satisfied with the solution
+    `,
+      inputSchema: inputSchema14.shape
+    },
+    async (input) => {
+      try {
+        return successToolResult(await think(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var todoInputSchema = z.object({
+  newTodos: z.array(z.string()).describe("New todos to add").optional(),
+  completedTodos: z.array(z.number()).describe("Todo ids that are completed").optional()
+});
+var clearTodoInputSchema = z.object({});
+var Todo = class {
+  currentTodoId = 0;
+  todos = [];
+  processTodo(input) {
+    const { newTodos, completedTodos } = input;
+    if (newTodos) {
+      this.todos.push(
+        ...newTodos.map((title) => ({ id: this.currentTodoId++, title, completed: false }))
+      );
+    }
+    if (completedTodos) {
+      this.todos = this.todos.map((todo2) => ({
+        ...todo2,
+        completed: todo2.completed || completedTodos.includes(todo2.id)
+      }));
+    }
+    return {
+      todos: this.todos
+    };
+  }
+  clearTodo() {
+    this.todos = [];
+    this.currentTodoId = 0;
+    return {
+      todos: this.todos
+    };
+  }
+};
+var todoSingleton = new Todo();
+async function todo(input) {
+  return todoSingleton.processTodo(input);
+}
+async function clearTodo(_input) {
+  return todoSingleton.clearTodo();
+}
+function registerTodo(server) {
+  server.registerTool(
+    "todo",
+    {
+      title: "todo",
+      description: dedent`
+        Todo list manager that tracks tasks and their completion status.
+
+        Use cases:
+        - Creating new tasks or action items
+        - Marking tasks as completed
+        - Viewing current task list and status
+
+        How it works:
+        - Each todo gets a unique ID when created
+        - Returns the full todo list after every operation
+        - Maintains state across multiple calls
+
+        Parameters:
+        - newTodos: Array of task descriptions to add
+        - completedTodos: Array of todo IDs to mark as completed
+      `,
+      inputSchema: todoInputSchema.shape
+    },
+    async (input) => {
+      try {
+        return successToolResult(await todo(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+function registerClearTodo(server) {
+  server.registerTool(
+    "clearTodo",
+    {
+      title: "clearTodo",
+      description: dedent`
+        Clears the todo list.
+
+        Use cases:
+        - Resetting the todo list to an empty state
+        - Starting fresh with a new task list
+        - Clearing all tasks for a new day or project
+
+        How it works:
+        - Resets the todo list to an empty state
+        - Returns an empty todo list
+      `,
+      inputSchema: clearTodoInputSchema.shape
+    },
+    async (input) => {
+      try {
+        return successToolResult(await clearTodo(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var inputSchema15 = z.object({
+  path: z.string().describe("Target file path (relative or absolute)."),
+  text: z.string().max(1e4).describe("Text to write to the file. Max 10000 characters.")
+});
+async function writeTextFile(input) {
+  const { path: path2, text } = input;
+  const validatedPath = await validatePath(path2);
+  if (existsSync(validatedPath)) {
+    const stats = statSync(validatedPath);
+    if (!(stats.mode & 128)) {
+      throw new Error(`File ${path2} is not writable`);
+    }
+  }
+  const dir = dirname(validatedPath);
+  await mkdir(dir, { recursive: true });
+  await writeFile(validatedPath, text, "utf-8");
+  return {
+    path: validatedPath,
+    text
+  };
+}
+function registerWriteTextFile(server) {
+  server.registerTool(
+    "writeTextFile",
+    {
+      title: "writeTextFile",
+      description: dedent`
+        Text file writer that creates or overwrites files with UTF-8 content.
+
+        Use cases:
+        - Creating new configuration files
+        - Writing generated code or documentation
+        - Saving processed data or results
+        - Creating log files or reports
+
+        How it works:
+        - Writes content as UTF-8 encoded text
+        - Returns success status with file path
+
+        Rules:
+        - IF THE FILE ALREADY EXISTS, IT WILL BE OVERWRITTEN
+        - YOU MUST PROVIDE A VALID UTF-8 STRING FOR THE TEXT
+        - THERE IS A LIMIT ON THE NUMBER OF TOKENS THAT CAN BE GENERATED, SO DO NOT WRITE ALL THE CONTENT AT ONCE (IT WILL CAUSE AN ERROR)
+        - IF YOU WANT TO WRITE MORE THAN 10,000 CHARACTERS, USE "appendTextFile" TOOL AFTER THIS ONE
+      `,
+      inputSchema: inputSchema15.shape
+    },
+    async (input) => {
+      try {
+        return successToolResult(await writeTextFile(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+
+export { appendTextFile, attemptCompletion, clearTodo, createDirectory, deleteDirectory, deleteFile, editTextFile, exec, getFileInfo, listDirectory, moveFile, readImageFile, readPdfFile, readTextFile, registerAppendTextFile, registerAttemptCompletion, registerClearTodo, registerCreateDirectory, registerDeleteDirectory, registerDeleteFile, registerEditTextFile, registerExec, registerGetFileInfo, registerListDirectory, registerMoveFile, registerReadImageFile, registerReadPdfFile, registerReadTextFile, registerThink, registerTodo, registerWriteTextFile, think, todo, writeTextFile };
+//# sourceMappingURL=chunk-CDWG4Z4N.js.map
+//# sourceMappingURL=chunk-CDWG4Z4N.js.map