@perstack/base 0.0.19 → 0.0.21

package/dist/src/index.js

@@ -1,9 +1,278 @@
-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 } from '../chunk-4N6IWATT.js';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
+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 { 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/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 execFileAsync = promisify(execFile);
 var execInputSchema = z.object({
   command: z.string().describe("The command to execute"),
@@ -108,7 +377,629 @@ Standard Error: ${execError.stderr}`;
     };
   }
 }
+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 { exec, execConfig };
+export { appendTextFile, appendTextFileConfig, attemptCompletion, attemptCompletionConfig, clearTodo, clearTodoConfig, createDirectory, createDirectoryConfig, deleteFile, deleteFileConfig, editTextFile, editTextFileConfig, exec, execConfig, getFileInfo, getFileInfoConfig, listDirectory, listDirectoryConfig, moveFile, moveFileConfig, readImageFile, readImageFileConfig, readPdfFile, readPdfFileConfig, readTextFile, readTextFileConfig, testUrlConfig, testUrls, think, thinkConfig, todo, todoConfig, writeTextFile, writeTextFileConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map