@perstack/base 0.0.6 → 0.0.8

package/dist/index.js

@@ -1,63 +1,14 @@
-#!/usr/bin/env node
-
-// 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.6",
-  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/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";
+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/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 === "~") {
@@ -95,9 +46,11 @@ async function validatePath(requestedPath) {
     }
   }
 }
-
-// src/lib/workspace-api.ts
-import mime from "mime-types";
+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;
@@ -249,99 +202,69 @@ 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/tools/append-text-file.ts
-var toolName = "appendTextFile";
-var toolDescription = dedent`
-  Text file appender for 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
-`;
-var toolInputSchema = {
+// src/lib/register-tool.ts
+function resolveToolByMode(localModeFunction, studioModeFunction) {
+  const mode = getWorkspaceMode();
+  const func = !studioModeFunction ? localModeFunction : mode === "local" /* LOCAL */ ? localModeFunction : studioModeFunction;
+  return async (input) => {
+    try {
+      const result = await func(input);
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    } catch (e) {
+      if (e instanceof Error) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: e.name, message: e.message }) }]
+        };
+      }
+      throw e;
+    }
+  };
+}
+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 addAppendTextFileTool(server) {
-  const mode = getWorkspaceMode();
-  switch (mode) {
-    case "local" /* LOCAL */: {
-      server.tool(
-        toolName,
-        `${toolDescription}
+});
+function appendTextFileConfig() {
+  return {
+    title: "Append text file",
+    description: dedent`
+      Adding content to the end of existing files.
 
-Mode: Local (Local filesystem)`,
-        toolInputSchema,
-        async ({ path: path2, text }) => {
-          try {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(await appendTextFileLocalMode(path2, text))
-                }
-              ]
-            };
-          } catch (e) {
-            if (e instanceof Error) {
-              return {
-                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-              };
-            }
-            throw e;
-          }
-        }
-      );
-      break;
-    }
-    case "studio" /* STUDIO */: {
-      server.tool(
-        toolName,
-        `${toolDescription}
+      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
 
-Mode: Studio (Workspace API)`,
-        toolInputSchema,
-        async ({ path: path2, text }) => {
-          try {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(await appendTextFileStudioMode(path2, text))
-                }
-              ]
-            };
-          } catch (e) {
-            if (e instanceof Error) {
-              return {
-                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-              };
-            }
-            throw e;
-          }
-        }
-      );
-      break;
-    }
-  }
+      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 appendTextFileLocalMode(path2, text) {
+async function appendTextFileLocalMode(input) {
+  const { path: path2, text } = input;
   const validatedPath = await validatePath(path2);
   if (!existsSync(validatedPath)) {
     throw new Error(`File ${path2} does not exist.`);
@@ -351,12 +274,10 @@ async function appendTextFileLocalMode(path2, text) {
     throw new Error(`File ${path2} is not writable`);
   }
   await appendFile(validatedPath, text);
-  return {
-    path: validatedPath,
-    text
-  };
+  return { path: validatedPath, text };
 }
-async function appendTextFileStudioMode(path2, text) {
+async function appendTextFileStudioMode(input) {
+  const { path: path2, text } = input;
   const validatedPath = await validatePath(path2);
   const relativePath = validatedPath.startsWith(workspacePath) ? validatedPath.slice(workspacePath.length + 1) : validatedPath;
   const existingItem = await findWorkspaceItem(relativePath);
@@ -366,161 +287,83 @@ async function appendTextFileStudioMode(path2, text) {
   if (existingItem.type === "workspaceItemDirectory") {
     throw new Error(`Path ${relativePath} is a directory.`);
   }
-  await appendTextFileLocalMode(path2, text);
+  await appendTextFileLocalMode(input);
   await deleteWorkspaceItem(existingItem.id);
   const content = await readFile(validatedPath, "utf-8");
   await createWorkspaceItem(
     {
       type: "workspaceItemFile",
       path: relativePath,
-      owner: "expert",
-      lifecycle: "expertJob",
       permission: "readWrite"
     },
     content
   );
+  return { path: relativePath, text };
+}
+function attemptCompletionConfig() {
   return {
-    path: relativePath,
-    text
+    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: {}
   };
 }
-
-// src/tools/attempt-completion.ts
-import { dedent as dedent2 } from "ts-dedent";
-var addAttemptCompletionTool = (server) => {
-  server.tool(
-    "attemptCompletion",
-    dedent2`
-        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
-      `,
-    {},
-    attemptCompletion
-  );
-};
 async function attemptCompletion() {
   return {
-    content: [
-      {
-        type: "text",
-        text: "End the agent loop and provide a final report"
-      }
-    ]
+    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.
 
-// 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 toolName2 = "createDirectory";
-var toolDescription2 = dedent3`
-  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
-`;
-var toolInputSchema2 = {
-  path: z2.string()
-};
-function addCreateDirectoryTool(server) {
-  const mode = getWorkspaceMode();
-  switch (mode) {
-    case "local" /* LOCAL */: {
-      server.tool(
-        toolName2,
-        `${toolDescription2}
-
-Mode: Local (Local filesystem)`,
-        toolInputSchema2,
-        async ({ path: path2 }) => {
-          try {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(await createDirectoryLocalMode(path2))
-                }
-              ]
-            };
-          } catch (e) {
-            if (e instanceof Error) {
-              return {
-                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-              };
-            }
-            throw e;
-          }
-        }
-      );
-      break;
-    }
-    case "studio" /* STUDIO */: {
-      server.tool(
-        toolName2,
-        `${toolDescription2}
+      Use cases:
+      - Setting up project directory structure
+      - Creating output folders for generated content
+      - Organizing files into logical groups
+      - Preparing directory hierarchies
 
-Mode: Studio (Workspace API)`,
-        toolInputSchema2,
-        async ({ path: path2 }) => {
-          try {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(await createDirectoryStudioMode(path2))
-                }
-              ]
-            };
-          } catch (e) {
-            if (e instanceof Error) {
-              return {
-                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-              };
-            }
-            throw e;
-          }
-        }
-      );
-      break;
-    }
-  }
+      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 createDirectoryLocalMode(path2) {
+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`);
     }
@@ -530,7 +373,8 @@ async function createDirectoryLocalMode(path2) {
     path: validatedPath
   };
 }
-async function createDirectoryStudioMode(path2) {
+async function createDirectoryStudioMode(input) {
+  const { path: path2 } = input;
   const validatedPath = await validatePath(path2);
   const relativePath = validatedPath.startsWith(workspacePath) ? validatedPath.slice(workspacePath.length + 1) : validatedPath;
   const existingItem = await findWorkspaceItem(relativePath);
@@ -546,114 +390,49 @@ async function createDirectoryStudioMode(path2) {
       await createWorkspaceItem({
         type: "workspaceItemDirectory",
         path: currentPath,
-        owner: "expert",
-        lifecycle: "expertJob",
         permission: "readWrite"
       });
     }
   }
-  await createDirectoryLocalMode(path2);
+  await createDirectoryLocalMode(input);
   return {
     path: relativePath
   };
 }
+var inputSchema3 = z.object({
+  path: z.string()
+});
+function deleteFileConfig() {
+  return {
+    title: "Delete file",
+    description: dedent`
+      File deleter for removing files from the workspace.
 
-// 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 toolName3 = "deleteFile";
-var toolDescription3 = dedent4`
-  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
-  - Removes file from both filesystem and workspace API
-  - Returns deletion status
-  
-  Parameters:
-  - path: File path to delete
-`;
-var toolInputSchema3 = {
-  path: z3.string()
-};
-function addDeleteFileTool(server) {
-  const mode = getWorkspaceMode();
-  switch (mode) {
-    case "local" /* LOCAL */: {
-      server.tool(
-        toolName3,
-        `${toolDescription3}
-
-Mode: Local (Local filesystem)`,
-        toolInputSchema3,
-        async ({ path: path2 }) => {
-          try {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(await deleteFileLocalMode(path2))
-                }
-              ]
-            };
-          } catch (e) {
-            if (e instanceof Error) {
-              return {
-                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-              };
-            }
-            throw e;
-          }
-        }
-      );
-      break;
-    }
-    case "studio" /* STUDIO */: {
-      server.tool(
-        toolName3,
-        `${toolDescription3}
+      Use cases:
+      - Removing temporary files
+      - Cleaning up generated files
+      - Deleting outdated configuration files
+      - Removing unwanted artifacts
 
-Mode: Studio (Workspace API)`,
-        toolInputSchema3,
-        async ({ path: path2 }) => {
-          try {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(await deleteFileStudioMode(path2))
-                }
-              ]
-            };
-          } catch (e) {
-            if (e instanceof Error) {
-              return {
-                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-              };
-            }
-            throw e;
-          }
-        }
-      );
-      break;
-    }
-  }
+      How it works:
+      - Validates file existence and permissions
+      - Performs atomic delete operation
+      - Removes file from both filesystem and workspace API
+      - Returns deletion status
+      
+      Parameters:
+      - path: File path to delete
+    `,
+    inputSchema: inputSchema3.shape
+  };
 }
-async function deleteFileLocalMode(path2) {
+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.`);
   }
@@ -665,7 +444,8 @@ async function deleteFileLocalMode(path2) {
     path: validatedPath
   };
 }
-async function deleteFileStudioMode(path2) {
+async function deleteFileStudioMode(input) {
+  const { path: path2 } = input;
   const validatedPath = await validatePath(path2);
   const relativePath = validatedPath.startsWith(workspacePath) ? validatedPath.slice(workspacePath.length + 1) : validatedPath;
   const existingItem = await findWorkspaceItem(relativePath);
@@ -675,115 +455,52 @@ async function deleteFileStudioMode(path2) {
   if (existingItem.type === "workspaceItemDirectory") {
     throw new Error(`Path ${relativePath} is a directory. Use delete directory tool instead.`);
   }
-  await deleteFileLocalMode(path2);
+  await deleteFileLocalMode(input);
   await deleteWorkspaceItem(existingItem.id);
   return {
     path: relativePath
   };
 }
+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.
 
-// 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 toolName4 = "editTextFile";
-var toolDescription4 = dedent5`
-  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
-`;
-var toolInputSchema4 = {
-  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.")
-};
-function addEditTextFileTool(server) {
-  const mode = getWorkspaceMode();
-  switch (mode) {
-    case "local" /* LOCAL */: {
-      server.tool(
-        toolName4,
-        `${toolDescription4}
-
-Mode: Local (Local filesystem)`,
-        toolInputSchema4,
-        async ({ path: path2, newText, oldText }) => {
-          try {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(await editTextFileLocalMode(path2, newText, oldText))
-                }
-              ]
-            };
-          } catch (e) {
-            if (e instanceof Error) {
-              return {
-                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-              };
-            }
-            throw e;
-          }
-        }
-      );
-      break;
-    }
-    case "studio" /* STUDIO */: {
-      server.tool(
-        toolName4,
-        `${toolDescription4}
+      Use cases:
+      - Updating configuration values
+      - Modifying code snippets
+      - Replacing specific text blocks
+      - Making targeted edits to files
 
-Mode: Studio (Workspace API)`,
-        toolInputSchema4,
-        async ({ path: path2, oldText, newText }) => {
-          try {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(await editTextFileStudioMode(path2, newText, oldText))
-                }
-              ]
-            };
-          } catch (e) {
-            if (e instanceof Error) {
-              return {
-                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-              };
-            }
-            throw e;
-          }
-        }
-      );
-      break;
-    }
-  }
+      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 editTextFileLocalMode(path2, newText, oldText) {
+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`);
   }
@@ -794,7 +511,8 @@ async function editTextFileLocalMode(path2, newText, oldText) {
     oldText
   };
 }
-async function editTextFileStudioMode(path2, newText, oldText) {
+async function editTextFileStudioMode(input) {
+  const { path: path2, newText, oldText } = input;
   const validatedPath = await validatePath(path2);
   const relativePath = validatedPath.startsWith(workspacePath) ? validatedPath.slice(workspacePath.length + 1) : validatedPath;
   const existingItem = await findWorkspaceItem(relativePath);
@@ -804,15 +522,13 @@ async function editTextFileStudioMode(path2, newText, oldText) {
   if (existingItem.type === "workspaceItemDirectory") {
     throw new Error(`Path ${relativePath} is a directory.`);
   }
-  await editTextFileLocalMode(path2, newText, oldText);
+  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
@@ -827,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)) {
@@ -836,106 +552,146 @@ async function applyFileEdit(filePath, newText, oldText) {
   const modifiedContent = content.replace(normalizedOld, normalizedNew);
   await writeFile(filePath, modifiedContent, "utf-8");
 }
-
-// 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 toolName5 = "getFileInfo";
-var toolDescription5 = dedent6`
-  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
-`;
-var toolInputSchema5 = {
-  path: z5.string()
-};
-function addGetFileInfoTool(server) {
-  const mode = getWorkspaceMode();
-  switch (mode) {
-    case "local" /* LOCAL */: {
-      server.tool(
-        toolName5,
-        `${toolDescription5}
-
-Mode: Local (Local filesystem)`,
-        toolInputSchema5,
-        async ({ path: path2 }) => {
-          try {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(await getFileInfoLocalMode(path2))
-                }
-              ]
-            };
-          } catch (e) {
-            if (e instanceof Error) {
-              return {
-                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-              };
-            }
-            throw e;
-          }
-        }
-      );
-      break;
+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.
+
+      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;
     }
-    case "studio" /* STUDIO */: {
-      server.tool(
-        toolName5,
-        `${toolDescription5}
-
-Mode: Studio (Workspace API + Local filesystem)`,
-        toolInputSchema5,
-        async ({ path: path2 }) => {
-          try {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(await getFileInfoStudioMode(path2))
-                }
-              ]
-            };
-          } catch (e) {
-            if (e instanceof Error) {
-              return {
-                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-              };
-            }
-            throw e;
-          }
+    if (input.stderr) {
+      output += stderr;
+    }
+    if (!output.trim()) {
+      output = "Command executed successfully, but produced no output.";
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: output
         }
-      );
-      break;
+      ]
+    };
+  } 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
+        }
+      ]
+    };
   }
 }
-async function getFileInfoLocalMode(path2) {
+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 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"];
@@ -947,7 +703,7 @@ async function getFileInfoLocalMode(path2) {
     path: validatedPath,
     absolutePath: resolve(validatedPath),
     name: basename(validatedPath),
-    directory: dirname2(validatedPath),
+    directory: dirname(validatedPath),
     extension: isDirectory ? null : extname(validatedPath),
     type: isDirectory ? "directory" : "file",
     mimeType,
@@ -963,10 +719,11 @@ async function getFileInfoLocalMode(path2) {
     }
   };
 }
-async function getFileInfoStudioMode(path2) {
+async function getFileInfoStudioMode(input) {
+  const { path: path2 } = input;
   const validatedPath = await validatePath(path2);
   const relativePath = validatedPath.startsWith(workspacePath) ? validatedPath.slice(workspacePath.length + 1) : validatedPath;
-  const localInfo = await getFileInfoLocalMode(path2);
+  const localInfo = await getFileInfoLocalMode(input);
   const workspaceItem = await findWorkspaceItem(relativePath);
   return {
     ...localInfo,
@@ -987,104 +744,40 @@ async function getFileInfoStudioMode(path2) {
     } : null
   };
 }
+var inputSchema6 = z.object({
+  path: z.string()
+});
+function listDirectoryConfig() {
+  return {
+    title: "List directory",
+    description: dedent`
+      Directory content lister with detailed file information.
 
-// 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 toolName6 = "listDirectory";
-var toolDescription6 = dedent7`
-  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)
-`;
-var toolInputSchema6 = {
-  path: z6.string().optional()
-};
-function addListDirectoryTool(server) {
-  const mode = getWorkspaceMode();
-  switch (mode) {
-    case "local" /* LOCAL */: {
-      server.tool(
-        toolName6,
-        `${toolDescription6}
-
-Mode: Local (Local filesystem)`,
-        toolInputSchema6,
-        async ({ path: path2 = "." }) => {
-          try {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(await listDirectoryLocalMode(path2))
-                }
-              ]
-            };
-          } catch (e) {
-            if (e instanceof Error) {
-              return {
-                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-              };
-            }
-            throw e;
-          }
-        }
-      );
-      break;
-    }
-    case "studio" /* STUDIO */: {
-      server.tool(
-        toolName6,
-        `${toolDescription6}
+      Use cases:
+      - Exploring project structure
+      - Finding files in a directory
+      - Checking directory contents before operations
+      - Understanding file organization
 
-Mode: Studio (Workspace API)`,
-        toolInputSchema6,
-        async ({ path: path2 = "." }) => {
-          try {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(await listDirectoryStudioMode(path2))
-                }
-              ]
-            };
-          } catch (e) {
-            if (e instanceof Error) {
-              return {
-                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-              };
-            }
-            throw e;
-          }
-        }
-      );
-      break;
-    }
-  }
+      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 listDirectoryLocalMode(path2) {
+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.`);
   }
@@ -1093,7 +786,7 @@ async function listDirectoryLocalMode(path2) {
   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,
@@ -1114,7 +807,8 @@ async function listDirectoryLocalMode(path2) {
     items
   };
 }
-async function listDirectoryStudioMode(path2) {
+async function listDirectoryStudioMode(input) {
+  const { path: path2 } = input;
   const validatedPath = await validatePath(path2);
   const relativePath = validatedPath.startsWith(workspacePath) ? validatedPath.slice(workspacePath.length + 1) : validatedPath;
   const workspaceItems = await getWorkspaceItems();
@@ -1136,122 +830,59 @@ async function listDirectoryStudioMode(path2) {
     }))
   };
 }
+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.
 
-// 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 toolName7 = "moveFile";
-var toolDescription7 = dedent8`
-  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
-`;
-var toolInputSchema7 = {
-  source: z7.string(),
-  destination: z7.string()
-};
-function addMoveFileTool(server) {
-  const mode = getWorkspaceMode();
-  switch (mode) {
-    case "local" /* LOCAL */: {
-      server.tool(
-        toolName7,
-        `${toolDescription7}
-
-Mode: Local (Local filesystem)`,
-        toolInputSchema7,
-        async ({ source, destination }) => {
-          try {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(await moveFileLocalMode(source, destination))
-                }
-              ]
-            };
-          } catch (e) {
-            if (e instanceof Error) {
-              return {
-                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-              };
-            }
-            throw e;
-          }
-        }
-      );
-      break;
-    }
-    case "studio" /* STUDIO */: {
-      server.tool(
-        toolName7,
-        `${toolDescription7}
+      Use cases:
+      - Renaming files to follow naming conventions
+      - Moving files to different directories
+      - Organizing project structure
+      - Backing up files before modifications
 
-Mode: Studio (Workspace API)`,
-        toolInputSchema7,
-        async ({ source, destination }) => {
-          try {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(await moveFileStudioMode(source, destination))
-                }
-              ]
-            };
-          } catch (e) {
-            if (e instanceof Error) {
-              return {
-                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-              };
-            }
-            throw e;
-          }
-        }
-      );
-      break;
-    }
-  }
+      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 moveFileLocalMode(source, destination) {
+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,
     destination: validatedDestination
   };
 }
-async function moveFileStudioMode(source, destination) {
+async function moveFileStudioMode(input) {
+  const { source, destination } = input;
   const validatedSource = await validatePath(source);
   const validatedDestination = await validatePath(destination);
   const relativeSource = validatedSource.startsWith(workspacePath) ? validatedSource.slice(workspacePath.length + 1) : validatedSource;
@@ -1264,15 +895,13 @@ async function moveFileStudioMode(source, destination) {
   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"
       });
     }
@@ -1280,75 +909,53 @@ async function moveFileStudioMode(source, destination) {
   await updateWorkspaceItem(sourceItem.id, {
     path: relativeDestination
   });
-  await moveFileLocalMode(source, destination);
+  await moveFileLocalMode(input);
   return {
     source: relativeSource,
     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 toolName8 = "readImageFile";
-var toolDescription8 = dedent9`
-  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
+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.
 
-  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
+      Use cases:
+      - Loading images for LLM to process
+      - Retrieving image data for analysis or display
+      - Converting workspace image files to base64 format
 
-  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)
-`;
-var toolInputSchema8 = {
-  path: z8.string()
-};
-function addReadImageFileTool(server) {
-  server.tool(toolName8, toolDescription8, toolInputSchema8, async ({ path: path2 }) => {
-    try {
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(await readImageFile(path2))
-          }
-        ]
-      };
-    } catch (e) {
-      if (e instanceof Error) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-        };
-      }
-      throw e;
-    }
-  });
+      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(path2) {
+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.`);
   }
@@ -1365,69 +972,47 @@ async function readImageFile(path2) {
     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 toolName9 = "readPdfFile";
-var toolDescription9 = dedent10`
-  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
+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.
 
-  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
+      Use cases:
+      - Extracting content from PDF documents for analysis
+      - Loading PDF files for LLM processing
+      - Retrieving PDF data for conversion or manipulation
 
-  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
-`;
-var toolInputSchema9 = {
-  path: z9.string()
-};
-function addReadPdfFileTool(server) {
-  server.tool(toolName9, toolDescription9, toolInputSchema9, async ({ path: path2 }) => {
-    try {
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(await readPdfFile(path2))
-          }
-        ]
-      };
-    } catch (e) {
-      if (e instanceof Error) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-        };
-      }
-      throw e;
-    }
-  });
+      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(path2) {
+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(
@@ -1440,67 +1025,46 @@ async function readPdfFile(path2) {
     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.
 
-// src/tools/read-text-file.ts
-import { existsSync as existsSync10 } from "fs";
-import { readFile as readFile4 } from "fs/promises";
-import { dedent as dedent11 } from "ts-dedent";
-import { z as z10 } from "zod";
-var toolName10 = "readTextFile";
-var toolDescription10 = dedent11`
-  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
+      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
 
-  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
-`;
-var toolInputSchema10 = {
-  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.")
-};
-function addReadTextFileTool(server) {
-  server.tool(toolName10, toolDescription10, toolInputSchema10, async ({ path: path2, from, to }) => {
-    try {
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(await readTextFile(path2, from, to))
-          }
-        ]
-      };
-    } catch (e) {
-      if (e instanceof Error) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-        };
-      }
-      throw e;
-    }
-  });
+      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(path2, from, to) {
+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 readFile4(validatedPath, "utf-8");
+  const fileContent = await readFile(validatedPath, "utf-8");
   const lines = fileContent.split("\n");
   const fromLine = from ?? 0;
   const toLine = to ?? lines.length;
@@ -1513,58 +1077,38 @@ async function readTextFile(path2, from, to) {
     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.
 
-// src/tools/test-url.ts
-import { dedent as dedent12 } from "ts-dedent";
-import { z as z11 } from "zod";
-var toolName11 = "testUrl";
-var toolDescription11 = dedent12`
-  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
+      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
 
-  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
-`;
-var toolInputSchema11 = {
-  urls: z11.array(z11.string()).min(1).max(10).describe("Array of URLs to test (max 10 URLs).")
-};
-function addTestUrlTool(server) {
-  server.tool(toolName11, toolDescription11, toolInputSchema11, async ({ urls }) => {
-    try {
-      const results = await testUrls(urls);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(results, null, 2)
-          }
-        ]
-      };
-    } catch (e) {
-      if (e instanceof Error) {
-        return {
-          content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-        };
-      }
-      throw e;
-    }
-  });
+      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(urls) {
+async function testUrls(input) {
+  const { urls } = input;
   const results = await Promise.allSettled(
     urls.map(async (url) => {
       try {
@@ -1637,14 +1181,42 @@ function extractDescription(html) {
   }
   return "";
 }
-
-// src/tools/think.ts
-import { dedent as dedent13 } from "ts-dedent";
-import { z as z12 } from "zod";
-var thoughtInputSchema = 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: 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 = {};
@@ -1652,65 +1224,15 @@ var Thought = class {
     const { nextThoughtNeeded } = input;
     this.thoughtHistory.push(input);
     return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            nextThoughtNeeded,
-            thoughtHistoryLength: this.thoughtHistory.length
-          })
-        }
-      ]
+      nextThoughtNeeded,
+      thoughtHistoryLength: this.thoughtHistory.length
     };
   }
 };
-function addThinkTool(server) {
-  const thought = new Thought();
-  server.registerTool(
-    "think",
-    {
-      title: "think",
-      description: dedent13`
-        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: thoughtInputSchema.shape
-    },
-    async (input) => {
-      return thought.processThought(input);
-    }
-  );
+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 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 Todo = class {
   currentTodoId = 0;
   todos = [];
@@ -1722,28 +1244,32 @@ var Todo = class {
       );
     }
     if (completedTodos) {
-      this.todos = this.todos.map((todo) => ({
-        ...todo,
-        completed: todo.completed || completedTodos.includes(todo.id)
+      this.todos = this.todos.map((todo2) => ({
+        ...todo2,
+        completed: todo2.completed || completedTodos.includes(todo2.id)
       }));
     }
     return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            todos: this.todos
-          })
-        }
-      ]
+      todos: this.todos
+    };
+  }
+  clearTodo() {
+    this.todos = [];
+    this.currentTodoId = 0;
+    return {
+      todos: this.todos
     };
   }
 };
-function addTodoTool(server) {
-  const todo = new Todo();
-  server.tool(
-    "todo",
-    dedent14`
+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:
@@ -1760,124 +1286,82 @@ function addTodoTool(server) {
       - newTodos: Array of task descriptions to add
       - completedTodos: Array of todo IDs to mark as completed
     `,
-    TodoInputSchema.shape,
-    async (input) => {
-      return todo.processTodo(input);
-    }
-  );
+    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.
 
-// 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 toolName12 = "writeTextFile";
-var toolDescription12 = dedent15`
-  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
+      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
 
-  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 2000 CHARACTERS, USE "appendTextFile" TOOL AFTER THIS ONE
-`;
-var toolInputSchema12 = {
-  path: z14.string().describe("Target file path (relative or absolute)."),
-  text: z14.string().min(1).max(2e3).describe("Text to write to the file. Max 2000 characters.")
-};
-function addWriteTextFileTool(server) {
-  const mode = getWorkspaceMode();
-  switch (mode) {
-    case "local" /* LOCAL */: {
-      server.tool(
-        toolName12,
-        `${toolDescription12}
+      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.
 
-Mode: Local (Local filesystem)`,
-        toolInputSchema12,
-        async ({ path: path2, text }) => {
-          try {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(await writeTextFileLocalMode(path2, text))
-                }
-              ]
-            };
-          } catch (e) {
-            if (e instanceof Error) {
-              return {
-                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-              };
-            }
-            throw e;
-          }
-        }
-      );
-      break;
-    }
-    case "studio" /* STUDIO */: {
-      server.tool(
-        toolName12,
-        `${toolDescription12}
+      Use cases:
+      - Creating new configuration files
+      - Writing generated code or documentation
+      - Saving processed data or results
+      - Creating log files or reports
 
-Mode: Studio (Workspace API)`,
-        toolInputSchema12,
-        async ({ path: path2, text }) => {
-          try {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify(await writeTextFileStudioMode(path2, text))
-                }
-              ]
-            };
-          } catch (e) {
-            if (e instanceof Error) {
-              return {
-                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
-              };
-            }
-            throw e;
-          }
-        }
-      );
-      break;
-    }
-  }
+      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 writeTextFileLocalMode(path2, text) {
+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
   };
 }
-async function writeTextFileStudioMode(path2, text) {
+async function writeTextFileStudioMode(input) {
+  const { path: path2, text } = input;
   const validatedPath = await validatePath(path2);
   const relativePath = validatedPath.startsWith(workspacePath) ? validatedPath.slice(workspacePath.length + 1) : validatedPath;
   const existingItem = await findWorkspaceItem(relativePath);
@@ -1896,8 +1380,6 @@ async function writeTextFileStudioMode(path2, text) {
       await createWorkspaceItem({
         type: "workspaceItemDirectory",
         path: currentPath,
-        owner: "expert",
-        lifecycle: "expertJob",
         permission: "readWrite"
       });
     }
@@ -1906,53 +1388,17 @@ async function writeTextFileStudioMode(path2, text) {
     {
       type: "workspaceItemFile",
       path: relativePath,
-      owner: "expert",
-      lifecycle: "expertJob",
       permission: "readWrite"
     },
     text
   );
-  await writeTextFileLocalMode(path2, text);
+  await writeTextFileLocalMode(input);
   return {
     path: relativePath,
     text
   };
 }
 
-// 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: {}
-        }
-      }
-    );
-    addAttemptCompletionTool(server);
-    addThinkTool(server);
-    addTodoTool(server);
-    addReadImageFileTool(server);
-    addReadPdfFileTool(server);
-    addReadTextFileTool(server);
-    addEditTextFileTool(server);
-    addAppendTextFileTool(server);
-    addDeleteFileTool(server);
-    addMoveFileTool(server);
-    addGetFileInfoTool(server);
-    addWriteTextFileTool(server);
-    addCreateDirectoryTool(server);
-    addListDirectoryTool(server);
-    addTestUrlTool(server);
-    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