@perstack/base 0.0.19 → 0.0.21

package/dist/chunk-4N6IWATT.js

@@ -1,899 +0,0 @@
-import { realpathSync, existsSync, statSync } from 'fs';
-import fs, { appendFile, mkdir, 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 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/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.")
-});
-function appendTextFileConfig() {
-  return {
-    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 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 attemptCompletionConfig() {
-  return {
-    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: {}
-  };
-}
-async function attemptCompletion() {
-  return {
-    message: "End the agent loop and provide a final report"
-  };
-}
-var inputSchema2 = z.object({
-  path: z.string()
-});
-function createDirectoryConfig() {
-  return {
-    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: inputSchema2.shape
-  };
-}
-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
-  };
-}
-var inputSchema3 = z.object({
-  path: z.string()
-});
-function deleteFileConfig() {
-  return {
-    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: inputSchema3.shape
-  };
-}
-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
-  };
-}
-var inputSchema4 = 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.")
-});
-function editTextFileConfig() {
-  return {
-    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: inputSchema4.shape
-  };
-}
-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");
-}
-var inputSchema5 = z.object({
-  path: z.string()
-});
-function getFileInfoConfig() {
-  return {
-    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: inputSchema5.shape
-  };
-}
-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)
-    }
-  };
-}
-var inputSchema6 = z.object({
-  path: z.string()
-});
-function listDirectoryConfig() {
-  return {
-    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: inputSchema6.shape
-  };
-}
-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
-  };
-}
-var inputSchema7 = z.object({
-  source: z.string(),
-  destination: z.string()
-});
-function moveFileConfig() {
-  return {
-    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: inputSchema7.shape
-  };
-}
-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
-  };
-}
-var MAX_IMAGE_SIZE = 15 * 1024 * 1024;
-var inputSchema8 = z.object({
-  path: z.string()
-});
-function readImageFileConfig() {
-  return {
-    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: inputSchema8.shape
-  };
-}
-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
-  };
-}
-var MAX_PDF_SIZE = 30 * 1024 * 1024;
-var inputSchema9 = z.object({
-  path: z.string()
-});
-function readPdfFileConfig() {
-  return {
-    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: inputSchema9.shape
-  };
-}
-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
-  };
-}
-var inputSchema10 = 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.")
-});
-function readTextFileConfig() {
-  return {
-    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: inputSchema10.shape
-  };
-}
-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
-  };
-}
-var inputSchema11 = z.object({
-  urls: z.array(z.string()).min(1).max(10).describe("Array of URLs to test (max 10 URLs).")
-});
-function testUrlConfig() {
-  return {
-    title: "Test URL",
-    description: dedent`
-      URL tester that validates multiple URLs and extracts metadata.
-
-      Use cases:
-      - Checking if URLs are accessible before web scraping
-      - Validating URL collections for RAG processes
-      - Extracting page metadata (title, description) for content analysis
-      - Batch URL validation for link checking
-
-      How it works:
-      - Performs HTTP GET requests to each URL
-      - Returns status code, title, and description for each URL
-      - Handles errors gracefully with timeout protection
-      - Processes URLs in parallel for performance
-
-      Rules:
-      - URLs must be valid HTTP/HTTPS addresses
-      - Maximum 10 URLs per request to prevent abuse
-      - 10 second timeout per URL request
-      - Returns empty title/description if HTML parsing fails
-    `,
-    inputSchema: inputSchema11.shape
-  };
-}
-async function testUrls(input) {
-  const { urls } = input;
-  const results = await Promise.allSettled(
-    urls.map(async (url) => {
-      try {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), 1e4);
-        const response = await fetch(url, {
-          method: "GET",
-          signal: controller.signal,
-          headers: {
-            "User-Agent": "Perstack URL Tester/1.0"
-          }
-        });
-        clearTimeout(timeoutId);
-        let title = "";
-        let description = "";
-        if (response.ok && response.headers.get("content-type")?.includes("text/html")) {
-          try {
-            const html = await response.text();
-            title = extractTitle(html);
-            description = extractDescription(html);
-          } catch {
-          }
-        }
-        return {
-          url,
-          status: response.status,
-          title,
-          description
-        };
-      } catch (error) {
-        return {
-          url,
-          status: 0,
-          title: "",
-          description: error instanceof Error ? error.message : "Unknown error"
-        };
-      }
-    })
-  );
-  return {
-    results: results.map((result) => {
-      if (result.status === "fulfilled") {
-        return result.value;
-      }
-      return {
-        url: "unknown",
-        status: 0,
-        title: "",
-        description: "Promise rejected"
-      };
-    })
-  };
-}
-function extractTitle(html) {
-  const titleMatch = html.match(/<title[^>]*>([^<]*)/i);
-  return titleMatch ? titleMatch[1].trim() : "";
-}
-function extractDescription(html) {
-  const metaDescMatch = html.match(
-    /<meta[^>]*name=["']description["'][^>]*content=["']([^"']*)["']/i
-  );
-  if (metaDescMatch) {
-    return metaDescMatch[1].trim();
-  }
-  const ogDescMatch = html.match(
-    /<meta[^>]*property=["']og:description["'][^>]*content=["']([^"']*)["']/i
-  );
-  if (ogDescMatch) {
-    return ogDescMatch[1].trim();
-  }
-  return "";
-}
-var inputSchema12 = 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")
-});
-function thinkConfig() {
-  return {
-    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: inputSchema12.shape
-  };
-}
-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);
-}
-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();
-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()
-});
-function todoConfig() {
-  return {
-    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 function todo(input) {
-  return todoSingleton.processTodo(input);
-}
-var clearTodoInputSchema = z.object({});
-function clearTodoConfig() {
-  return {
-    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 function clearTodo(input) {
-  return todoSingleton.clearTodo();
-}
-var toolInputSchema = z.object({
-  path: z.string().describe("Target file path (relative or absolute)."),
-  text: z.string().min(1).max(1e4).describe("Text to write to the file. Max 10000 characters.")
-});
-function writeTextFileConfig() {
-  return {
-    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: toolInputSchema.shape
-  };
-}
-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
-  };
-}
-
-export { appendTextFile, appendTextFileConfig, attemptCompletion, attemptCompletionConfig, clearTodo, clearTodoConfig, createDirectory, createDirectoryConfig, deleteFile, deleteFileConfig, editTextFile, editTextFileConfig, getFileInfo, getFileInfoConfig, listDirectory, listDirectoryConfig, moveFile, moveFileConfig, readImageFile, readImageFileConfig, readPdfFile, readPdfFileConfig, readTextFile, readTextFileConfig, testUrlConfig, testUrls, think, thinkConfig, todo, todoConfig, writeTextFile, writeTextFileConfig };
-//# sourceMappingURL=chunk-4N6IWATT.js.map
-//# sourceMappingURL=chunk-4N6IWATT.js.map