@perstack/base 0.0.7 → 0.0.8

package/dist/index.js

@@ -1,53 +1,56 @@
-#!/usr/bin/env node
+import { realpathSync, existsSync, statSync } from 'fs';
+import fs, { appendFile, readFile, mkdir, unlink, writeFile, readdir, rename, stat } from 'fs/promises';
+import os from 'os';
+import path, { dirname, extname, basename, resolve, join } from 'path';
+import mime from 'mime-types';
+import { dedent } from 'ts-dedent';
+import { z } from 'zod';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
 
-// src/index.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { Command } from "commander";
-
-// package.json
-var package_default = {
-  name: "@perstack/base",
-  version: "0.0.7",
-  description: "Perstack base skills for agents.",
-  author: "Wintermute Technologies, Inc.",
-  type: "module",
-  bin: {
-    base: "dist/index.js"
-  },
-  exports: {
-    ".": "./dist/index.js"
-  },
-  files: [
-    "dist"
-  ],
-  scripts: {
-    clean: "rm -rf dist",
-    dev: "tsup --watch --config ../../tsup.config.ts",
-    build: "npm run clean && tsup --config ../../tsup.config.ts",
-    prepublishOnly: "npm run clean && npm run build"
-  },
-  dependencies: {
-    "@modelcontextprotocol/sdk": "^1.17.1",
-    commander: "^14.0.0",
-    "mime-types": "^3.0.1",
-    "ts-dedent": "^2.2.0",
-    zod: "^3.23.8"
-  },
-  devDependencies: {
-    "@tsconfig/node22": "^22.0.2",
-    "@types/mime-types": "^3.0.1",
-    "@types/node": "^24.2.0",
-    tsup: "^8.5.0",
-    typescript: "^5.9.2"
-  },
-  engines: {
-    node: ">=22.0.0"
+// src/lib/path.ts
+var workspacePath = realpathSync(expandHome(process.cwd()));
+function expandHome(filepath) {
+  if (filepath.startsWith("~/") || filepath === "~") {
+    return path.join(os.homedir(), filepath.slice(1));
   }
-};
-
-// src/lib/workspace-api.ts
-import mime from "mime-types";
+  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}`);
+    }
+  }
+}
+var WorkspaceMode = /* @__PURE__ */ ((WorkspaceMode2) => {
+  WorkspaceMode2["LOCAL"] = "local";
+  WorkspaceMode2["STUDIO"] = "studio";
+  return WorkspaceMode2;
+})(WorkspaceMode || {});
 var getWorkspaceApiConfig = () => {
   const baseUrl = process.env.PERSTACK_API_BASE_URL;
   const apiKey = process.env.PERSTACK_API_KEY;
@@ -199,6 +202,16 @@ var deleteWorkspaceItem = async (workspaceItemId) => {
     throw new Error(`Failed to delete workspace item: ${response.status} ${errorText}`);
   }
 };
+var getWorkspaceItemContent = async (workspaceItem) => {
+  const config = getWorkspaceApiConfig();
+  if (!config) {
+    throw new Error("Workspace API not configured");
+  }
+  if (workspaceItem.type !== "workspaceItemFile") {
+    throw new Error("Can only get content for files");
+  }
+  throw new Error("Getting file content is not implemented yet");
+};
 
 // src/lib/register-tool.ts
 function resolveToolByMode(localModeFunction, studioModeFunction) {
@@ -218,58 +231,6 @@ function resolveToolByMode(localModeFunction, studioModeFunction) {
     }
   };
 }
-
-// src/tools/append-text-file.ts
-import { existsSync, statSync } from "fs";
-import { appendFile } from "fs/promises";
-import { readFile } from "fs/promises";
-import { dedent } from "ts-dedent";
-import { z } from "zod";
-
-// src/lib/path.ts
-import { realpathSync } from "fs";
-import fs from "fs/promises";
-import os from "os";
-import path from "path";
-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.")
@@ -333,21 +294,16 @@ async function appendTextFileStudioMode(input) {
     {
       type: "workspaceItemFile",
       path: relativePath,
-      owner: "expert",
-      lifecycle: "expertJob",
       permission: "readWrite"
     },
     content
   );
   return { path: relativePath, text };
 }
-
-// src/tools/attempt-completion.ts
-import { dedent as dedent2 } from "ts-dedent";
 function attemptCompletionConfig() {
   return {
     title: "Attempt completion",
-    description: dedent2`
+    description: dedent`
       Task completion signal that triggers immediate final report generation.
       Use cases:
       - Signaling task completion to Perstack runtime
@@ -371,20 +327,13 @@ async function attemptCompletion() {
     message: "End the agent loop and provide a final report"
   };
 }
-
-// src/tools/create-directory.ts
-import { existsSync as existsSync2, statSync as statSync2 } from "fs";
-import { mkdir } from "fs/promises";
-import { dirname } from "path";
-import { dedent as dedent3 } from "ts-dedent";
-import { z as z2 } from "zod";
-var inputSchema2 = z2.object({
-  path: z2.string()
+var inputSchema2 = z.object({
+  path: z.string()
 });
 function createDirectoryConfig() {
   return {
     title: "Create directory",
-    description: dedent3`
+    description: dedent`
       Directory creator for establishing folder structures in the workspace.
 
       Use cases:
@@ -408,13 +357,13 @@ function createDirectoryConfig() {
 async function createDirectoryLocalMode(input) {
   const { path: path2 } = input;
   const validatedPath = await validatePath(path2);
-  const exists = existsSync2(validatedPath);
+  const exists = existsSync(validatedPath);
   if (exists) {
     throw new Error(`Directory ${path2} already exists`);
   }
   const parentDir = dirname(validatedPath);
-  if (existsSync2(parentDir)) {
-    const parentStats = statSync2(parentDir);
+  if (existsSync(parentDir)) {
+    const parentStats = statSync(parentDir);
     if (!(parentStats.mode & 128)) {
       throw new Error(`Parent directory ${parentDir} is not writable`);
     }
@@ -441,8 +390,6 @@ async function createDirectoryStudioMode(input) {
       await createWorkspaceItem({
         type: "workspaceItemDirectory",
         path: currentPath,
-        owner: "expert",
-        lifecycle: "expertJob",
         permission: "readWrite"
       });
     }
@@ -452,19 +399,13 @@ async function createDirectoryStudioMode(input) {
     path: relativePath
   };
 }
-
-// src/tools/delete-file.ts
-import { existsSync as existsSync3, statSync as statSync3 } from "fs";
-import { unlink } from "fs/promises";
-import { dedent as dedent4 } from "ts-dedent";
-import { z as z3 } from "zod";
-var inputSchema3 = z3.object({
-  path: z3.string()
+var inputSchema3 = z.object({
+  path: z.string()
 });
 function deleteFileConfig() {
   return {
     title: "Delete file",
-    description: dedent4`
+    description: dedent`
       File deleter for removing files from the workspace.
 
       Use cases:
@@ -488,10 +429,10 @@ function deleteFileConfig() {
 async function deleteFileLocalMode(input) {
   const { path: path2 } = input;
   const validatedPath = await validatePath(path2);
-  if (!existsSync3(validatedPath)) {
+  if (!existsSync(validatedPath)) {
     throw new Error(`File ${path2} does not exist.`);
   }
-  const stats = statSync3(validatedPath);
+  const stats = statSync(validatedPath);
   if (stats.isDirectory()) {
     throw new Error(`Path ${path2} is a directory. Use delete directory tool instead.`);
   }
@@ -520,21 +461,15 @@ async function deleteFileStudioMode(input) {
     path: relativePath
   };
 }
-
-// src/tools/edit-text-file.ts
-import { existsSync as existsSync4, statSync as statSync4 } from "fs";
-import { readFile as readFile2, writeFile } from "fs/promises";
-import { dedent as dedent5 } from "ts-dedent";
-import { z as z4 } from "zod";
-var inputSchema4 = z4.object({
-  path: z4.string().describe("Target file path to edit."),
-  newText: z4.string().min(1).max(2e3).describe("Text to append to the file. Max 2000 characters."),
-  oldText: z4.string().min(1).max(2e3).describe("Exact text to find and replace. Max 2000 characters.")
+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: dedent5`
+    description: dedent`
       Text file editor for modifying existing files with precise text replacement.
 
       Use cases:
@@ -562,10 +497,10 @@ function editTextFileConfig() {
 async function editTextFileLocalMode(input) {
   const { path: path2, newText, oldText } = input;
   const validatedPath = await validatePath(path2);
-  if (!existsSync4(validatedPath)) {
+  if (!existsSync(validatedPath)) {
     throw new Error(`File ${path2} does not exist.`);
   }
-  const stats = statSync4(validatedPath);
+  const stats = statSync(validatedPath);
   if (!(stats.mode & 128)) {
     throw new Error(`File ${path2} is not writable`);
   }
@@ -589,13 +524,11 @@ async function editTextFileStudioMode(input) {
   }
   await editTextFileLocalMode(input);
   await deleteWorkspaceItem(existingItem.id);
-  const content = await readFile2(validatedPath, "utf-8");
+  const content = await readFile(validatedPath, "utf-8");
   await createWorkspaceItem(
     {
       type: "workspaceItemFile",
       path: relativePath,
-      owner: "expert",
-      lifecycle: "expertJob",
       permission: "readWrite"
     },
     content
@@ -610,7 +543,7 @@ function normalizeLineEndings(text) {
   return text.replace(/\r\n/g, "\n");
 }
 async function applyFileEdit(filePath, newText, oldText) {
-  const content = normalizeLineEndings(await readFile2(filePath, "utf-8"));
+  const content = normalizeLineEndings(await readFile(filePath, "utf-8"));
   const normalizedOld = normalizeLineEndings(oldText);
   const normalizedNew = normalizeLineEndings(newText);
   if (!content.includes(normalizedOld)) {
@@ -619,20 +552,117 @@ async function applyFileEdit(filePath, newText, oldText) {
   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"),
+  args: z.array(z.string()).describe("The arguments to pass to the command"),
+  env: z.record(z.string(), z.string()).describe("The environment variables to set"),
+  cwd: z.string().describe("The working directory to execute the command in"),
+  stdout: z.boolean().describe("Whether to capture the standard output"),
+  stderr: z.boolean().describe("Whether to capture the standard error"),
+  timeout: z.number().optional().describe("Timeout in milliseconds")
+});
+function execConfig() {
+  return {
+    title: "Execute Command",
+    description: dedent`
+      A tool for executing a command.
+      This tool helps execute a command with the given parameters.
+
+      When to use this tool:
+      - When you need to run system tasks or scripts.
+      - When automating the use of command-line tools or utilities.
+
+      Key features:
+      - Flexible Execution Environment: Specify environment variables, working directory, and arguments to tailor the command execution.
+      - Output Capture: Control whether to capture the standard output and standard error from the executed command.
+      - Simple Interface: A unified input schema consolidates all parameters needed for command execution.
 
-// src/tools/get-file-info.ts
-import { existsSync as existsSync5, statSync as statSync5 } from "fs";
-import { basename, dirname as dirname2, extname, resolve } from "path";
-import mime2 from "mime-types";
-import { dedent as dedent6 } from "ts-dedent";
-import { z as z5 } from "zod";
-var inputSchema5 = z5.object({
-  path: z5.string()
+      Parameters explained:
+      - command: The command to execute (e.g., \`ls\`, \`python\`).
+      - args: A list of arguments to pass to the command, functioning similarly to command-line input.
+      - env: A record of key-value pairs representing environment variables for the command's execution environment.
+      - cwd: The working directory in which the command will run; both relative and absolute paths are supported.
+      - stdout: A boolean flag indicating whether to capture the standard output (set to \`true\` to capture).
+      - stderr: A boolean flag indicating whether to capture the standard error (set to \`true\` to capture).
+      - timeout: The timeout in milliseconds for the command execution.
+
+      Rules:
+      - Safety: Only execute commands from trusted sources to avoid executing malicious code.
+      - Command Termination: Do not execute commands that remain running in the foreground (e.g., \`tail -f\`), as the tool requires commands to complete.
+      - Resource Management: Be cautious when running commands that may consume significant system resources or produce large amounts of output.
+      - Error Handling: Implement proper error handling to catch and manage any issues that arise during command execution.
+      - Parameter Validation: Ensure that all provided parameters adhere to the expected format to prevent unexpected behavior.
+    `,
+    inputSchema: execInputSchema.shape
+  };
+}
+async function exec(input) {
+  try {
+    const { stdout, stderr } = await execFileAsync(input.command, input.args, {
+      cwd: input.cwd,
+      env: { ...process.env, ...input.env },
+      timeout: input.timeout
+    });
+    let output = "";
+    if (input.stdout) {
+      output += stdout;
+    }
+    if (input.stderr) {
+      output += stderr;
+    }
+    if (!output.trim()) {
+      output = "Command executed successfully, but produced no output.";
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: output
+        }
+      ]
+    };
+  } catch (error) {
+    let errMsg = "";
+    const execError = error;
+    if (execError && (execError.killed || execError.signal === "SIGTERM") && typeof input.timeout === "number") {
+      errMsg = `Error: Command timed out after ${input.timeout}ms.
+`;
+    } else if (error instanceof Error) {
+      if (error.message.includes("timeout")) {
+        errMsg = `Error: Command timed out after ${input.timeout}ms.
+`;
+      } else {
+        errMsg = `Error: ${error.message}
+`;
+      }
+    } else {
+      errMsg = "An unknown error occurred.\n";
+    }
+    if (execError.stdout && input.stdout) {
+      errMsg += `Standard Output: ${execError.stdout}`;
+    }
+    if (execError.stderr && input.stderr) {
+      errMsg += `
+Standard Error: ${execError.stderr}`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: errMsg
+        }
+      ]
+    };
+  }
+}
+var inputSchema5 = z.object({
+  path: z.string()
 });
 function getFileInfoConfig() {
   return {
     title: "Get file info",
-    description: dedent6`
+    description: dedent`
       File information retriever for detailed metadata about files and directories.
 
       Use cases:
@@ -656,12 +686,12 @@ function getFileInfoConfig() {
 async function getFileInfoLocalMode(input) {
   const { path: path2 } = input;
   const validatedPath = await validatePath(path2);
-  if (!existsSync5(validatedPath)) {
+  if (!existsSync(validatedPath)) {
     throw new Error(`File or directory ${path2} does not exist`);
   }
-  const stats = statSync5(validatedPath);
+  const stats = statSync(validatedPath);
   const isDirectory = stats.isDirectory();
-  const mimeType = isDirectory ? null : mime2.lookup(validatedPath) || "application/octet-stream";
+  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"];
@@ -673,7 +703,7 @@ async function getFileInfoLocalMode(input) {
     path: validatedPath,
     absolutePath: resolve(validatedPath),
     name: basename(validatedPath),
-    directory: dirname2(validatedPath),
+    directory: dirname(validatedPath),
     extension: isDirectory ? null : extname(validatedPath),
     type: isDirectory ? "directory" : "file",
     mimeType,
@@ -714,20 +744,13 @@ async function getFileInfoStudioMode(input) {
     } : null
   };
 }
-
-// src/tools/list-directory.ts
-import { existsSync as existsSync6, statSync as statSync6 } from "fs";
-import { readdir } from "fs/promises";
-import { join } from "path";
-import { dedent as dedent7 } from "ts-dedent";
-import { z as z6 } from "zod";
-var inputSchema6 = z6.object({
-  path: z6.string()
+var inputSchema6 = z.object({
+  path: z.string()
 });
 function listDirectoryConfig() {
   return {
     title: "List directory",
-    description: dedent7`
+    description: dedent`
       Directory content lister with detailed file information.
 
       Use cases:
@@ -751,10 +774,10 @@ function listDirectoryConfig() {
 async function listDirectoryLocalMode(input) {
   const { path: path2 } = input;
   const validatedPath = await validatePath(path2);
-  if (!existsSync6(validatedPath)) {
+  if (!existsSync(validatedPath)) {
     throw new Error(`Directory ${path2} does not exist.`);
   }
-  const stats = statSync6(validatedPath);
+  const stats = statSync(validatedPath);
   if (!stats.isDirectory()) {
     throw new Error(`Path ${path2} is not a directory.`);
   }
@@ -763,7 +786,7 @@ async function listDirectoryLocalMode(input) {
   for (const entry of entries.sort()) {
     try {
       const fullPath = await validatePath(join(validatedPath, entry));
-      const entryStats = statSync6(fullPath);
+      const entryStats = statSync(fullPath);
       const item = {
         name: entry,
         path: entry,
@@ -807,21 +830,14 @@ async function listDirectoryStudioMode(input) {
     }))
   };
 }
-
-// src/tools/move-file.ts
-import { existsSync as existsSync7, statSync as statSync7 } from "fs";
-import { mkdir as mkdir2, rename } from "fs/promises";
-import { dirname as dirname3 } from "path";
-import { dedent as dedent8 } from "ts-dedent";
-import { z as z7 } from "zod";
-var inputSchema7 = z7.object({
-  source: z7.string(),
-  destination: z7.string()
+var inputSchema7 = z.object({
+  source: z.string(),
+  destination: z.string()
 });
 function moveFileConfig() {
   return {
     title: "Move file",
-    description: dedent8`
+    description: dedent`
       File mover for relocating or renaming files within the workspace.
 
       Use cases:
@@ -847,18 +863,18 @@ async function moveFileLocalMode(input) {
   const { source, destination } = input;
   const validatedSource = await validatePath(source);
   const validatedDestination = await validatePath(destination);
-  if (!existsSync7(validatedSource)) {
+  if (!existsSync(validatedSource)) {
     throw new Error(`Source file ${source} does not exist.`);
   }
-  const sourceStats = statSync7(validatedSource);
+  const sourceStats = statSync(validatedSource);
   if (!(sourceStats.mode & 128)) {
     throw new Error(`Source file ${source} is not writable`);
   }
-  if (existsSync7(validatedDestination)) {
+  if (existsSync(validatedDestination)) {
     throw new Error(`Destination ${destination} already exists.`);
   }
-  const destDir = dirname3(validatedDestination);
-  await mkdir2(destDir, { recursive: true });
+  const destDir = dirname(validatedDestination);
+  await mkdir(destDir, { recursive: true });
   await rename(validatedSource, validatedDestination);
   return {
     source: validatedSource,
@@ -879,15 +895,13 @@ async function moveFileStudioMode(input) {
   if (destItem) {
     throw new Error(`Destination ${relativeDestination} already exists.`);
   }
-  const destDir = dirname3(relativeDestination);
+  const destDir = dirname(relativeDestination);
   if (destDir !== "." && destDir !== "/") {
     const destDirItem = await findWorkspaceItem(destDir);
     if (!destDirItem) {
       await createWorkspaceItem({
         type: "workspaceItemDirectory",
         path: destDir,
-        owner: "expert",
-        lifecycle: "expertJob",
         permission: "readWrite"
       });
     }
@@ -901,21 +915,14 @@ async function moveFileStudioMode(input) {
     destination: relativeDestination
   };
 }
-
-// src/tools/read-image-file.ts
-import { existsSync as existsSync8 } from "fs";
-import { stat } from "fs/promises";
-import mime3 from "mime-types";
-import { dedent as dedent9 } from "ts-dedent";
-import { z as z8 } from "zod";
 var MAX_IMAGE_SIZE = 15 * 1024 * 1024;
-var inputSchema8 = z8.object({
-  path: z8.string()
+var inputSchema8 = z.object({
+  path: z.string()
 });
 function readImageFileConfig() {
   return {
     title: "Read image file",
-    description: dedent9`
+    description: dedent`
       Image file reader that converts images to base64 encoded strings with MIME type validation.
 
       Use cases:
@@ -944,11 +951,11 @@ function readImageFileConfig() {
 async function readImageFile(input) {
   const { path: path2 } = input;
   const validatedPath = await validatePath(path2);
-  const isFile = existsSync8(validatedPath);
+  const isFile = existsSync(validatedPath);
   if (!isFile) {
     throw new Error(`File ${path2} does not exist.`);
   }
-  const mimeType = mime3.lookup(validatedPath);
+  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.`);
   }
@@ -965,21 +972,14 @@ async function readImageFile(input) {
     size: fileStats.size
   };
 }
-
-// src/tools/read-pdf-file.ts
-import { existsSync as existsSync9 } from "fs";
-import { stat as stat2 } from "fs/promises";
-import mime4 from "mime-types";
-import { dedent as dedent10 } from "ts-dedent";
-import { z as z9 } from "zod";
 var MAX_PDF_SIZE = 30 * 1024 * 1024;
-var inputSchema9 = z9.object({
-  path: z9.string()
+var inputSchema9 = z.object({
+  path: z.string()
 });
 function readPdfFileConfig() {
   return {
     title: "Read PDF file",
-    description: dedent10`
+    description: dedent`
       PDF file reader that converts documents to base64 encoded resources.
 
       Use cases:
@@ -1004,15 +1004,15 @@ function readPdfFileConfig() {
 async function readPdfFile(input) {
   const { path: path2 } = input;
   const validatedPath = await validatePath(path2);
-  const isFile = existsSync9(validatedPath);
+  const isFile = existsSync(validatedPath);
   if (!isFile) {
     throw new Error(`File ${path2} does not exist.`);
   }
-  const mimeType = mime4.lookup(validatedPath);
+  const mimeType = mime.lookup(validatedPath);
   if (mimeType !== "application/pdf") {
     throw new Error(`File ${path2} is not a PDF file.`);
   }
-  const fileStats = await stat2(validatedPath);
+  const fileStats = await stat(validatedPath);
   const fileSizeMB = fileStats.size / (1024 * 1024);
   if (fileStats.size > MAX_PDF_SIZE) {
     throw new Error(
@@ -1025,21 +1025,15 @@ async function readPdfFile(input) {
     size: fileStats.size
   };
 }
-
-// src/tools/read-text-file.ts
-import { existsSync as existsSync10 } from "fs";
-import { readFile as readFile3 } from "fs/promises";
-import { dedent as dedent11 } from "ts-dedent";
-import { z as z10 } from "zod";
-var inputSchema10 = z10.object({
-  path: z10.string(),
-  from: z10.number().optional().describe("The line number to start reading from."),
-  to: z10.number().optional().describe("The line number to stop reading at.")
+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: dedent11`
+    description: dedent`
       Text file reader with line range support for UTF-8 encoded files.
 
       Use cases:
@@ -1066,11 +1060,11 @@ function readTextFileConfig() {
 async function readTextFile(input) {
   const { path: path2, from, to } = input;
   const validatedPath = await validatePath(path2);
-  const isFile = existsSync10(validatedPath);
+  const isFile = existsSync(validatedPath);
   if (!isFile) {
     throw new Error(`File ${path2} does not exist.`);
   }
-  const fileContent = await readFile3(validatedPath, "utf-8");
+  const fileContent = await readFile(validatedPath, "utf-8");
   const lines = fileContent.split("\n");
   const fromLine = from ?? 0;
   const toLine = to ?? lines.length;
@@ -1083,17 +1077,13 @@ async function readTextFile(input) {
     to: toLine
   };
 }
-
-// src/tools/test-url.ts
-import { dedent as dedent12 } from "ts-dedent";
-import { z as z11 } from "zod";
-var inputSchema11 = z11.object({
-  urls: z11.array(z11.string()).min(1).max(10).describe("Array of URLs to test (max 10 URLs).")
+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: dedent12`
+    description: dedent`
       URL tester that validates multiple URLs and extracts metadata.
 
       Use cases:
@@ -1191,18 +1181,14 @@ function extractDescription(html) {
   }
   return "";
 }
-
-// src/tools/think.ts
-import { dedent as dedent13 } from "ts-dedent";
-import { z as z12 } from "zod";
-var inputSchema12 = z12.object({
-  thought: z12.string().describe("Your current thinking step"),
-  nextThoughtNeeded: z12.boolean().optional().describe("true if you need more thinking, even if at what seemed like the end")
+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: dedent13`
+    description: dedent`
       Sequential thinking tool for step-by-step problem analysis and solution development.
 
       Use cases:
@@ -1247,10 +1233,6 @@ var thought = new Thought();
 async function think(input) {
   return thought.processThought(input);
 }
-
-// src/tools/todo.ts
-import { dedent as dedent14 } from "ts-dedent";
-import { z as z13 } from "zod";
 var Todo = class {
   currentTodoId = 0;
   todos = [];
@@ -1280,14 +1262,14 @@ var Todo = class {
   }
 };
 var todoSingleton = new Todo();
-var todoInputSchema = z13.object({
-  newTodos: z13.array(z13.string()).describe("New todos to add").optional(),
-  completedTodos: z13.array(z13.number()).describe("Todo ids that are completed").optional()
+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: dedent14`
+    description: dedent`
       Todo list manager that tracks tasks and their completion status.
 
       Use cases:
@@ -1310,11 +1292,11 @@ function todoConfig() {
 async function todo(input) {
   return todoSingleton.processTodo(input);
 }
-var clearTodoInputSchema = z13.object({});
+var clearTodoInputSchema = z.object({});
 function clearTodoConfig() {
   return {
     title: "clearTodo",
-    description: dedent14`
+    description: dedent`
       Clears the todo list.
 
       Use cases:
@@ -1332,22 +1314,14 @@ function clearTodoConfig() {
 async function clearTodo(input) {
   return todoSingleton.clearTodo();
 }
-
-// src/tools/write-text-file.ts
-import { existsSync as existsSync11, statSync as statSync8 } from "fs";
-import { writeFile as writeFile2 } from "fs/promises";
-import { mkdir as mkdir3 } from "fs/promises";
-import { dirname as dirname4 } from "path";
-import { dedent as dedent15 } from "ts-dedent";
-import { z as z14 } from "zod";
-var toolInputSchema = z14.object({
-  path: z14.string().describe("Target file path (relative or absolute)."),
-  text: z14.string().min(1).max(1e4).describe("Text to write to the file. Max 10000 characters.")
+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: dedent15`
+    description: dedent`
       Text file writer that creates or overwrites files with UTF-8 content.
 
       Use cases:
@@ -1372,15 +1346,15 @@ function writeTextFileConfig() {
 async function writeTextFileLocalMode(input) {
   const { path: path2, text } = input;
   const validatedPath = await validatePath(path2);
-  if (existsSync11(validatedPath)) {
-    const stats = statSync8(validatedPath);
+  if (existsSync(validatedPath)) {
+    const stats = statSync(validatedPath);
     if (!(stats.mode & 128)) {
       throw new Error(`File ${path2} is not writable`);
     }
   }
-  const dir = dirname4(validatedPath);
-  await mkdir3(dir, { recursive: true });
-  await writeFile2(validatedPath, text, "utf-8");
+  const dir = dirname(validatedPath);
+  await mkdir(dir, { recursive: true });
+  await writeFile(validatedPath, text, "utf-8");
   return {
     path: validatedPath,
     text
@@ -1406,8 +1380,6 @@ async function writeTextFileStudioMode(input) {
       await createWorkspaceItem({
         type: "workspaceItemDirectory",
         path: currentPath,
-        owner: "expert",
-        lifecycle: "expertJob",
         permission: "readWrite"
       });
     }
@@ -1416,8 +1388,6 @@ async function writeTextFileStudioMode(input) {
     {
       type: "workspaceItemFile",
       path: relativePath,
-      owner: "expert",
-      lifecycle: "expertJob",
       permission: "readWrite"
     },
     text
@@ -1429,77 +1399,6 @@ async function writeTextFileStudioMode(input) {
   };
 }
 
-// src/index.ts
-async function main() {
-  const program = new Command();
-  program.name(package_default.name).description(package_default.description).version(package_default.version, "-v, --version", "display the version number").action(async () => {
-    const server = new McpServer(
-      {
-        name: package_default.name,
-        version: package_default.version
-      },
-      {
-        capabilities: {
-          tools: {}
-        }
-      }
-    );
-    server.registerTool(
-      "attemptCompletion",
-      attemptCompletionConfig(),
-      resolveToolByMode(attemptCompletion)
-    );
-    server.registerTool("think", thinkConfig(), resolveToolByMode(think));
-    server.registerTool("todo", todoConfig(), resolveToolByMode(todo));
-    server.registerTool("clearTodo", clearTodoConfig(), resolveToolByMode(clearTodo));
-    server.registerTool("testUrl", testUrlConfig(), resolveToolByMode(testUrls));
-    server.registerTool(
-      "getFileInfo",
-      getFileInfoConfig(),
-      resolveToolByMode(getFileInfoLocalMode, getFileInfoStudioMode)
-    );
-    server.registerTool("readTextFile", readTextFileConfig(), resolveToolByMode(readTextFile));
-    server.registerTool("readImageFile", readImageFileConfig(), resolveToolByMode(readImageFile));
-    server.registerTool("readPdfFile", readPdfFileConfig(), resolveToolByMode(readPdfFile));
-    server.registerTool(
-      "writeTextFile",
-      writeTextFileConfig(),
-      resolveToolByMode(writeTextFileLocalMode, writeTextFileStudioMode)
-    );
-    server.registerTool(
-      "appendTextFile",
-      appendTextFileConfig(),
-      resolveToolByMode(appendTextFileLocalMode, appendTextFileStudioMode)
-    );
-    server.registerTool(
-      "editTextFile",
-      editTextFileConfig(),
-      resolveToolByMode(editTextFileLocalMode, editTextFileStudioMode)
-    );
-    server.registerTool(
-      "moveFile",
-      moveFileConfig(),
-      resolveToolByMode(moveFileLocalMode, moveFileStudioMode)
-    );
-    server.registerTool(
-      "deleteFile",
-      deleteFileConfig(),
-      resolveToolByMode(deleteFileLocalMode, deleteFileStudioMode)
-    );
-    server.registerTool(
-      "listDirectory",
-      listDirectoryConfig(),
-      resolveToolByMode(listDirectoryLocalMode, listDirectoryStudioMode)
-    );
-    server.registerTool(
-      "createDirectory",
-      createDirectoryConfig(),
-      resolveToolByMode(createDirectoryLocalMode, createDirectoryStudioMode)
-    );
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-  });
-  program.parse();
-}
-main();
+export { WorkspaceMode, appendTextFileConfig, appendTextFileLocalMode, appendTextFileStudioMode, attemptCompletion, attemptCompletionConfig, clearTodo, clearTodoConfig, createDirectoryConfig, createDirectoryLocalMode, createDirectoryStudioMode, createWorkspaceItem, deleteFileConfig, deleteFileLocalMode, deleteFileStudioMode, deleteWorkspaceItem, editTextFileConfig, editTextFileLocalMode, editTextFileStudioMode, exec, execConfig, findWorkspaceItem, getFileInfoConfig, getFileInfoLocalMode, getFileInfoStudioMode, getWorkspaceApiConfig, getWorkspaceItemContent, getWorkspaceItems, getWorkspaceMode, listDirectoryConfig, listDirectoryLocalMode, listDirectoryStudioMode, moveFileConfig, moveFileLocalMode, moveFileStudioMode, readImageFile, readImageFileConfig, readPdfFile, readPdfFileConfig, readTextFile, readTextFileConfig, resolveToolByMode, testUrlConfig, testUrls, think, thinkConfig, todo, todoConfig, updateWorkspaceItem, validatePath, workspacePath, writeTextFileConfig, writeTextFileLocalMode, writeTextFileStudioMode };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map