@perstack/base 0.0.2 → 0.0.4

package/dist/index.js

@@ -1,5 +1,258 @@
 #!/usr/bin/env node
-import {McpServer}from'@modelcontextprotocol/sdk/server/mcp.js';import {StdioServerTransport}from'@modelcontextprotocol/sdk/server/stdio.js';import {Command}from'commander';import {realpathSync,existsSync,statSync}from'fs';import M,{stat,readFile,appendFile,unlink,mkdir,rename,writeFile,readdir}from'fs/promises';import {dedent}from'ts-dedent';import {z as z$1}from'zod';import Ue from'os';import y,{dirname,extname,basename,resolve,join}from'path';import $e from'mime-types';var h={name:"@perstack/base",version:"0.0.2",description:"Perstack base skills for agents."};var c=realpathSync(F(process.cwd()));function F(t){return t.startsWith("~/")||t==="~"?y.join(Ue.homedir(),t.slice(1)):t}async function a(t){let o=F(t),e=y.isAbsolute(o)?y.resolve(o):y.resolve(process.cwd(),o);if(e===`${c}/perstack`)throw new Error("Access denied - perstack directory is not allowed");try{let r=await M.realpath(e);if(!r.startsWith(c))throw new Error("Access denied - symlink target outside allowed directories");return r}catch{let i=y.dirname(e);try{if(!(await M.realpath(i)).startsWith(c))throw new Error("Access denied - parent directory outside allowed directories");return e}catch{throw e.startsWith(c)?new Error(`Parent directory does not exist: ${i}`):new Error(`Access denied - path outside allowed directories: ${e} not in ${c}`)}}}var w=()=>{let t=process.env.PERSTACK_API_BASE_URL,o=process.env.PERSTACK_API_KEY,e=process.env.PERSTACK_EXPERT_JOB_ID;if(!(!t||!o||!e||t===""||o===""||e===""))return {baseUrl:t,apiKey:o,expertJobId:e}},m=()=>w()!==void 0?"studio":"local",l=async t=>{let o=w();if(!o)throw new Error("Workspace API not configured");try{let e=new URL("/api/studio/v1/workspace/items/find",o.baseUrl);e.searchParams.set("path",t);let r=await fetch(e,{headers:{Authorization:`Bearer ${o.apiKey}`,"x-studio-expert-job-id":o.expertJobId}});if(!r.ok){if(r.status===404)return null;let s=await r.text();throw new Error(`Failed to find workspace item: ${r.status} ${s}`)}return (await r.json()).data.workspaceItem}catch(e){if(e instanceof Error&&e.message.includes("404"))return null;throw e}},f=async(t,o)=>{let e=w();if(!e)throw new Error("Workspace API not configured");let r=new URL("/api/studio/v1/workspace/items",e.baseUrl);if(t.type==="workspaceItemFile"&&o){let n=new FormData;n.append("type","workspaceItemFile"),n.append("path",t.path),n.append("permission",t.permission);let d=new Blob([o],{type:$e.lookup(t.path)||"text/plain"});n.append("file",d);let p=await fetch(r,{method:"POST",headers:{Authorization:`Bearer ${e.apiKey}`,"x-studio-expert-job-id":e.expertJobId},body:n});if(!p.ok){let T=await p.text();throw new Error(`Failed to create workspace item: ${p.status} ${T}`)}return (await p.json()).data.workspaceItem}let i=await fetch(r,{method:"POST",headers:{Authorization:`Bearer ${e.apiKey}`,"Content-Type":"application/json","x-studio-expert-job-id":e.expertJobId},body:JSON.stringify({type:t.type,path:t.path,permission:t.permission})});if(!i.ok){let n=await i.text();throw new Error(`Failed to create workspace item: ${i.status} ${n}`)}return (await i.json()).data.workspaceItem},A=async(t,o)=>{let e=w();if(!e)throw new Error("Workspace API not configured");let r={Authorization:`Bearer ${e.apiKey}`,"Content-Type":"application/json","x-studio-expert-job-id":e.expertJobId},i=new URL(`/api/studio/v1/workspace/items/${t}`,e.baseUrl),s=await fetch(i,{method:"POST",headers:r,body:JSON.stringify(o)});if(!s.ok)throw new Error(`Failed to update workspace item: ${s.status}`);return (await s.json()).data.workspaceItem},W=async(t=100,o=0)=>{let e=w();if(!e)throw new Error("Workspace API not configured");let r=new URL("/api/studio/v1/workspace/items",e.baseUrl);r.searchParams.set("take",t.toString()),r.searchParams.set("skip",o.toString());let i=await fetch(r,{headers:{Authorization:`Bearer ${e.apiKey}`,"x-studio-expert-job-id":e.expertJobId}});if(!i.ok){let n=await i.text();throw new Error(`Failed to get workspace items: ${i.status} ${n}`)}return (await i.json()).data.workspaceItems},g=async t=>{let o=w();if(!o)throw new Error("Workspace API not configured");let e=new URL(`/api/studio/v1/workspace/items/${t}`,o.baseUrl),r=await fetch(e,{method:"DELETE",headers:{Authorization:`Bearer ${o.apiKey}`,"x-studio-expert-job-id":o.expertJobId}});if(!r.ok){let i=await r.text();throw new Error(`Failed to delete workspace item: ${r.status} ${i}`)}};var D="appendTextFile",R=dedent`
+
+// 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.4",
+  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.10.2",
+    commander: "^13.1.0",
+    "mime-types": "^3.0.1",
+    "ts-dedent": "^2.2.0",
+    zod: "^3.24.3"
+  },
+  devDependencies: {
+    "@tsconfig/node22": "^22.0.1",
+    "@types/mime-types": "^3.0.1",
+    "@types/node": "^22.15.3",
+    tsup: "^8.4.0",
+    typescript: "^5.8.3"
+  },
+  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";
+
+// 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 = () => {
+  const baseUrl = process.env.PERSTACK_API_BASE_URL;
+  const apiKey = process.env.PERSTACK_API_KEY;
+  const expertJobId = process.env.PERSTACK_EXPERT_JOB_ID;
+  if (!baseUrl || !apiKey || !expertJobId || baseUrl === "" || apiKey === "" || expertJobId === "") {
+    return void 0;
+  }
+  return { baseUrl, apiKey, expertJobId };
+};
+var getWorkspaceMode = () => {
+  return getWorkspaceApiConfig() !== void 0 ? "studio" /* STUDIO */ : "local" /* LOCAL */;
+};
+var findWorkspaceItem = async (path2) => {
+  const config = getWorkspaceApiConfig();
+  if (!config) {
+    throw new Error("Workspace API not configured");
+  }
+  try {
+    const url = new URL("/api/studio/v1/workspace/items/find", config.baseUrl);
+    url.searchParams.set("path", path2);
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "x-studio-expert-job-id": config.expertJobId
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        return null;
+      }
+      const errorText = await response.text();
+      throw new Error(`Failed to find workspace item: ${response.status} ${errorText}`);
+    }
+    const result = await response.json();
+    return result.data.workspaceItem;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("404")) {
+      return null;
+    }
+    throw error;
+  }
+};
+var createWorkspaceItem = async (item, fileContent) => {
+  const config = getWorkspaceApiConfig();
+  if (!config) {
+    throw new Error("Workspace API not configured");
+  }
+  const url = new URL("/api/studio/v1/workspace/items", config.baseUrl);
+  if (item.type === "workspaceItemFile" && fileContent) {
+    const formData = new FormData();
+    formData.append("type", "workspaceItemFile");
+    formData.append("path", item.path);
+    formData.append("permission", item.permission);
+    const blob = new Blob([fileContent], { type: mime.lookup(item.path) || "text/plain" });
+    formData.append("file", blob);
+    const response2 = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "x-studio-expert-job-id": config.expertJobId
+      },
+      body: formData
+    });
+    if (!response2.ok) {
+      const errorText = await response2.text();
+      throw new Error(`Failed to create workspace item: ${response2.status} ${errorText}`);
+    }
+    const result2 = await response2.json();
+    return result2.data.workspaceItem;
+  }
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${config.apiKey}`,
+      "Content-Type": "application/json",
+      "x-studio-expert-job-id": config.expertJobId
+    },
+    body: JSON.stringify({
+      type: item.type,
+      path: item.path,
+      permission: item.permission
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to create workspace item: ${response.status} ${errorText}`);
+  }
+  const result = await response.json();
+  return result.data.workspaceItem;
+};
+var updateWorkspaceItem = async (id, updates) => {
+  const config = getWorkspaceApiConfig();
+  if (!config) {
+    throw new Error("Workspace API not configured");
+  }
+  const headers = {
+    Authorization: `Bearer ${config.apiKey}`,
+    "Content-Type": "application/json",
+    "x-studio-expert-job-id": config.expertJobId
+  };
+  const url = new URL(`/api/studio/v1/workspace/items/${id}`, config.baseUrl);
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(updates)
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to update workspace item: ${response.status}`);
+  }
+  const result = await response.json();
+  return result.data.workspaceItem;
+};
+var getWorkspaceItems = async (take = 100, skip = 0) => {
+  const config = getWorkspaceApiConfig();
+  if (!config) {
+    throw new Error("Workspace API not configured");
+  }
+  const url = new URL("/api/studio/v1/workspace/items", config.baseUrl);
+  url.searchParams.set("take", take.toString());
+  url.searchParams.set("skip", skip.toString());
+  const response = await fetch(url, {
+    headers: {
+      Authorization: `Bearer ${config.apiKey}`,
+      "x-studio-expert-job-id": config.expertJobId
+    }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to get workspace items: ${response.status} ${errorText}`);
+  }
+  const result = await response.json();
+  return result.data.workspaceItems;
+};
+var deleteWorkspaceItem = async (workspaceItemId) => {
+  const config = getWorkspaceApiConfig();
+  if (!config) {
+    throw new Error("Workspace API not configured");
+  }
+  const url = new URL(`/api/studio/v1/workspace/items/${workspaceItemId}`, config.baseUrl);
+  const response = await fetch(url, {
+    method: "DELETE",
+    headers: {
+      Authorization: `Bearer ${config.apiKey}`,
+      "x-studio-expert-job-id": config.expertJobId
+    }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to delete workspace item: ${response.status} ${errorText}`);
+  }
+};
+
+// 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:
@@ -20,11 +273,124 @@ import {McpServer}from'@modelcontextprotocol/sdk/server/mcp.js';import {StdioSer
   - 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
-`,L={path:z$1.string().describe("Target file path to append to."),text:z$1.string().min(1).max(2e3).describe("Text to append to the file. Max 2000 characters.")};function N(t){switch(m()){case "local":{t.tool(D,`${R}
+`;
+var toolInputSchema = {
+  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}
 
-Mode: Local (Local filesystem)`,L,async({path:e,text:r})=>{try{return {content:[{type:"text",text:JSON.stringify(await U(e,r))}]}}catch(i){if(i instanceof Error)return {content:[{type:"text",text:i.message}]};throw i}});break}case "studio":{t.tool(D,`${R}
+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}
 
-Mode: Studio (Workspace API)`,L,async({path:e,text:r})=>{try{return {content:[{type:"text",text:JSON.stringify(await Be(e,r))}]}}catch(i){if(i instanceof Error)return {content:[{type:"text",text:i.message}]};throw i}});break}}}async function U(t,o){let e=await a(t);if(!existsSync(e))throw new Error(`File ${t} does not exist.`);if(!(statSync(e).mode&128))throw new Error(`File ${t} is not writable`);return await appendFile(e,o),e}async function Be(t,o){let e=await a(t),r=e.startsWith(c)?e.slice(c.length+1):e,i=await l(r);if(!i)throw new Error(`File ${r} does not exist.`);if(i.type==="workspaceItemDirectory")throw new Error(`Path ${r} is a directory.`);await U(t,o),await g(i.id);let s=await readFile(e,"utf-8");return await f({type:"workspaceItemFile",path:r,permission:"readWrite"},s),r}var $=t=>{t.tool("attemptCompletion",dedent`
+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;
+    }
+  }
+}
+async function appendTextFileLocalMode(path2, text) {
+  const validatedPath = await validatePath(path2);
+  if (!existsSync(validatedPath)) {
+    throw new Error(`File ${path2} does not exist.`);
+  }
+  const stats = statSync(validatedPath);
+  if (!(stats.mode & 128)) {
+    throw new Error(`File ${path2} is not writable`);
+  }
+  await appendFile(validatedPath, text);
+  return {
+    path: validatedPath,
+    text
+  };
+}
+async function appendTextFileStudioMode(path2, text) {
+  const validatedPath = await validatePath(path2);
+  const relativePath = validatedPath.startsWith(workspacePath) ? validatedPath.slice(workspacePath.length + 1) : validatedPath;
+  const existingItem = await findWorkspaceItem(relativePath);
+  if (!existingItem) {
+    throw new Error(`File ${relativePath} does not exist.`);
+  }
+  if (existingItem.type === "workspaceItemDirectory") {
+    throw new Error(`Path ${relativePath} is a directory.`);
+  }
+  await appendTextFileLocalMode(path2, text);
+  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
+  };
+}
+
+// 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
@@ -39,7 +405,30 @@ Mode: Studio (Workspace API)`,L,async({path:e,text:r})=>{try{return {content:[{t
         - Triggers immediate transition to final report
         - Should only be used when task is fully complete
         - Cannot be reverted once called
-      `,{},Ke);};async function Ke(){return {content:[{type:"text",text:"End the agent loop and provide a final report"}]}}var z="createDirectory",j=dedent`
+      `,
+    {},
+    attemptCompletion
+  );
+};
+async function attemptCompletion() {
+  return {
+    content: [
+      {
+        type: "text",
+        text: "End the agent loop and provide a final report"
+      }
+    ]
+  };
+}
+
+// src/tools/create-directory.ts
+import { existsSync as existsSync2, statSync as statSync2 } from "fs";
+import { mkdir } from "fs/promises";
+import { dirname } from "path";
+import { dedent as dedent3 } from "ts-dedent";
+import { z as z2 } from "zod";
+var toolName2 = "createDirectory";
+var toolDescription2 = dedent3`
   Directory creator for establishing folder structures in the workspace.
 
   Use cases:
@@ -56,11 +445,126 @@ Mode: Studio (Workspace API)`,L,async({path:e,text:r})=>{try{return {content:[{t
   
   Parameters:
   - path: Directory path to create
-`,H={path:z$1.string()};function J(t){switch(m()){case "local":{t.tool(z,`${j}
+`;
+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}
 
-Mode: Local (Local filesystem)`,H,async({path:e})=>{try{return {content:[{type:"text",text:JSON.stringify(await B(e))}]}}catch(r){if(r instanceof Error)return {content:[{type:"text",text:r.message}]};throw r}});break}case "studio":{t.tool(z,`${j}
+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;
+    }
+  }
+}
+async function createDirectoryLocalMode(path2) {
+  const validatedPath = await validatePath(path2);
+  const exists = existsSync2(validatedPath);
+  if (exists) {
+    throw new Error(`Directory ${path2} already exists`);
+  }
+  const parentDir = dirname(validatedPath);
+  if (existsSync2(parentDir)) {
+    const parentStats = statSync2(parentDir);
+    if (!(parentStats.mode & 128)) {
+      throw new Error(`Parent directory ${parentDir} is not writable`);
+    }
+  }
+  await mkdir(validatedPath, { recursive: true });
+  return {
+    path: validatedPath
+  };
+}
+async function createDirectoryStudioMode(path2) {
+  const validatedPath = await validatePath(path2);
+  const relativePath = validatedPath.startsWith(workspacePath) ? validatedPath.slice(workspacePath.length + 1) : validatedPath;
+  const existingItem = await findWorkspaceItem(relativePath);
+  if (existingItem) {
+    throw new Error(`Directory ${relativePath} already exists`);
+  }
+  const pathParts = relativePath.split("/").filter((part) => part !== "");
+  for (let i = 1; i <= pathParts.length; i++) {
+    const currentPath = pathParts.slice(0, i).join("/");
+    if (currentPath === "") continue;
+    const existingParent = await findWorkspaceItem(currentPath);
+    if (!existingParent) {
+      await createWorkspaceItem({
+        type: "workspaceItemDirectory",
+        path: currentPath,
+        owner: "expert",
+        lifecycle: "expertJob",
+        permission: "readWrite"
+      });
+    }
+  }
+  await createDirectoryLocalMode(path2);
+  return {
+    path: relativePath
+  };
+}
 
-Mode: Studio (Workspace API)`,H,async({path:e})=>{try{return {content:[{type:"text",text:JSON.stringify(await Ze(e))}]}}catch(r){if(r instanceof Error)return {content:[{type:"text",text:r.message}]};throw r}});break}}}async function B(t){let o=await a(t);if(existsSync(o))throw new Error(`Directory ${t} already exists`);let r=dirname(o);if(existsSync(r)&&!(statSync(r).mode&128))throw new Error(`Parent directory ${r} is not writable`);return await mkdir(o,{recursive:true}),o}async function Ze(t){let o=await a(t),e=o.startsWith(c)?o.slice(c.length+1):o;if(await l(e))throw new Error(`Directory ${e} already exists`);let i=e.split("/").filter(s=>s!=="");for(let s=1;s<=i.length;s++){let n=i.slice(0,s).join("/");if(n==="")continue;await l(n)||await f({type:"workspaceItemDirectory",path:n,permission:"readWrite"});}return await B(t),e}var G="deleteFile",K=dedent`
+// 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:
@@ -77,11 +581,114 @@ Mode: Studio (Workspace API)`,H,async({path:e})=>{try{return {content:[{type:"te
   
   Parameters:
   - path: File path to delete
-`,V={path:z$1.string()};function _(t){switch(m()){case "local":{t.tool(G,`${K}
+`;
+var toolInputSchema3 = {
+  path: z3.string()
+};
+function addDeleteFileTool(server) {
+  const mode = getWorkspaceMode();
+  switch (mode) {
+    case "local" /* LOCAL */: {
+      server.tool(
+        toolName3,
+        `${toolDescription3}
 
-Mode: Local (Local filesystem)`,V,async({path:e})=>{try{return {content:[{type:"text",text:JSON.stringify(await q(e))}]}}catch(r){if(r instanceof Error)return {content:[{type:"text",text:r.message}]};throw r}});break}case "studio":{t.tool(G,`${K}
+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}
 
-Mode: Studio (Workspace API)`,V,async({path:e})=>{try{return {content:[{type:"text",text:JSON.stringify(await it(e))}]}}catch(r){if(r instanceof Error)return {content:[{type:"text",text:r.message}]};throw r}});break}}}async function q(t){let o=await a(t);if(!existsSync(o))throw new Error(`File ${t} does not exist.`);let e=statSync(o);if(e.isDirectory())throw new Error(`Path ${t} is a directory. Use delete directory tool instead.`);if(!(e.mode&128))throw new Error(`File ${t} is not writable`);return await unlink(o),o}async function it(t){let o=await a(t),e=o.startsWith(c)?o.slice(c.length+1):o,r=await l(e);if(!r)throw new Error(`File ${e} does not exist.`);if(r.type==="workspaceItemDirectory")throw new Error(`Path ${e} is a directory. Use delete directory tool instead.`);return await q(t),await g(r.id),e}var X="editTextFile",Y=dedent`
+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;
+    }
+  }
+}
+async function deleteFileLocalMode(path2) {
+  const validatedPath = await validatePath(path2);
+  if (!existsSync3(validatedPath)) {
+    throw new Error(`File ${path2} does not exist.`);
+  }
+  const stats = statSync3(validatedPath);
+  if (stats.isDirectory()) {
+    throw new Error(`Path ${path2} is a directory. Use delete directory tool instead.`);
+  }
+  if (!(stats.mode & 128)) {
+    throw new Error(`File ${path2} is not writable`);
+  }
+  await unlink(validatedPath);
+  return {
+    path: validatedPath
+  };
+}
+async function deleteFileStudioMode(path2) {
+  const validatedPath = await validatePath(path2);
+  const relativePath = validatedPath.startsWith(workspacePath) ? validatedPath.slice(workspacePath.length + 1) : validatedPath;
+  const existingItem = await findWorkspaceItem(relativePath);
+  if (!existingItem) {
+    throw new Error(`File ${relativePath} does not exist.`);
+  }
+  if (existingItem.type === "workspaceItemDirectory") {
+    throw new Error(`Path ${relativePath} is a directory. Use delete directory tool instead.`);
+  }
+  await deleteFileLocalMode(path2);
+  await deleteWorkspaceItem(existingItem.id);
+  return {
+    path: relativePath
+  };
+}
+
+// src/tools/edit-text-file.ts
+import { existsSync as existsSync4, statSync as statSync4 } from "fs";
+import { readFile as readFile2, writeFile } from "fs/promises";
+import { dedent as dedent5 } from "ts-dedent";
+import { z as z4 } from "zod";
+var toolName4 = "editTextFile";
+var toolDescription4 = dedent5`
   Text file editor for modifying existing files with precise text replacement.
 
   Use cases:
@@ -102,12 +709,142 @@ Mode: Studio (Workspace API)`,V,async({path:e})=>{try{return {content:[{type:"te
   - 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
-`,Z={path:z$1.string().describe("Target file path to edit."),newText:z$1.string().min(1).max(2e3).describe("Text to append to the file. Max 2000 characters."),oldText:z$1.string().min(1).max(2e3).describe("Exact text to find and replace. Max 2000 characters.")};function ee(t){switch(m()){case "local":{t.tool(X,`${Y}
+`;
+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}
 
-Mode: Local (Local filesystem)`,Z,async({path:e,newText:r,oldText:i})=>{try{return {content:[{type:"text",text:JSON.stringify(await te(e,r,i))}]}}catch(s){if(s instanceof Error)return {content:[{type:"text",text:s.message}]};throw s}});break}case "studio":{t.tool(X,`${Y}
+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;
+    }
+  }
+}
+async function editTextFileLocalMode(path2, newText, oldText) {
+  const validatedPath = await validatePath(path2);
+  if (!existsSync4(validatedPath)) {
+    throw new Error(`File ${path2} does not exist.`);
+  }
+  const stats = statSync4(validatedPath);
+  if (!(stats.mode & 128)) {
+    throw new Error(`File ${path2} is not writable`);
+  }
+  await applyFileEdit(validatedPath, newText, oldText);
+  return {
+    path: validatedPath,
+    newText,
+    oldText
+  };
+}
+async function editTextFileStudioMode(path2, newText, oldText) {
+  const validatedPath = await validatePath(path2);
+  const relativePath = validatedPath.startsWith(workspacePath) ? validatedPath.slice(workspacePath.length + 1) : validatedPath;
+  const existingItem = await findWorkspaceItem(relativePath);
+  if (!existingItem) {
+    throw new Error(`File ${relativePath} does not exist.`);
+  }
+  if (existingItem.type === "workspaceItemDirectory") {
+    throw new Error(`Path ${relativePath} is a directory.`);
+  }
+  await editTextFileLocalMode(path2, newText, oldText);
+  await deleteWorkspaceItem(existingItem.id);
+  const content = await readFile2(validatedPath, "utf-8");
+  await createWorkspaceItem(
+    {
+      type: "workspaceItemFile",
+      path: relativePath,
+      owner: "expert",
+      lifecycle: "expertJob",
+      permission: "readWrite"
+    },
+    content
+  );
+  return {
+    path: relativePath,
+    newText,
+    oldText
+  };
+}
+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 normalizedOld = normalizeLineEndings(oldText);
+  const normalizedNew = normalizeLineEndings(newText);
+  if (!content.includes(normalizedOld)) {
+    throw new Error(`Could not find exact match for oldText in file ${filePath}`);
+  }
+  const modifiedContent = content.replace(normalizedOld, normalizedNew);
+  await writeFile(filePath, modifiedContent, "utf-8");
+}
 
-Mode: Studio (Workspace API)`,Z,async({path:e,oldText:r,newText:i})=>{try{return {content:[{type:"text",text:JSON.stringify(await pt(e,i,r))}]}}catch(s){if(s instanceof Error)return {content:[{type:"text",text:s.message}]};throw s}});break}}}async function te(t,o,e){let r=await a(t);if(!existsSync(r))throw new Error(`File ${t} does not exist.`);if(!(statSync(r).mode&128))throw new Error(`File ${t} is not writable`);return await dt(r,o,e),r}async function pt(t,o,e){let r=await a(t),i=r.startsWith(c)?r.slice(c.length+1):r,s=await l(i);if(!s)throw new Error(`File ${i} does not exist.`);if(s.type==="workspaceItemDirectory")throw new Error(`Path ${i} is a directory.`);await te(t,o,e),await g(s.id);let n=await readFile(r,"utf-8");return await f({type:"workspaceItemFile",path:i,permission:"readWrite"},n),i}function I(t){return t.replace(/\r\n/g,`
-`)}async function dt(t,o,e){let r=I(await readFile(t,"utf-8")),i=I(e),s=I(o);if(!r.includes(i))throw new Error(`Could not find exact match for oldText in file ${t}`);let n=r.replace(i,s);await writeFile(t,n,"utf-8");}var oe="getFileInfo",re=dedent`
+// 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:
@@ -124,11 +861,141 @@ Mode: Studio (Workspace API)`,Z,async({path:e,oldText:r,newText:i})=>{try{return
   
   Parameters:
   - path: File or directory path to inspect
-`,ie={path:z$1.string()};function se(t){switch(m()){case "local":{t.tool(oe,`${re}
+`;
+var toolInputSchema5 = {
+  path: z5.string()
+};
+function addGetFileInfoTool(server) {
+  const mode = getWorkspaceMode();
+  switch (mode) {
+    case "local" /* LOCAL */: {
+      server.tool(
+        toolName5,
+        `${toolDescription5}
 
-Mode: Local (Local filesystem)`,ie,async({path:e})=>{try{return {content:[{type:"text",text:JSON.stringify(await ne(e))}]}}catch(r){if(r instanceof Error)return {content:[{type:"text",text:r.message}]};throw r}});break}case "studio":{t.tool(oe,`${re}
+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}
 
-Mode: Studio (Workspace API + Local filesystem)`,ie,async({path:e})=>{try{return {content:[{type:"text",text:JSON.stringify(await Tt(e))}]}}catch(r){if(r instanceof Error)return {content:[{type:"text",text:r.message}]};throw r}});break}}}async function ne(t){let o=await a(t);if(!existsSync(o))throw new Error(`File or directory ${t} does not exist`);let e=statSync(o),r=e.isDirectory(),i=r?null:$e.lookup(o)||"application/octet-stream",s=n=>{if(n===0)return "0 B";let d=["B","KB","MB","GB","TB"],p=Math.floor(Math.log(n)/Math.log(1024));return `${(n/1024**p).toFixed(2)} ${d[p]}`};return {exists:true,path:o,absolutePath:resolve(o),name:basename(o),directory:dirname(o),extension:r?null:extname(o),type:r?"directory":"file",mimeType:i,size:e.size,sizeFormatted:s(e.size),created:e.birthtime.toISOString(),modified:e.mtime.toISOString(),accessed:e.atime.toISOString(),permissions:{readable:true,writable:!!(e.mode&128),executable:!!(e.mode&64)}}}async function Tt(t){let o=await a(t),e=o.startsWith(c)?o.slice(c.length+1):o,r=await ne(t),i=await l(e);return {...r,workspaceItem:i?{id:i.id,type:i.type,path:i.path,owner:i.owner,lifecycle:i.lifecycle,permission:i.permission,createdAt:i.createdAt,updatedAt:i.updatedAt,...i.type==="workspaceItemFile"?{key:i.key,mimeType:i.mimeType,size:i.size}:{}}:null}}var ce="listDirectory",pe=dedent`
+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;
+    }
+  }
+}
+async function getFileInfoLocalMode(path2) {
+  const validatedPath = await validatePath(path2);
+  if (!existsSync5(validatedPath)) {
+    throw new Error(`File or directory ${path2} does not exist`);
+  }
+  const stats = statSync5(validatedPath);
+  const isDirectory = stats.isDirectory();
+  const mimeType = isDirectory ? null : mime2.lookup(validatedPath) || "application/octet-stream";
+  const formatSize = (bytes) => {
+    if (bytes === 0) return "0 B";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return `${(bytes / 1024 ** i).toFixed(2)} ${units[i]}`;
+  };
+  return {
+    exists: true,
+    path: validatedPath,
+    absolutePath: resolve(validatedPath),
+    name: basename(validatedPath),
+    directory: dirname2(validatedPath),
+    extension: isDirectory ? null : extname(validatedPath),
+    type: isDirectory ? "directory" : "file",
+    mimeType,
+    size: stats.size,
+    sizeFormatted: formatSize(stats.size),
+    created: stats.birthtime.toISOString(),
+    modified: stats.mtime.toISOString(),
+    accessed: stats.atime.toISOString(),
+    permissions: {
+      readable: true,
+      writable: Boolean(stats.mode & 128),
+      executable: Boolean(stats.mode & 64)
+    }
+  };
+}
+async function getFileInfoStudioMode(path2) {
+  const validatedPath = await validatePath(path2);
+  const relativePath = validatedPath.startsWith(workspacePath) ? validatedPath.slice(workspacePath.length + 1) : validatedPath;
+  const localInfo = await getFileInfoLocalMode(path2);
+  const workspaceItem = await findWorkspaceItem(relativePath);
+  return {
+    ...localInfo,
+    workspaceItem: workspaceItem ? {
+      id: workspaceItem.id,
+      type: workspaceItem.type,
+      path: workspaceItem.path,
+      owner: workspaceItem.owner,
+      lifecycle: workspaceItem.lifecycle,
+      permission: workspaceItem.permission,
+      createdAt: workspaceItem.createdAt,
+      updatedAt: workspaceItem.updatedAt,
+      ...workspaceItem.type === "workspaceItemFile" ? {
+        key: workspaceItem.key,
+        mimeType: workspaceItem.mimeType,
+        size: workspaceItem.size
+      } : {}
+    } : null
+  };
+}
+
+// src/tools/list-directory.ts
+import { existsSync as existsSync6, statSync as statSync6 } from "fs";
+import { readdir } from "fs/promises";
+import { join } from "path";
+import { dedent as dedent7 } from "ts-dedent";
+import { z as z6 } from "zod";
+var toolName6 = "listDirectory";
+var toolDescription6 = dedent7`
   Directory content lister with detailed file information.
 
   Use cases:
@@ -145,11 +1012,139 @@ Mode: Studio (Workspace API + Local filesystem)`,ie,async({path:e})=>{try{return
   
   Parameters:
   - path: Directory path to list (optional, defaults to workspace root)
-`,de={path:z$1.string().optional()};function le(t){switch(m()){case "local":{t.tool(ce,`${pe}
+`;
+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}
 
-Mode: Local (Local filesystem)`,de,async({path:e="."})=>{try{return {content:[{type:"text",text:JSON.stringify(await Pt(e))}]}}catch(r){if(r instanceof Error)return {content:[{type:"text",text:r.message}]};throw r}});break}case "studio":{t.tool(ce,`${pe}
+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;
+    }
+  }
+}
+async function listDirectoryLocalMode(path2) {
+  const validatedPath = await validatePath(path2);
+  if (!existsSync6(validatedPath)) {
+    throw new Error(`Directory ${path2} does not exist.`);
+  }
+  const stats = statSync6(validatedPath);
+  if (!stats.isDirectory()) {
+    throw new Error(`Path ${path2} is not a directory.`);
+  }
+  const entries = await readdir(validatedPath);
+  const items = [];
+  for (const entry of entries.sort()) {
+    try {
+      const fullPath = await validatePath(join(validatedPath, entry));
+      const entryStats = statSync6(fullPath);
+      const item = {
+        name: entry,
+        path: entry,
+        type: entryStats.isDirectory() ? "directory" : "file",
+        size: entryStats.size,
+        modified: entryStats.mtime.toISOString()
+      };
+      items.push(item);
+    } catch (e) {
+      if (e instanceof Error && e.message.includes("perstack directory is not allowed")) {
+        continue;
+      }
+      throw e;
+    }
+  }
+  return {
+    path: validatedPath,
+    items
+  };
+}
+async function listDirectoryStudioMode(path2) {
+  const validatedPath = await validatePath(path2);
+  const relativePath = validatedPath.startsWith(workspacePath) ? validatedPath.slice(workspacePath.length + 1) : validatedPath;
+  const workspaceItems = await getWorkspaceItems();
+  const filteredItems = workspaceItems.filter((item) => {
+    if (relativePath === "" || relativePath === ".") {
+      return !item.path.includes("/");
+    }
+    const pathPrefix = relativePath.endsWith("/") ? relativePath : `${relativePath}/`;
+    return item.path.startsWith(pathPrefix) && !item.path.substring(pathPrefix.length).includes("/");
+  });
+  return {
+    path: relativePath,
+    items: filteredItems.map((item) => ({
+      name: item.path.split("/").pop() || item.path,
+      path: item.path,
+      type: item.type === "workspaceItemDirectory" ? "directory" : "file",
+      size: item.type === "workspaceItemFile" ? item.size : 0,
+      modified: item.updatedAt
+    }))
+  };
+}
 
-Mode: Studio (Workspace API)`,de,async({path:e="."})=>{try{return {content:[{type:"text",text:JSON.stringify(await bt(e))}]}}catch(r){if(r instanceof Error)return {content:[{type:"text",text:r.message}]};throw r}});break}}}async function Pt(t){let o=await a(t);if(!existsSync(o))throw new Error(`Directory ${t} does not exist.`);if(!statSync(o).isDirectory())throw new Error(`Path ${t} is not a directory.`);let r=await readdir(o),i=[];for(let s of r.sort())try{let n=await a(join(o,s)),d=statSync(n),p={name:s,path:s,type:d.isDirectory()?"directory":"file",size:d.size,modified:d.mtime.toISOString()};i.push(p);}catch(n){if(n instanceof Error&&n.message.includes("perstack directory is not allowed"))continue;throw n}return i}async function bt(t){let o=await a(t),e=o.startsWith(c)?o.slice(c.length+1):o;return (await W()).filter(s=>{if(e===""||e===".")return !s.path.includes("/");let n=e.endsWith("/")?e:`${e}/`;return s.path.startsWith(n)&&!s.path.substring(n.length).includes("/")}).map(s=>({name:s.path.split("/").pop()||s.path,path:s.path,type:s.type==="workspaceItemDirectory"?"directory":"file",size:s.type==="workspaceItemFile"?s.size:0,modified:s.updatedAt}))}var ue="moveFile",he=dedent`
+// 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:
@@ -167,11 +1162,140 @@ Mode: Studio (Workspace API)`,de,async({path:e="."})=>{try{return {content:[{typ
   Parameters:
   - source: Current file path
   - destination: Target file path
-`,we={source:z$1.string(),destination:z$1.string()};function ye(t){switch(m()){case "local":{t.tool(ue,`${he}
+`;
+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}
 
-Mode: Local (Local filesystem)`,we,async({source:e,destination:r})=>{try{return {content:[{type:"text",text:JSON.stringify(await xe(e,r))}]}}catch(i){if(i instanceof Error)return {content:[{type:"text",text:i.message}]};throw i}});break}case "studio":{t.tool(ue,`${he}
+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;
+    }
+  }
+}
+async function moveFileLocalMode(source, destination) {
+  const validatedSource = await validatePath(source);
+  const validatedDestination = await validatePath(destination);
+  if (!existsSync7(validatedSource)) {
+    throw new Error(`Source file ${source} does not exist.`);
+  }
+  const sourceStats = statSync7(validatedSource);
+  if (!(sourceStats.mode & 128)) {
+    throw new Error(`Source file ${source} is not writable`);
+  }
+  if (existsSync7(validatedDestination)) {
+    throw new Error(`Destination ${destination} already exists.`);
+  }
+  const destDir = dirname3(validatedDestination);
+  await mkdir2(destDir, { recursive: true });
+  await rename(validatedSource, validatedDestination);
+  return {
+    source: validatedSource,
+    destination: validatedDestination
+  };
+}
+async function moveFileStudioMode(source, destination) {
+  const validatedSource = await validatePath(source);
+  const validatedDestination = await validatePath(destination);
+  const relativeSource = validatedSource.startsWith(workspacePath) ? validatedSource.slice(workspacePath.length + 1) : validatedSource;
+  const relativeDestination = validatedDestination.startsWith(workspacePath) ? validatedDestination.slice(workspacePath.length + 1) : validatedDestination;
+  const sourceItem = await findWorkspaceItem(relativeSource);
+  if (!sourceItem) {
+    throw new Error(`Source file ${relativeSource} does not exist.`);
+  }
+  const destItem = await findWorkspaceItem(relativeDestination);
+  if (destItem) {
+    throw new Error(`Destination ${relativeDestination} already exists.`);
+  }
+  const destDir = dirname3(relativeDestination);
+  if (destDir !== "." && destDir !== "/") {
+    const destDirItem = await findWorkspaceItem(destDir);
+    if (!destDirItem) {
+      await createWorkspaceItem({
+        type: "workspaceItemDirectory",
+        path: destDir,
+        owner: "expert",
+        lifecycle: "expertJob",
+        permission: "readWrite"
+      });
+    }
+  }
+  await updateWorkspaceItem(sourceItem.id, {
+    path: relativeDestination
+  });
+  await moveFileLocalMode(source, destination);
+  return {
+    source: relativeSource,
+    destination: relativeDestination
+  };
+}
 
-Mode: Studio (Workspace API)`,we,async({source:e,destination:r})=>{try{return {content:[{type:"text",text:JSON.stringify(await Ot(e,r))}]}}catch(i){if(i instanceof Error)return {content:[{type:"text",text:i.message}]};throw i}});break}}}async function xe(t,o){let e=await a(t),r=await a(o);if(!existsSync(e))throw new Error(`Source file ${t} does not exist.`);if(!(statSync(e).mode&128))throw new Error(`Source file ${t} is not writable`);if(existsSync(r))throw new Error(`Destination ${o} already exists.`);let s=dirname(r);return await mkdir(s,{recursive:true}),await rename(e,r),r}async function Ot(t,o){let e=await a(t),r=await a(o),i=e.startsWith(c)?e.slice(c.length+1):e,s=r.startsWith(c)?r.slice(c.length+1):r,n=await l(i);if(!n)throw new Error(`Source file ${i} does not exist.`);if(await l(s))throw new Error(`Destination ${s} already exists.`);let p=dirname(s);return p!=="."&&p!=="/"&&(await l(p)||await f({type:"workspaceItemDirectory",path:p,permission:"readWrite"})),await A(n.id,{path:s}),await xe(t,o),s}var Te=15*1024*1024,$t="readImageFile",Ct=dedent`
+// 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:
@@ -193,7 +1317,64 @@ Mode: Studio (Workspace API)`,we,async({source:e,destination:r})=>{try{return {c
   
   Notes:
   - Maximum file size: 15MB (larger files will be rejected)
-`,zt={path:z$1.string()};function ke(t){t.tool($t,Ct,zt,async({path:o})=>{try{return {content:[{type:"text",text:JSON.stringify(await jt(o))}]}}catch(e){if(e instanceof Error)return {content:[{type:"text",text:e.message}]};throw e}});}async function jt(t){let o=await a(t);if(!existsSync(o))throw new Error(`File ${t} does not exist.`);let r=$e.lookup(o);if(!r||!["image/png","image/jpeg","image/gif","image/webp"].includes(r))throw new Error(`File ${t} is not supported.`);let i=await stat(o),s=i.size/(1024*1024);if(i.size>Te)throw new Error(`Image file too large (${s.toFixed(1)}MB). Maximum supported size is ${Te/(1024*1024)}MB. Please use a smaller image file.`);return {path:o,mimeType:r,size:i.size}}var Ie=30*1024*1024,Vt="readPdfFile",_t=dedent`
+`;
+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;
+    }
+  });
+}
+async function readImageFile(path2) {
+  const validatedPath = await validatePath(path2);
+  const isFile = existsSync8(validatedPath);
+  if (!isFile) {
+    throw new Error(`File ${path2} does not exist.`);
+  }
+  const mimeType = mime3.lookup(validatedPath);
+  if (!mimeType || !["image/png", "image/jpeg", "image/gif", "image/webp"].includes(mimeType)) {
+    throw new Error(`File ${path2} is not supported.`);
+  }
+  const fileStats = await stat(validatedPath);
+  const fileSizeMB = fileStats.size / (1024 * 1024);
+  if (fileStats.size > MAX_IMAGE_SIZE) {
+    throw new Error(
+      `Image file too large (${fileSizeMB.toFixed(1)}MB). Maximum supported size is ${MAX_IMAGE_SIZE / (1024 * 1024)}MB. Please use a smaller image file.`
+    );
+  }
+  return {
+    path: validatedPath,
+    mimeType,
+    size: fileStats.size
+  };
+}
+
+// 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:
@@ -211,7 +1392,62 @@ Mode: Studio (Workspace API)`,we,async({source:e,destination:r})=>{try{return {c
   - 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
-`,qt={path:z$1.string()};function Se(t){t.tool(Vt,_t,qt,async({path:o})=>{try{return {content:[{type:"text",text:JSON.stringify(await Xt(o))}]}}catch(e){if(e instanceof Error)return {content:[{type:"text",text:e.message}]};throw e}});}async function Xt(t){let o=await a(t);if(!existsSync(o))throw new Error(`File ${t} does not exist.`);let r=$e.lookup(o);if(r!=="application/pdf")throw new Error(`File ${t} is not a PDF file.`);let i=await stat(o),s=i.size/(1024*1024);if(i.size>Ie)throw new Error(`PDF file too large (${s.toFixed(1)}MB). Maximum supported size is ${Ie/(1024*1024)}MB. Please use a smaller PDF file.`);return {path:o,mimeType:r,size:i.size}}var eo="readTextFile",to=dedent`
+`;
+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;
+    }
+  });
+}
+async function readPdfFile(path2) {
+  const validatedPath = await validatePath(path2);
+  const isFile = existsSync9(validatedPath);
+  if (!isFile) {
+    throw new Error(`File ${path2} does not exist.`);
+  }
+  const mimeType = mime4.lookup(validatedPath);
+  if (mimeType !== "application/pdf") {
+    throw new Error(`File ${path2} is not a PDF file.`);
+  }
+  const fileStats = await stat2(validatedPath);
+  const fileSizeMB = fileStats.size / (1024 * 1024);
+  if (fileStats.size > MAX_PDF_SIZE) {
+    throw new Error(
+      `PDF file too large (${fileSizeMB.toFixed(1)}MB). Maximum supported size is ${MAX_PDF_SIZE / (1024 * 1024)}MB. Please use a smaller PDF file.`
+    );
+  }
+  return {
+    path: validatedPath,
+    mimeType,
+    size: fileStats.size
+  };
+}
+
+// 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:
@@ -231,9 +1467,58 @@ Mode: Studio (Workspace API)`,we,async({source:e,destination:r})=>{try{return {c
   - Documentation: .md, .txt, .rst
   - Configuration: .json, .yaml, .toml, .ini
   - Data files: .csv, .log, .sql
-`,oo={path:z$1.string(),from:z$1.number().optional().describe("The line number to start reading from."),to:z$1.number().optional().describe("The line number to stop reading at.")};function Ee(t){t.tool(eo,to,oo,async({path:o,from:e,to:r})=>{try{return {content:[{type:"text",text:JSON.stringify(await ro(o,e,r))}]}}catch(i){if(i instanceof Error)return {content:[{type:"text",text:i.message}]};throw i}});}async function ro(t,o,e){let r=await a(t);if(!existsSync(r))throw new Error(`File ${t} does not exist.`);let n=(await readFile(r,"utf-8")).split(`
-`),d=o??0,p=e??n.length,T=n.slice(d,p).join(`
-`);return {path:t,content:T,from:d,to:p}}var so="testUrl",no=dedent`
+`;
+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;
+    }
+  });
+}
+async function readTextFile(path2, from, to) {
+  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 lines = fileContent.split("\n");
+  const fromLine = from ?? 0;
+  const toLine = to ?? lines.length;
+  const selectedLines = lines.slice(fromLine, toLine);
+  const content = selectedLines.join("\n");
+  return {
+    path: path2,
+    content,
+    from: fromLine,
+    to: toLine
+  };
+}
+
+// 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:
@@ -253,7 +1538,137 @@ Mode: Studio (Workspace API)`,we,async({source:e,destination:r})=>{try{return {c
   - Maximum 10 URLs per request to prevent abuse
   - 10 second timeout per URL request
   - Returns empty title/description if HTML parsing fails
-`,ao={urls:z$1.array(z$1.string()).min(1).max(10).describe("Array of URLs to test (max 10 URLs).")};function Pe(t){t.tool(so,no,ao,async({urls:o})=>{try{let e=await co(o);return {content:[{type:"text",text:JSON.stringify(e,null,2)}]}}catch(e){if(e instanceof Error)return {content:[{type:"text",text:e.message}]};throw e}});}async function co(t){return (await Promise.allSettled(t.map(async e=>{try{let r=new AbortController,i=setTimeout(()=>r.abort(),1e4),s=await fetch(e,{method:"GET",signal:r.signal,headers:{"User-Agent":"Perstack URL Tester/1.0"}});clearTimeout(i);let n="",d="";if(s.ok&&s.headers.get("content-type")?.includes("text/html"))try{let p=await s.text();n=po(p),d=lo(p);}catch{}return {url:e,status:s.status,title:n,description:d}}catch(r){return {url:e,status:0,title:"",description:r instanceof Error?r.message:"Unknown error"}}}))).map(e=>e.status==="fulfilled"?e.value:{url:"unknown",status:0,title:"",description:"Promise rejected"})}function po(t){let o=t.match(/<title[^>]*>([^<]*)/i);return o?o[1].trim():""}function lo(t){let o=t.match(/<meta[^>]*name=["']description["'][^>]*content=["']([^"']*)["']/i);if(o)return o[1].trim();let e=t.match(/<meta[^>]*property=["']og:description["'][^>]*content=["']([^"']*)["']/i);return e?e[1].trim():""}var fo=z$1.object({thought:z$1.string().describe("Your current thinking step"),nextThoughtNeeded:z$1.boolean().optional().describe("true if you need more thinking, even if at what seemed like the end")}),v=class{thoughtHistory=[];branches={};processThought(o){let{nextThoughtNeeded:e}=o;return this.thoughtHistory.push(o),{content:[{type:"text",text:JSON.stringify({nextThoughtNeeded:e,thoughtHistoryLength:this.thoughtHistory.length})}]}}};function be(t){let o=new v;t.tool("think",dedent`
+`;
+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;
+    }
+  });
+}
+async function testUrls(urls) {
+  const results = await Promise.allSettled(
+    urls.map(async (url) => {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 1e4);
+        const response = await fetch(url, {
+          method: "GET",
+          signal: controller.signal,
+          headers: {
+            "User-Agent": "Perstack URL Tester/1.0"
+          }
+        });
+        clearTimeout(timeoutId);
+        let title = "";
+        let description = "";
+        if (response.ok && response.headers.get("content-type")?.includes("text/html")) {
+          try {
+            const html = await response.text();
+            title = extractTitle(html);
+            description = extractDescription(html);
+          } catch {
+          }
+        }
+        return {
+          url,
+          status: response.status,
+          title,
+          description
+        };
+      } catch (error) {
+        return {
+          url,
+          status: 0,
+          title: "",
+          description: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    })
+  );
+  return {
+    results: results.map((result) => {
+      if (result.status === "fulfilled") {
+        return result.value;
+      }
+      return {
+        url: "unknown",
+        status: 0,
+        title: "",
+        description: "Promise rejected"
+      };
+    })
+  };
+}
+function extractTitle(html) {
+  const titleMatch = html.match(/<title[^>]*>([^<]*)/i);
+  return titleMatch ? titleMatch[1].trim() : "";
+}
+function extractDescription(html) {
+  const metaDescMatch = html.match(
+    /<meta[^>]*name=["']description["'][^>]*content=["']([^"']*)["']/i
+  );
+  if (metaDescMatch) {
+    return metaDescMatch[1].trim();
+  }
+  const ogDescMatch = html.match(
+    /<meta[^>]*property=["']og:description["'][^>]*content=["']([^"']*)["']/i
+  );
+  if (ogDescMatch) {
+    return ogDescMatch[1].trim();
+  }
+  return "";
+}
+
+// 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 Thought = class {
+  thoughtHistory = [];
+  branches = {};
+  processThought(input) {
+    const { nextThoughtNeeded } = input;
+    this.thoughtHistory.push(input);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            nextThoughtNeeded,
+            thoughtHistoryLength: this.thoughtHistory.length
+          })
+        }
+      ]
+    };
+  }
+};
+function addThinkTool(server) {
+  const thought = new Thought();
+  server.tool(
+    "think",
+    dedent13`
       Sequential thinking tool for step-by-step problem analysis and solution development.
 
       Use cases:
@@ -278,7 +1693,54 @@ Mode: Studio (Workspace API)`,we,async({source:e,destination:r})=>{try{return {c
       - 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
-    `,fo.shape,async e=>o.processThought(e));}var ho=z$1.object({newTodos:z$1.array(z$1.string()).describe("New todos to add").optional(),completedTodos:z$1.array(z$1.number()).describe("Todo ids that are completed").optional()}),P=class{currentTodoId=0;todos=[];processTodo(o){let{newTodos:e,completedTodos:r}=o;return e&&this.todos.push(...e.map(i=>({id:this.currentTodoId++,title:i,completed:false}))),r&&(this.todos=this.todos.map(i=>({...i,completed:i.completed||r.includes(i.id)}))),{content:[{type:"text",text:JSON.stringify({todos:this.todos})}]}}};function Me(t){let o=new P;t.tool("todo",dedent`
+    `,
+    ThoughtInputSchema.shape,
+    async (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 = [];
+  processTodo(input) {
+    const { newTodos, completedTodos } = input;
+    if (newTodos) {
+      this.todos.push(
+        ...newTodos.map((title) => ({ id: this.currentTodoId++, title, completed: false }))
+      );
+    }
+    if (completedTodos) {
+      this.todos = this.todos.map((todo) => ({
+        ...todo,
+        completed: todo.completed || completedTodos.includes(todo.id)
+      }));
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            todos: this.todos
+          })
+        }
+      ]
+    };
+  }
+};
+function addTodoTool(server) {
+  const todo = new Todo();
+  server.tool(
+    "todo",
+    dedent14`
       Todo list manager that tracks tasks and their completion status.
 
       Use cases:
@@ -294,7 +1756,23 @@ Mode: Studio (Workspace API)`,we,async({source:e,destination:r})=>{try{return {c
       Parameters:
       - newTodos: Array of task descriptions to add
       - completedTodos: Array of todo IDs to mark as completed
-    `,ho.shape,async e=>o.processTodo(e));}var Ae="writeTextFile",We=dedent`
+    `,
+    TodoInputSchema.shape,
+    async (input) => {
+      return todo.processTodo(input);
+    }
+  );
+}
+
+// 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:
@@ -312,9 +1790,166 @@ Mode: Studio (Workspace API)`,we,async({source:e,destination:r})=>{try{return {c
   - 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
-`,Oe={path:z$1.string().describe("Target file path (relative or absolute)."),text:z$1.string().min(1).max(2e3).describe("Text to write to the file. Max 2000 characters.")};function De(t){switch(m()){case "local":{t.tool(Ae,`${We}
+`;
+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}
+
+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}
 
-Mode: Local (Local filesystem)`,Oe,async({path:e,text:r})=>{try{return {content:[{type:"text",text:JSON.stringify(await Re(e,r))}]}}catch(i){if(i instanceof Error)return {content:[{type:"text",text:i.message}]};throw i}});break}case "studio":{t.tool(Ae,`${We}
+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;
+    }
+  }
+}
+async function writeTextFileLocalMode(path2, text) {
+  const validatedPath = await validatePath(path2);
+  if (existsSync11(validatedPath)) {
+    const stats = statSync8(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");
+  return {
+    path: validatedPath,
+    text
+  };
+}
+async function writeTextFileStudioMode(path2, text) {
+  const validatedPath = await validatePath(path2);
+  const relativePath = validatedPath.startsWith(workspacePath) ? validatedPath.slice(workspacePath.length + 1) : validatedPath;
+  const existingItem = await findWorkspaceItem(relativePath);
+  if (existingItem) {
+    if (existingItem.type === "workspaceItemDirectory") {
+      throw new Error(`Path ${relativePath} is a directory`);
+    }
+    throw new Error("Updating existing file content is not supported yet");
+  }
+  const pathParts = relativePath.split("/").filter((part) => part !== "");
+  for (let i = 1; i < pathParts.length; i++) {
+    const currentPath = pathParts.slice(0, i).join("/");
+    if (currentPath === "") continue;
+    const existingParent = await findWorkspaceItem(currentPath);
+    if (!existingParent) {
+      await createWorkspaceItem({
+        type: "workspaceItemDirectory",
+        path: currentPath,
+        owner: "expert",
+        lifecycle: "expertJob",
+        permission: "readWrite"
+      });
+    }
+  }
+  await createWorkspaceItem(
+    {
+      type: "workspaceItemFile",
+      path: relativePath,
+      owner: "expert",
+      lifecycle: "expertJob",
+      permission: "readWrite"
+    },
+    text
+  );
+  await writeTextFileLocalMode(path2, text);
+  return {
+    path: relativePath,
+    text
+  };
+}
 
-Mode: Studio (Workspace API)`,Oe,async({path:e,text:r})=>{try{return {content:[{type:"text",text:JSON.stringify(await Io(e,r))}]}}catch(i){if(i instanceof Error)return {content:[{type:"text",text:i.message}]};throw i}});break}}}async function Re(t,o){let e=await a(t);if(existsSync(e)&&!(statSync(e).mode&128))throw new Error(`File ${t} is not writable`);let r=dirname(e);return await mkdir(r,{recursive:true}),await writeFile(e,o,"utf-8"),{path:e}}async function Io(t,o){let e=await a(t),r=e.startsWith(c)?e.slice(c.length+1):e,i=await l(r);if(i)throw i.type==="workspaceItemDirectory"?new Error(`Path ${r} is a directory`):new Error("Updating existing file content is not supported yet");let s=r.split("/").filter(n=>n!=="");for(let n=1;n<s.length;n++){let d=s.slice(0,n).join("/");if(d==="")continue;await l(d)||await f({type:"workspaceItemDirectory",path:d,permission:"readWrite"});}return await f({type:"workspaceItemFile",path:r,permission:"readWrite"},o),await Re(t,o),{path:r}}async function Po(){let t=new Command;t.name(h.name).description(h.description).version(h.version,"-v, --version","display the version number").action(async()=>{let o=new McpServer({name:h.name,version:h.version},{capabilities:{tools:{}}});$(o),be(o),Me(o),ke(o),Se(o),Ee(o),ee(o),N(o),_(o),ye(o),se(o),De(o),J(o),le(o),Pe(o);let e=new StdioServerTransport;await o.connect(e);}),t.parse();}Po();//# sourceMappingURL=index.js.map
+// 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();
 //# sourceMappingURL=index.js.map