@perstack/base 0.0.54 → 0.0.56

package/dist/chunk-HUJMWPRE.js

@@ -1,1225 +0,0 @@
-import { realpathSync, existsSync, statSync } from 'fs';
-import fs, { constants, stat, mkdir, rm, rmdir, unlink, readdir, rename, open, lstat } from 'fs/promises';
-import os from 'os';
-import path, { dirname, extname, basename, resolve, join } from 'path';
-import { dedent } from 'ts-dedent';
-import { z } from 'zod/v4';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-import { getFilteredEnv } from '@perstack/core';
-import mime from 'mime-types';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-
-// package.json
-var package_default = {
-  name: "@perstack/base",
-  version: "0.0.54",
-  description: "Perstack base skills for agents.",
-  author: "Wintermute Technologies, Inc.",
-  license: "Apache-2.0",
-  type: "module",
-  exports: {
-    ".": "./src/index.ts"
-  },
-  publishConfig: {
-    access: "public",
-    bin: {
-      "@perstack/base": "dist/bin/server.js"
-    },
-    exports: {
-      ".": "./dist/src/index.js"
-    },
-    types: {
-      ".": "./dist/src/index.d.ts"
-    }
-  },
-  files: [
-    "dist"
-  ],
-  scripts: {
-    clean: "rm -rf dist",
-    build: "pnpm run clean && tsup",
-    typecheck: "tsc --noEmit"
-  },
-  dependencies: {
-    "@modelcontextprotocol/sdk": "^1.25.3",
-    "@perstack/core": "workspace:*",
-    commander: "^14.0.2",
-    "mime-types": "^3.0.2",
-    "ts-dedent": "^2.2.0",
-    zod: "^4.3.6"
-  },
-  devDependencies: {
-    "@tsconfig/node22": "^22.0.5",
-    "@types/mime-types": "^3.0.1",
-    "@types/node": "^25.0.10",
-    tsup: "^8.5.1",
-    typescript: "^5.9.3",
-    vitest: "^4.0.18"
-  },
-  engines: {
-    node: ">=22.0.0"
-  }
-};
-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);
-  const perstackDir = `${workspacePath}/perstack`.toLowerCase();
-  if (absolute.toLowerCase() === perstackDir || absolute.toLowerCase().startsWith(`${perstackDir}/`)) {
-    throw new Error("Access denied - perstack directory is not allowed");
-  }
-  try {
-    const realAbsolute = await fs.realpath(absolute);
-    if (!isWithinWorkspace(realAbsolute)) {
-      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 (!isWithinWorkspace(realParentPath)) {
-        throw new Error("Access denied - parent directory outside allowed directories");
-      }
-      return absolute;
-    } catch {
-      if (!isWithinWorkspace(absolute)) {
-        throw new Error(
-          `Access denied - path outside allowed directories: ${absolute} not in ${workspacePath}`
-        );
-      }
-      throw new Error(`Parent directory does not exist: ${parentDir}`);
-    }
-  }
-}
-function isWithinWorkspace(absolutePath) {
-  return absolutePath === workspacePath || absolutePath.startsWith(`${workspacePath}/`);
-}
-
-// 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 }) }]
-  };
-}
-var O_NOFOLLOW = constants.O_NOFOLLOW ?? 0;
-typeof constants.O_NOFOLLOW === "number";
-async function checkNotSymlink(path2) {
-  const stats = await lstat(path2).catch(() => null);
-  if (stats?.isSymbolicLink()) {
-    throw new Error("Operation denied: target is a symbolic link");
-  }
-}
-async function safeWriteFile(path2, data) {
-  let handle;
-  try {
-    await checkNotSymlink(path2);
-    const flags = constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | O_NOFOLLOW;
-    handle = await open(path2, flags, 420);
-    await handle.writeFile(data, "utf-8");
-  } finally {
-    await handle?.close();
-  }
-}
-async function safeReadFile(path2) {
-  let handle;
-  try {
-    await checkNotSymlink(path2);
-    const flags = constants.O_RDONLY | O_NOFOLLOW;
-    handle = await open(path2, flags);
-    const buffer = await handle.readFile("utf-8");
-    return buffer;
-  } finally {
-    await handle?.close();
-  }
-}
-async function safeAppendFile(path2, data) {
-  let handle;
-  try {
-    await checkNotSymlink(path2);
-    const flags = constants.O_WRONLY | constants.O_APPEND | O_NOFOLLOW;
-    handle = await open(path2, flags);
-    await handle.writeFile(data, "utf-8");
-  } finally {
-    await handle?.close();
-  }
-}
-
-// src/tools/append-text-file.ts
-async function appendTextFile({ path: path2, text }) {
-  const validatedPath = await validatePath(path2);
-  const stats = await stat(validatedPath).catch(() => null);
-  if (!stats) {
-    throw new Error(`File ${path2} does not exist.`);
-  }
-  if (!(stats.mode & 128)) {
-    throw new Error(`File ${path2} is not writable`);
-  }
-  await safeAppendFile(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
-    `,
-      inputSchema: {
-        path: z.string().describe("Target file path to append to."),
-        text: z.string().describe("Text to append to the file.")
-      }
-    },
-    async ({ path: path2, text }) => {
-      try {
-        return successToolResult(await appendTextFile({ path: path2, text }));
-      } catch (e) {
-        if (e instanceof Error) return errorToolResult(e);
-        throw e;
-      }
-    }
-  );
-}
-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() {
-  return todoSingleton.clearTodo();
-}
-function getRemainingTodos() {
-  return todoSingleton.todos.filter((t) => !t.completed);
-}
-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: {
-        newTodos: z.array(z.string()).describe("New todos to add").optional(),
-        completedTodos: z.array(z.number()).describe("Todo ids that are completed").optional()
-      }
-    },
-    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: {}
-    },
-    async () => {
-      try {
-        return successToolResult(await clearTodo());
-      } catch (e) {
-        if (e instanceof Error) return errorToolResult(e);
-        throw e;
-      }
-    }
-  );
-}
-async function attemptCompletion() {
-  const remainingTodos = getRemainingTodos();
-  if (remainingTodos.length > 0) {
-    return { remainingTodos };
-  }
-  return {};
-}
-function registerAttemptCompletion(server) {
-  server.registerTool(
-    "attemptCompletion",
-    {
-      title: "Attempt completion",
-      description: dedent`
-      Task completion signal with automatic todo validation.
-      Use cases:
-      - Signaling task completion to Perstack runtime
-      - Validating all todos are complete before ending
-      - Ending the current expert's work cycle
-      How it works:
-      - Checks the current todo list for incomplete items
-      - If incomplete todos exist: returns them and continues the agent loop
-      - If no incomplete todos: returns empty object and ends the agent loop
-      Notes:
-      - Mark all todos as complete before calling
-      - Use clearTodo if you want to reset and start fresh
-      - Prevents premature completion by surfacing forgotten tasks
-    `,
-      inputSchema: {}
-    },
-    async () => {
-      try {
-        return successToolResult(await attemptCompletion());
-      } catch (e) {
-        if (e instanceof Error) return errorToolResult(e);
-        throw e;
-      }
-    }
-  );
-}
-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: {
-        path: z.string()
-      }
-    },
-    async (input) => {
-      try {
-        return successToolResult(await createDirectory(input));
-      } catch (e) {
-        if (e instanceof Error) return errorToolResult(e);
-        throw e;
-      }
-    }
-  );
-}
-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: {
-        path: z.string(),
-        recursive: z.boolean().optional().describe("Whether to delete contents recursively. Required for non-empty directories.")
-      }
-    },
-    async (input) => {
-      try {
-        return successToolResult(await deleteDirectory(input));
-      } catch (e) {
-        if (e instanceof Error) return errorToolResult(e);
-        throw e;
-      }
-    }
-  );
-}
-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: {
-        path: z.string()
-      }
-    },
-    async (input) => {
-      try {
-        return successToolResult(await deleteFile(input));
-      } catch (e) {
-        if (e instanceof Error) return errorToolResult(e);
-        throw e;
-      }
-    }
-  );
-}
-async function editTextFile(input) {
-  const { path: path2, newText, oldText } = input;
-  const validatedPath = await validatePath(path2);
-  const stats = await stat(validatedPath).catch(() => null);
-  if (!stats) {
-    throw new Error(`File ${path2} does not exist.`);
-  }
-  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 safeReadFile(filePath));
-  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 safeWriteFile(filePath, modifiedContent);
-}
-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
-        - DO NOT USE THIS TOOL FOR APPENDING TEXT TO FILES - USE appendTextFile TOOL INSTEAD
-      `,
-      inputSchema: {
-        path: z.string().describe("Target file path to edit."),
-        newText: z.string().describe("Text to replace with."),
-        oldText: z.string().describe("Exact text to find and replace.")
-      }
-    },
-    async (input) => {
-      try {
-        return successToolResult(await editTextFile(input));
-      } catch (e) {
-        if (e instanceof Error) return errorToolResult(e);
-        throw e;
-      }
-    }
-  );
-}
-var execFileAsync = promisify(execFile);
-function isExecError(error) {
-  return error instanceof Error && "code" in error;
-}
-async function exec(input) {
-  const validatedCwd = await validatePath(input.cwd);
-  const { stdout, stderr } = await execFileAsync(input.command, input.args, {
-    cwd: validatedCwd,
-    env: getFilteredEnv(input.env),
-    timeout: input.timeout,
-    maxBuffer: 10 * 1024 * 1024
-  });
-  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: {
-        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().default(6e4).describe("Timeout in milliseconds (default: 60000)")
-      }
-    },
-    async (input) => {
-      try {
-        return successToolResult(await exec(input));
-      } catch (error) {
-        let message;
-        let stdout;
-        let stderr;
-        if (isExecError(error)) {
-          if ((error.killed || error.signal === "SIGTERM") && typeof input.timeout === "number") {
-            message = `Command timed out after ${input.timeout}ms.`;
-          } else if (error.message.includes("timeout")) {
-            message = `Command timed out after ${input.timeout}ms.`;
-          } else {
-            message = error.message;
-          }
-          stdout = error.stdout;
-          stderr = error.stderr;
-        } else if (error instanceof Error) {
-          message = error.message;
-        } else {
-          message = "An unknown error occurred.";
-        }
-        const result = { error: message };
-        if (stdout && input.stdout) {
-          result.stdout = stdout;
-        }
-        if (stderr && input.stderr) {
-          result.stderr = stderr;
-        }
-        return { content: [{ type: "text", text: JSON.stringify(result) }] };
-      }
-    }
-  );
-}
-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: {
-        path: z.string()
-      }
-    },
-    async (input) => {
-      try {
-        return successToolResult(await getFileInfo(input));
-      } catch (e) {
-        if (e instanceof Error) return errorToolResult(e);
-        throw e;
-      }
-    }
-  );
-}
-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: {
-        path: z.string()
-      }
-    },
-    async (input) => {
-      try {
-        return successToolResult(await listDirectory(input));
-      } catch (e) {
-        if (e instanceof Error) return errorToolResult(e);
-        throw e;
-      }
-    }
-  );
-}
-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: {
-        source: z.string(),
-        destination: z.string()
-      }
-    },
-    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;
-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: {
-        path: z.string()
-      }
-    },
-    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;
-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: 30MB (larger files will be rejected)
-        - Text extraction not performed, returns raw PDF data
-      `,
-      inputSchema: {
-        path: z.string()
-      }
-    },
-    async (input) => {
-      try {
-        return successToolResult(await readPdfFile(input));
-      } catch (e) {
-        if (e instanceof Error) return errorToolResult(e);
-        throw e;
-      }
-    }
-  );
-}
-async function readTextFile(input) {
-  const { path: path2, from, to } = input;
-  const validatedPath = await validatePath(path2);
-  const stats = await stat(validatedPath).catch(() => null);
-  if (!stats) {
-    throw new Error(`File ${path2} does not exist.`);
-  }
-  const fileContent = await safeReadFile(validatedPath);
-  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: {
-        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 (input) => {
-      try {
-        return successToolResult(await readTextFile(input));
-      } catch (e) {
-        if (e instanceof Error) return errorToolResult(e);
-        throw e;
-      }
-    }
-  );
-}
-async function writeTextFile(input) {
-  const { path: path2, text } = input;
-  const validatedPath = await validatePath(path2);
-  const stats = await stat(validatedPath).catch(() => null);
-  if (stats && !(stats.mode & 128)) {
-    throw new Error(`File ${path2} is not writable`);
-  }
-  const dir = dirname(validatedPath);
-  await mkdir(dir, { recursive: true });
-  await safeWriteFile(validatedPath, text);
-  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
-      `,
-      inputSchema: {
-        path: z.string().describe("Target file path (relative or absolute)."),
-        text: z.string().describe("Text to write to the file.")
-      }
-    },
-    async (input) => {
-      try {
-        return successToolResult(await writeTextFile(input));
-      } catch (e) {
-        if (e instanceof Error) return errorToolResult(e);
-        throw e;
-      }
-    }
-  );
-}
-var startTime = Date.now();
-async function healthCheck() {
-  const uptime = Math.floor((Date.now() - startTime) / 1e3);
-  const memoryUsage = process.memoryUsage();
-  return {
-    status: "ok",
-    workspace: workspacePath,
-    uptime: `${uptime}s`,
-    memory: {
-      heapUsed: `${Math.round(memoryUsage.heapUsed / 1024 / 1024)}MB`,
-      heapTotal: `${Math.round(memoryUsage.heapTotal / 1024 / 1024)}MB`
-    },
-    pid: process.pid
-  };
-}
-function registerHealthCheck(server) {
-  server.registerTool(
-    "healthCheck",
-    {
-      title: "Perstack Runtime Health Check",
-      description: dedent`
-        Returns Perstack runtime health status and diagnostics.
-        Use cases:
-        - Verify Perstack runtime is running and responsive
-        - Check workspace configuration
-        - Monitor runtime uptime and memory usage
-        How it works:
-        - Returns runtime status, workspace path, uptime, and memory usage
-        - Always returns "ok" status if runtime can respond
-        - Useful for debugging connection issues
-        Notes:
-        - This is a diagnostic tool for Perstack runtime itself
-        - Does not access or modify files
-      `,
-      inputSchema: {}
-    },
-    async () => successToolResult(await healthCheck())
-  );
-}
-
-// src/server.ts
-var BASE_SKILL_NAME = package_default.name;
-var BASE_SKILL_VERSION = package_default.version;
-function registerAllTools(server) {
-  registerAttemptCompletion(server);
-  registerTodo(server);
-  registerClearTodo(server);
-  registerExec(server);
-  registerGetFileInfo(server);
-  registerHealthCheck(server);
-  registerReadTextFile(server);
-  registerReadImageFile(server);
-  registerReadPdfFile(server);
-  registerWriteTextFile(server);
-  registerAppendTextFile(server);
-  registerEditTextFile(server);
-  registerMoveFile(server);
-  registerDeleteFile(server);
-  registerListDirectory(server);
-  registerCreateDirectory(server);
-  registerDeleteDirectory(server);
-}
-function createBaseServer() {
-  const server = new McpServer(
-    {
-      name: BASE_SKILL_NAME,
-      version: BASE_SKILL_VERSION
-    },
-    {
-      capabilities: {
-        tools: {}
-      }
-    }
-  );
-  registerAllTools(server);
-  return server;
-}
-
-export { BASE_SKILL_NAME, BASE_SKILL_VERSION, appendTextFile, attemptCompletion, clearTodo, createBaseServer, createDirectory, deleteDirectory, deleteFile, editTextFile, errorToolResult, exec, getFileInfo, getRemainingTodos, listDirectory, moveFile, package_default, readImageFile, readPdfFile, readTextFile, registerAllTools, registerAppendTextFile, registerAttemptCompletion, registerClearTodo, registerCreateDirectory, registerDeleteDirectory, registerDeleteFile, registerEditTextFile, registerExec, registerGetFileInfo, registerListDirectory, registerMoveFile, registerReadImageFile, registerReadPdfFile, registerReadTextFile, registerTodo, registerWriteTextFile, successToolResult, todo, validatePath, writeTextFile };
-//# sourceMappingURL=chunk-HUJMWPRE.js.map
-//# sourceMappingURL=chunk-HUJMWPRE.js.map