@perstack/base 0.0.5 → 0.0.7

package/dist/index.js

@@ -8,7 +8,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@perstack/base",
-  version: "0.0.5",
+  version: "0.0.7",
   description: "Perstack base skills for agents.",
   author: "Wintermute Technologies, Inc.",
   type: "module",
@@ -46,56 +46,6 @@ var package_default = {
   }
 };
 
-// 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/lib/workspace-api.ts
 import mime from "mime-types";
 var getWorkspaceApiConfig = () => {
@@ -250,98 +200,110 @@ var deleteWorkspaceItem = async (workspaceItemId) => {
   }
 };
 
-// src/tools/append-text-file.ts
-var toolName = "appendTextFile";
-var toolDescription = dedent`
-  Text file appender for adding content to the end of existing files.
+// 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;
+    }
+  };
+}
 
-  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
+// 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";
 
-  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
+// 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}`);
+    }
+  }
+}
 
-  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/tools/append-text-file.ts
+var inputSchema = z.object({
   path: z.string().describe("Target file path to append to."),
   text: z.string().min(1).max(2e3).describe("Text to append to the file. Max 2000 characters.")
-};
-function 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 +313,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,7 +326,7 @@ 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(
@@ -379,45 +339,36 @@ async function appendTextFileStudioMode(path2, text) {
     },
     content
   );
-  return {
-    path: relativePath,
-    text
-  };
+  return { path: relativePath, text };
 }
 
 // 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
-  );
-};
+function attemptCompletionConfig() {
+  return {
+    title: "Attempt completion",
+    description: 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
+    `,
+    inputSchema: {}
+  };
+}
 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"
   };
 }
 
@@ -427,92 +378,35 @@ 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 = {
+var inputSchema2 = z2.object({
   path: z2.string()
-};
-function addCreateDirectoryTool(server) {
-  const mode = getWorkspaceMode();
-  switch (mode) {
-    case "local" /* LOCAL */: {
-      server.tool(
-        toolName2,
-        `${toolDescription2}
+});
+function createDirectoryConfig() {
+  return {
+    title: "Create directory",
+    description: dedent3`
+      Directory creator for establishing folder structures in the workspace.
 
-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);
   if (exists) {
@@ -530,7 +424,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);
@@ -552,7 +447,7 @@ async function createDirectoryStudioMode(path2) {
       });
     }
   }
-  await createDirectoryLocalMode(path2);
+  await createDirectoryLocalMode(input);
   return {
     path: relativePath
   };
@@ -563,92 +458,35 @@ 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 = {
+var inputSchema3 = z3.object({
   path: z3.string()
-};
-function addDeleteFileTool(server) {
-  const mode = getWorkspaceMode();
-  switch (mode) {
-    case "local" /* LOCAL */: {
-      server.tool(
-        toolName3,
-        `${toolDescription3}
+});
+function deleteFileConfig() {
+  return {
+    title: "Delete file",
+    description: dedent4`
+      File deleter for removing files from the workspace.
 
-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)) {
     throw new Error(`File ${path2} does not exist.`);
@@ -665,7 +503,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,7 +514,7 @@ 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
@@ -687,98 +526,41 @@ 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 = {
+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.")
-};
-function addEditTextFileTool(server) {
-  const mode = getWorkspaceMode();
-  switch (mode) {
-    case "local" /* LOCAL */: {
-      server.tool(
-        toolName4,
-        `${toolDescription4}
+});
+function editTextFileConfig() {
+  return {
+    title: "Edit text file",
+    description: dedent5`
+      Text file editor for modifying existing files with precise text replacement.
 
-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)) {
     throw new Error(`File ${path2} does not exist.`);
@@ -794,7 +576,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,7 +587,7 @@ 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");
   await createWorkspaceItem(
@@ -843,92 +626,35 @@ 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 = {
+var inputSchema5 = z5.object({
   path: z5.string()
-};
-function addGetFileInfoTool(server) {
-  const mode = getWorkspaceMode();
-  switch (mode) {
-    case "local" /* LOCAL */: {
-      server.tool(
-        toolName5,
-        `${toolDescription5}
+});
+function getFileInfoConfig() {
+  return {
+    title: "Get file info",
+    description: dedent6`
+      File information retriever for detailed metadata about files and directories.
 
-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;
-    }
-    case "studio" /* STUDIO */: {
-      server.tool(
-        toolName5,
-        `${toolDescription5}
+      Use cases:
+      - Checking file existence and type
+      - Getting file size and timestamps
+      - Determining MIME types
+      - Validating file accessibility
 
-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;
-          }
-        }
-      );
-      break;
-    }
-  }
+      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(path2) {
+async function getFileInfoLocalMode(input) {
+  const { path: path2 } = input;
   const validatedPath = await validatePath(path2);
   if (!existsSync5(validatedPath)) {
     throw new Error(`File or directory ${path2} does not exist`);
@@ -963,10 +689,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,
@@ -994,92 +721,35 @@ 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}
+var inputSchema6 = z6.object({
+  path: z6.string()
+});
+function listDirectoryConfig() {
+  return {
+    title: "List directory",
+    description: dedent7`
+      Directory content lister with detailed file information.
 
-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)) {
     throw new Error(`Directory ${path2} does not exist.`);
@@ -1114,7 +784,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();
@@ -1143,94 +814,37 @@ 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 = {
+var inputSchema7 = z7.object({
   source: z7.string(),
   destination: z7.string()
-};
-function addMoveFileTool(server) {
-  const mode = getWorkspaceMode();
-  switch (mode) {
-    case "local" /* LOCAL */: {
-      server.tool(
-        toolName7,
-        `${toolDescription7}
+});
+function moveFileConfig() {
+  return {
+    title: "Move file",
+    description: dedent8`
+      File mover for relocating or renaming files within the workspace.
 
-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)) {
@@ -1251,7 +865,8 @@ async function moveFileLocalMode(source, destination) {
     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;
@@ -1280,7 +895,7 @@ async function moveFileStudioMode(source, destination) {
   await updateWorkspaceItem(sourceItem.id, {
     path: relativeDestination
   });
-  await moveFileLocalMode(source, destination);
+  await moveFileLocalMode(input);
   return {
     source: relativeSource,
     destination: relativeDestination
@@ -1294,55 +909,40 @@ 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 = z8.object({
+  path: z8.string()
+});
+function readImageFileConfig() {
+  return {
+    title: "Read image file",
+    description: dedent9`
+      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);
   if (!isFile) {
@@ -1373,51 +973,36 @@ 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 = z9.object({
+  path: z9.string()
+});
+function readPdfFileConfig() {
+  return {
+    title: "Read PDF file",
+    description: dedent10`
+      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);
   if (!isFile) {
@@ -1443,64 +1028,49 @@ async function readPdfFile(path2) {
 
 // src/tools/read-text-file.ts
 import { existsSync as existsSync10 } from "fs";
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile3 } 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
-
-  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 = {
+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.")
-};
-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;
-    }
-  });
+});
+function readTextFileConfig() {
+  return {
+    title: "Read text file",
+    description: 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
+
+      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);
   if (!isFile) {
     throw new Error(`File ${path2} does not exist.`);
   }
-  const fileContent = await readFile4(validatedPath, "utf-8");
+  const fileContent = await readFile3(validatedPath, "utf-8");
   const lines = fileContent.split("\n");
   const fromLine = from ?? 0;
   const toLine = to ?? lines.length;
@@ -1517,54 +1087,38 @@ async function readTextFile(path2, from, to) {
 // 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
+var inputSchema11 = z11.object({
+  urls: z11.array(z11.string()).min(1).max(10).describe("Array of URLs to test (max 10 URLs).")
+});
+function testUrlConfig() {
+  return {
+    title: "Test URL",
+    description: dedent12`
+      URL tester that validates multiple URLs and extracts metadata.
 
-  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 {
@@ -1641,10 +1195,42 @@ function extractDescription(html) {
 // src/tools/think.ts
 import { dedent as dedent13 } from "ts-dedent";
 import { z as z12 } from "zod";
-var thoughtInputSchema = z12.object({
+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")
 });
+function thinkConfig() {
+  return {
+    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: inputSchema12.shape
+  };
+}
 var Thought = class {
   thoughtHistory = [];
   branches = {};
@@ -1652,65 +1238,19 @@ 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 +1262,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 = 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()
+});
+function todoConfig() {
+  return {
+    title: "todo",
+    description: dedent14`
       Todo list manager that tracks tasks and their completion status.
 
       Use cases:
@@ -1760,11 +1304,33 @@ 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 = z13.object({});
+function clearTodoConfig() {
+  return {
+    title: "clearTodo",
+    description: dedent14`
+      Clears the todo list.
+
+      Use cases:
+      - Resetting the todo list to an empty state
+      - Starting fresh with a new task list
+      - Clearing all tasks for a new day or project
+
+      How it works:
+      - Resets the todo list to an empty state
+      - Returns an empty todo list
+    `,
+    inputSchema: clearTodoInputSchema.shape
+  };
+}
+async function clearTodo(input) {
+  return todoSingleton.clearTodo();
 }
 
 // src/tools/write-text-file.ts
@@ -1774,94 +1340,37 @@ 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
-
-  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 = {
+var toolInputSchema = z14.object({
   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}
+  text: z14.string().min(1).max(1e4).describe("Text to write to the file. Max 10000 characters.")
+});
+function writeTextFileConfig() {
+  return {
+    title: "writeTextFile",
+    description: dedent15`
+      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);
@@ -1877,7 +1386,8 @@ async function writeTextFileLocalMode(path2, text) {
     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);
@@ -1912,7 +1422,7 @@ async function writeTextFileStudioMode(path2, text) {
     },
     text
   );
-  await writeTextFileLocalMode(path2, text);
+  await writeTextFileLocalMode(input);
   return {
     path: relativePath,
     text
@@ -1934,21 +1444,58 @@ async function main() {
         }
       }
     );
-    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);
+    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);
   });