@lvce-editor/static-server 0.77.7 → 0.77.9

package/static/{fd1a2e0 → 2c0fc7e}/packages/chat-tool-worker/dist/chatToolWorkerMain.js

@@ -407,6 +407,9 @@ const IpcChildWithModuleWorkerAndMessagePort$1 = {
   listen: listen$6,
   wrap: wrap$e
 };
+const Error$3 = 1;
+const Open = 2;
+const Close = 3;
 const addListener = (emitter, type, callback) => {
   if ('addEventListener' in emitter) {
     emitter.addEventListener(type, callback);
@@ -501,6 +504,66 @@ const IpcParentWithMessagePort$1 = {
   signal: signal$1,
   wrap: wrap$5
 };
+const stringifyCompact = value => {
+  return JSON.stringify(value);
+};
+const parse = content => {
+  if (content === 'undefined') {
+    return null;
+  }
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    throw new VError(error, 'failed to parse json');
+  }
+};
+const waitForWebSocketToBeOpen = webSocket => {
+  return getFirstEvent(webSocket, {
+    close: Close,
+    error: Error$3,
+    open: Open
+  });
+};
+const create$c = async ({
+  webSocket
+}) => {
+  const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
+  if (firstWebSocketEvent.type === Error$3) {
+    throw new IpcError(`WebSocket connection error`);
+  }
+  if (firstWebSocketEvent.type === Close) {
+    throw new IpcError('Websocket connection was immediately closed');
+  }
+  return webSocket;
+};
+class IpcParentWithWebSocket extends Ipc {
+  getData(event) {
+    return parse(event.data);
+  }
+  send(message) {
+    this._rawIpc.send(stringifyCompact(message));
+  }
+  sendAndTransfer(message) {
+    throw new Error('sendAndTransfer not supported');
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onClose(callback) {
+    this._rawIpc.addEventListener('close', callback);
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap = webSocket => {
+  return new IpcParentWithWebSocket(webSocket);
+};
+const IpcParentWithWebSocket$1 = {
+  __proto__: null,
+  create: create$c,
+  wrap
+};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -737,7 +800,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$9 = (message, result) => {
+const create$b = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$1,
@@ -746,7 +809,7 @@ const create$9 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$9(message, resultProperty);
+  return create$b(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -840,7 +903,7 @@ const handleJsonRpcMessage = async (...args) => {
 
 const Two = '2.0';
 
-const create$8 = (method, params) => {
+const create$a = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -848,7 +911,7 @@ const create$8 = (method, params) => {
   };
 };
 
-const create$7 = (id, method, params) => {
+const create$9 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -859,12 +922,12 @@ const create$7 = (id, method, params) => {
 };
 
 let id = 0;
-const create$6 = () => {
+const create$8 = () => {
   return ++id;
 };
 
 const registerPromise = map => {
-  const id = create$6();
+  const id = create$8();
   const {
     promise,
     resolve
@@ -881,7 +944,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$7(id, method, params);
+  const message = create$9(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -917,7 +980,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$8(method, params);
+      const message = create$a(method, params);
       ipc.send(message);
     }
   };
@@ -957,7 +1020,7 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
-const create$5 = async ({
+const create$7 = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -975,7 +1038,7 @@ const create$5 = async ({
   return rpc;
 };
 
-const create$4 = async ({
+const create$6 = async ({
   commandMap,
   isMessagePortOpen,
   send
@@ -985,7 +1048,7 @@ const create$4 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$5({
+  return create$7({
     commandMap,
     isMessagePortOpen,
     messagePort: port2
@@ -1020,13 +1083,13 @@ const createSharedLazyRpc = factory => {
   };
 };
 
-const create$3 = async ({
+const create$5 = async ({
   commandMap,
   isMessagePortOpen,
   send
 }) => {
   return createSharedLazyRpc(() => {
-    return create$4({
+    return create$6({
       commandMap,
       isMessagePortOpen,
       send
@@ -1034,6 +1097,56 @@ const create$3 = async ({
   });
 };
 
+const Https = 'https:';
+const Ws = 'ws:';
+const Wss = 'wss:';
+
+const getWebSocketProtocol = locationProtocol => {
+  return locationProtocol === Https ? Wss : Ws;
+};
+
+const getWebSocketUrl = (type, host, locationProtocol) => {
+  const wsProtocol = getWebSocketProtocol(locationProtocol);
+  return `${wsProtocol}//${host}/websocket/${type}`;
+};
+
+const getHost = () => {
+  return location.host;
+};
+const getProtocol = () => {
+  return location.protocol;
+};
+
+const create$4 = async ({
+  commandMap,
+  webSocket
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithWebSocket$1.create({
+    webSocket
+  });
+  const ipc = IpcParentWithWebSocket$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+
+const create$3 = async ({
+  commandMap,
+  type
+}) => {
+  const host = getHost();
+  const protocol = getProtocol();
+  const wsUrl = getWebSocketUrl(type, host, protocol);
+  const webSocket = new WebSocket(wsUrl);
+  const rpc = await create$4({
+    commandMap,
+    webSocket
+  });
+  return rpc;
+};
+
 const create$2 = async ({
   commandMap,
   messagePort
@@ -1080,7 +1193,7 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$3 = (id, rpc) => {
+const set$4 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
@@ -1113,7 +1226,7 @@ const create = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$3(rpcId, mockRpc);
+      set$4(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -1122,45 +1235,75 @@ const create = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$3(rpcId, rpc);
+      set$4(rpcId, rpc);
     }
   };
 };
 
+const Directory = 3;
+const File = 7;
+const Symlink = 9;
+
+const Electron = 2;
+const Remote = 3;
+
 const ChatStorageWorker = 6003;
 const FileSystemWorker = 209;
 const RendererWorker = 1;
+const TerminalProcess = 7;
 
 const {
-  set: set$2
+  set: set$3
 } = create(ChatStorageWorker);
 
 const {
-  set: set$1
+  invoke: invoke$2,
+  set: set$2
 } = create(FileSystemWorker);
+const readDirWithFileTypes = async uri => {
+  return invoke$2('FileSystem.readDirWithFileTypes', uri);
+};
+const readFile$1 = async uri => {
+  return invoke$2('FileSystem.readFile', uri);
+};
+const writeFile$1 = async (uri, content) => {
+  return invoke$2('FileSystem.writeFile', uri, content);
+};
+const exists = async uri => {
+  return invoke$2('FileSystem.exists', uri);
+};
 
 const {
-  invoke,
+  invoke: invoke$1,
   invokeAndTransfer,
-  set
+  set: set$1
 } = create(RendererWorker);
+const sendMessagePortToTerminalProcess = async (port, rpcId) => {
+  const command = 'HandleMessagePortForTerminalProcess.handleMessagePortForTerminalProcess';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToTerminalProcess', port, command, rpcId);
+};
 const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
   const command = 'FileSystem.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
 };
 const readFile = async uri => {
-  return invoke('FileSystem.readFile', uri);
+  return invoke$1('FileSystem.readFile', uri);
 };
 const sendMessagePortToChatStorageWorker = async port => {
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatStorageWorker', port, 'HandleMessagePort.handleMessagePort');
 };
 const writeFile = async (uri, text) => {
-  await invoke('FileSystem.writeFile', uri, text);
+  await invoke$1('FileSystem.writeFile', uri, text);
 };
 const getWorkspacePath = () => {
-  return invoke('Workspace.getPath');
+  return invoke$1('Workspace.getPath');
 };
 
+const {
+  invoke,
+  set
+} = create(TerminalProcess);
+
 const getToolErrorPayload = error => {
   const rawStack = error && typeof error === 'object' ? Reflect.get(error, 'stack') : undefined;
   return {
@@ -1174,7 +1317,7 @@ const getToolErrorPayload = error => {
 
 const executeClosePreviewTool = async (_args, _options) => {
   try {
-    await invoke('Preview.close');
+    await invoke$1('Preview.close');
     return {
       ok: true
     };
@@ -1203,7 +1346,7 @@ const executeCreateDirectoryTool = async (args, _options) => {
     };
   }
   try {
-    await invoke('FileSystem.mkdir', uri);
+    await invoke$1('FileSystem.mkdir', uri);
     return {
       ok: true,
       uri
@@ -1282,6 +1425,197 @@ const executeGetWorkspaceUriTool = async (_args, _options) => {
   }
 };
 
+/**
+ * Matches a string against a glob pattern
+ * Supported patterns:
+ * - * matches any characters except /
+ * - ? matches a single character except /
+ * - ** matches any characters including /
+ * - [abc] matches a, b, or c
+ * - [!abc] matches any character except a, b, c
+ * - [a-z] matches any character between a and z
+ */
+
+const REGEX_SPECIAL_CHARS_REGEX = /[.*+?^${}()|[\]\\]/g;
+const LEADING_DOT_SLASH_REGEX$1 = /^\.\//g;
+const MULTIPLE_SLASHES_REGEX$1 = /\/+/g;
+const escapeRegExp = str => {
+  return str.replaceAll(REGEX_SPECIAL_CHARS_REGEX, '\\$&');
+};
+
+/*
+ * Convert a glob pattern to a regex, but only for segments between separators
+ */
+const segmentToRegex = segment => {
+  let regexStr = '';
+  let i = 0;
+  while (i < segment.length) {
+    const char = segment[i];
+    switch (char) {
+      case '?':
+        {
+          regexStr += '[^/]';
+          i++;
+          break;
+        }
+      case '[':
+        {
+          let j = i + 1;
+          let negated = false;
+          if (j < segment.length && segment[j] === '!') {
+            negated = true;
+            j++;
+          }
+          let classStr = '';
+          while (j < segment.length && segment[j] !== ']') {
+            classStr += segment[j];
+            j++;
+          }
+          if (j < segment.length) {
+            if (negated) {
+              regexStr += `[^${escapeRegExp(classStr)}]`;
+            } else {
+              regexStr += `[${classStr.replaceAll('\\', '\\\\')}]`;
+            }
+            i = j + 1;
+          } else {
+            regexStr += escapeRegExp(char);
+            i++;
+          }
+          break;
+        }
+      case '*':
+        {
+          regexStr += '[^/]*';
+          i++;
+          break;
+        }
+      default:
+        {
+          regexStr += escapeRegExp(char);
+          i++;
+        }
+    }
+  }
+  return new RegExp(`^${regexStr}$`);
+};
+const matchesGlobPattern = (path, pattern) => {
+  const normalizedPath = path.replaceAll('\\', '/').replaceAll(LEADING_DOT_SLASH_REGEX$1, '');
+  let normalizedPattern = pattern.replaceAll('\\', '/').replaceAll(LEADING_DOT_SLASH_REGEX$1, '').replaceAll(MULTIPLE_SLASHES_REGEX$1, '/');
+  if (normalizedPattern.endsWith('/')) {
+    normalizedPattern = normalizedPattern.slice(0, -1) + '/*';
+  }
+  const patternParts = normalizedPattern.split('/');
+  const pathParts = normalizedPath.split('/');
+  return matchesPatternParts(pathParts, patternParts, 0, 0);
+};
+const matchesPatternParts = (pathParts, patternParts, pathIdx, patternIdx) => {
+  if (patternIdx === patternParts.length) {
+    return pathIdx === pathParts.length;
+  }
+  if (pathIdx > pathParts.length) {
+    return false;
+  }
+  const patternPart = patternParts[patternIdx];
+  if (patternPart === undefined) {
+    return false;
+  }
+  if (patternPart === '**') {
+    for (let i = pathIdx; i <= pathParts.length; i++) {
+      if (matchesPatternParts(pathParts, patternParts, i, patternIdx + 1)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  if (pathIdx === pathParts.length) {
+    return false;
+  }
+  if (patternPart.includes('**')) {
+    const regex = segmentToRegex(patternPart.replace('**', ''));
+    const pathPart = pathParts[pathIdx];
+    if (pathPart !== undefined && regex.test(pathPart)) {
+      return matchesPatternParts(pathParts, patternParts, pathIdx + 1, patternIdx + 1);
+    }
+    return false;
+  }
+  const regex = segmentToRegex(patternPart);
+  const pathPart = pathParts[pathIdx];
+  if (pathPart !== undefined && regex.test(pathPart)) {
+    return matchesPatternParts(pathParts, patternParts, pathIdx + 1, patternIdx + 1);
+  }
+  return false;
+};
+
+// cspell:ignore venv
+const DEFAULT_EXCLUDE_DIRS = new Set(['.git', 'node_modules', '.cache', '.venv', 'dist', 'build', '.next', '.nuxt']);
+const shouldExcludeDir = dirName => {
+  return DEFAULT_EXCLUDE_DIRS.has(dirName);
+};
+const traverseDirectory = async (baseUri, currentPath, onEntry) => {
+  const visited = new Set();
+  const visit = async path => {
+    const uri = path === '' ? baseUri : `${baseUri}/${path}`;
+    if (visited.has(uri)) {
+      return;
+    }
+    visited.add(uri);
+    try {
+      const entries = await readDirWithFileTypes(uri);
+      for (const entry of entries) {
+        const entryPath = path === '' ? entry.name : `${path}/${entry.name}`;
+        await onEntry(entryPath, entry);
+        if (entry.type === Directory && !shouldExcludeDir(entry.name)) {
+          await visit(entryPath);
+        }
+      }
+    } catch (error) {
+      if (path === '') {
+        throw error;
+      }
+      // Ignore unreadable directories and continue with other matches.
+    }
+  };
+  return visit(currentPath);
+};
+
+const MULTIPLE_SLASHES_REGEX = /\/+/g;
+const LEADING_DOT_SLASH_REGEX = /^\.\//g;
+const PLACEHOLDER_WORKSPACE_URI = 'file:///workspace';
+const hasGlobCharacters = part => {
+  return part.includes('*') || part.includes('?') || part.includes('[');
+};
+const normalizeInputPattern = pattern => {
+  return pattern.trim().replaceAll('\\', '/').replaceAll(LEADING_DOT_SLASH_REGEX, '').replaceAll(MULTIPLE_SLASHES_REGEX, '/');
+};
+const normalizePattern = pattern => {
+  const normalized = normalizeInputPattern(pattern);
+  const matchDirectories = normalized.endsWith('/');
+  const patternToParse = matchDirectories ? normalized.slice(0, -1) : normalized;
+  const parts = patternToParse.split('/');
+  let firstGlobIndex = -1;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part && hasGlobCharacters(part)) {
+      firstGlobIndex = i;
+      break;
+    }
+  }
+  const globPartIndex = firstGlobIndex === -1 ? Math.max(parts.length - 1, 0) : firstGlobIndex;
+  const baseDir = parts.slice(0, globPartIndex).join('/');
+  const globPart = parts.slice(globPartIndex).join('/');
+  return {
+    baseDir,
+    globPart,
+    matchDirectories
+  };
+};
+const joinUri = (baseUri, path) => {
+  if (!path) {
+    return baseUri;
+  }
+  return baseUri.endsWith('/') ? `${baseUri}${path}` : `${baseUri}/${path}`;
+};
 const executeGlobTool = async (args, _options) => {
   const pattern = typeof args.pattern === 'string' ? args.pattern : '';
   if (!pattern) {
@@ -1289,19 +1623,125 @@ const executeGlobTool = async (args, _options) => {
       error: 'Invalid argument: pattern must be a non-empty string.'
     };
   }
-  const paths = ['./src/main.ts', './src/utils/search.ts', './test/Main.test.ts'];
-  return {
-    paths,
-    pattern
-  };
+  const baseUri = typeof args.baseUri === 'string' ? args.baseUri : '';
+  if (!baseUri || !isAbsoluteUri(baseUri)) {
+    return {
+      error: 'Invalid argument: baseUri must be an absolute URI.'
+    };
+  }
+  if (baseUri === PLACEHOLDER_WORKSPACE_URI || baseUri.startsWith(`${PLACEHOLDER_WORKSPACE_URI}/`)) {
+    return {
+      baseUri,
+      error: 'Invalid argument: baseUri must be a real workspace folder URI. Call getWorkspaceUri first and use the returned workspaceUri value.'
+    };
+  }
+  const normalizedPattern = normalizeInputPattern(pattern);
+  const {
+    baseDir,
+    globPart,
+    matchDirectories
+  } = normalizePattern(pattern);
+  const matches = [];
+  try {
+    if (matchDirectories) {
+      const dirUri = joinUri(baseUri, globPart);
+      const entries = await readDirWithFileTypes(dirUri);
+      for (const entry of entries) {
+        matches.push(globPart ? `${globPart}/${entry.name}` : entry.name);
+      }
+    } else if (globPart.includes('**')) {
+      const baseDirUri = joinUri(baseUri, baseDir);
+      await traverseDirectory(baseDirUri, '', async (relativePath, entry) => {
+        if (entry.type !== File) {
+          return;
+        }
+        const fullPath = baseDir ? `${baseDir}/${relativePath}` : relativePath;
+        if (matchesGlobPattern(fullPath, normalizedPattern)) {
+          matches.push(fullPath);
+        }
+      });
+    } else {
+      const dirUri = joinUri(baseUri, baseDir);
+      const entries = await readDirWithFileTypes(dirUri);
+      for (const entry of entries) {
+        const fullPath = baseDir ? `${baseDir}/${entry.name}` : entry.name;
+        if (matchesGlobPattern(fullPath, normalizedPattern)) {
+          matches.push(fullPath);
+        }
+      }
+    }
+    matches.sort();
+    return {
+      paths: matches,
+      pattern
+    };
+  } catch (error) {
+    return {
+      error: `Failed to glob: ${error instanceof Error ? error.message : String(error)}`,
+      pattern
+    };
+  }
 };
 
-const formatSearchProcessResults = results => {
+const escapeXml = value => {
+  return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;');
+};
+const formatTextMatches = matches => {
+  const lines = [];
+  for (const match of matches) {
+    if (typeof match.lineNumber === 'number') {
+      lines.push(`${match.path}:${match.lineNumber}:${match.text}`);
+    } else {
+      lines.push(`${match.path}: ${match.text}`);
+    }
+  }
+  return lines.join('\n');
+};
+const formatXmlMatches = matches => {
+  const lines = [`${matches.length} matches`];
+  for (const match of matches) {
+    const attributes = [`path="${escapeXml(match.path)}"`];
+    if (typeof match.lineNumber === 'number') {
+      attributes.push(`line="${match.lineNumber}"`);
+    }
+    lines.push(`<match ${attributes.join(' ')}>`);
+    lines.push(escapeXml(match.text));
+    lines.push('</match>');
+  }
+  return lines.join('\n');
+};
+const formatJsonMatches = matches => {
+  return JSON.stringify({
+    count: matches.length,
+    matches: matches.map(match => ({
+      ...(typeof match.lineNumber === 'number' ? {
+        line: match.lineNumber
+      } : {}),
+      path: match.path,
+      text: match.text
+    }))
+  }, undefined, 2);
+};
+const formatGrepMatches = (matches, outputFormat) => {
+  if (matches.length === 0) {
+    return 'No matches found.';
+  }
+  switch (outputFormat) {
+    case 'json':
+      return formatJsonMatches(matches);
+    case 'xml':
+      return formatXmlMatches(matches);
+    default:
+      return formatTextMatches(matches);
+  }
+};
+
+const formatSearchProcessResults = (results, outputFormat) => {
   if (!results || results.length === 0) {
     return 'No matches found.';
   }
   let currentFile = '';
-  const lines = [];
+  const matches = [];
   for (const result of results) {
     if (result.type === 1) {
       currentFile = result.text;
@@ -1309,16 +1749,24 @@ const formatSearchProcessResults = results => {
     }
     if (result.type === 2) {
       if (currentFile) {
-        lines.push(`${currentFile}:${result.lineNumber}:${result.text}`);
+        matches.push({
+          lineNumber: result.lineNumber,
+          path: currentFile,
+          text: result.text
+        });
       } else {
-        lines.push(`${result.lineNumber}:${result.text}`);
+        matches.push({
+          lineNumber: result.lineNumber,
+          path: '',
+          text: result.text
+        });
       }
     }
   }
-  if (lines.length === 0) {
+  if (matches.length === 0) {
     return 'No matches found.';
   }
-  return lines.join('\n');
+  return formatGrepMatches(matches, outputFormat);
 };
 
 const windowsDrivePathRegex = /^[a-zA-Z]:[\\/]/;
@@ -1383,14 +1831,14 @@ const getSearchDir = (workspaceUri, includePattern) => {
 };
 
 const executeFileGrepSearch = async (workspaceUri, grepSearchArgs) => {
-  const result = await invoke('SearchProcess.invoke', 'TextSearch.search', {
+  const result = await invoke$1('SearchProcess.invoke', 'TextSearch.search', {
     maxSearchResults: grepSearchArgs.maxResults,
     ripGrepArgs: getRipGrepArgs(grepSearchArgs),
     searchDir: getSearchDir(workspaceUri, grepSearchArgs.includePattern)
   });
   return {
     arguments: grepSearchArgs,
-    result: formatSearchProcessResults(result.results),
+    result: formatSearchProcessResults(result.results, grepSearchArgs.outputFormat),
     workspaceUri,
     ...(result.limitHit ? {
       warning: 'Search result limit reached.'
@@ -1398,19 +1846,25 @@ const executeFileGrepSearch = async (workspaceUri, grepSearchArgs) => {
   };
 };
 
-const formatLegacyMemorySearchResults = results => {
-  const lines = [];
+const formatLegacyMemorySearchResults = (results, outputFormat) => {
+  const matches = [];
   for (const result of results) {
-    const [path, matches] = result;
-    for (const match of matches) {
+    const [path, resultMatches] = result;
+    for (const match of resultMatches) {
       const preview = typeof match?.preview === 'string' ? match.preview : '';
-      lines.push(preview ? `${path}: ${preview}` : path);
+      matches.push(preview ? {
+        path,
+        text: preview
+      } : {
+        path,
+        text: ''
+      });
     }
   }
-  if (lines.length === 0) {
+  if (matches.length === 0) {
     return 'No matches found.';
   }
-  return lines.join('\n');
+  return formatGrepMatches(matches, outputFormat);
 };
 
 const isLegacyMemorySearchResult = value => {
@@ -1429,20 +1883,20 @@ const executeMemoryGrepSearch = async (workspaceUri, grepSearchArgs, options) =>
     useRegularExpression: grepSearchArgs.isRegexp
   };
   try {
-    const result = await invoke('ExtensionHostTextSearch.textSearchMemory2', searchOptions.scheme, workspaceUri, grepSearchArgs.query, searchOptions, options.assetDir);
+    const result = await invoke$1('ExtensionHostTextSearch.textSearchMemory2', searchOptions.scheme, workspaceUri, grepSearchArgs.query, searchOptions, options.assetDir);
     return {
       arguments: grepSearchArgs,
-      result: formatLegacyMemorySearchResults(result.results || []),
+      result: formatLegacyMemorySearchResults(result.results || [], grepSearchArgs.outputFormat),
       workspaceUri,
       ...(result.limitHit ? {
         warning: 'Search result limit reached.'
       } : {})
     };
   } catch {
-    const legacyResults = await invoke('ExtensionHostTextSearch.textSearchMemory', searchOptions.scheme, workspaceUri, grepSearchArgs.query, searchOptions, options.assetDir);
+    const legacyResults = await invoke$1('ExtensionHostTextSearch.textSearchMemory', searchOptions.scheme, workspaceUri, grepSearchArgs.query, searchOptions, options.assetDir);
     return {
       arguments: grepSearchArgs,
-      result: isLegacyMemorySearchResult(legacyResults) ? formatLegacyMemorySearchResults(legacyResults) : 'No matches found.',
+      result: isLegacyMemorySearchResult(legacyResults) ? formatLegacyMemorySearchResults(legacyResults, grepSearchArgs.outputFormat) : 'No matches found.',
       workspaceUri
     };
   }
@@ -1454,6 +1908,7 @@ const getGrepSearchArgs = args => {
     includePattern,
     isRegexp,
     maxResults,
+    outputFormat,
     query
   } = args;
   if (typeof query !== 'string' || typeof isRegexp !== 'boolean') {
@@ -1468,6 +1923,9 @@ const getGrepSearchArgs = args => {
   if (includeIgnoredFiles !== undefined && typeof includeIgnoredFiles !== 'boolean') {
     return undefined;
   }
+  if (outputFormat !== undefined && outputFormat !== 'xml' && outputFormat !== 'json') {
+    return undefined;
+  }
   return {
     ...(includeIgnoredFiles === undefined ? {} : {
       includeIgnoredFiles
@@ -1478,12 +1936,15 @@ const getGrepSearchArgs = args => {
     ...(maxResults === undefined ? {} : {
       maxResults
     }),
+    ...(outputFormat === undefined ? {} : {
+      outputFormat
+    }),
     isRegexp,
     query
   };
 };
 
-const grepSearchArgumentError = 'Invalid argument: grep_search requires query (string), isRegexp (boolean), optional includePattern (string), optional maxResults (number), and optional includeIgnoredFiles (boolean).';
+const grepSearchArgumentError = 'Invalid argument: grep_search requires query (string), isRegexp (boolean), optional includePattern (string), optional maxResults (number), optional includeIgnoredFiles (boolean), and optional outputFormat ("xml" | "json").';
 
 const executeGrepSearchTool = async (args, options) => {
   const grepSearchArgs = getGrepSearchArgs(args);
@@ -1507,6 +1968,22 @@ const executeGrepSearchTool = async (args, options) => {
   }
 };
 
+const getEntryType = type => {
+  switch (type) {
+    case Directory:
+      return 'folder';
+    case File:
+      return 'file';
+    case Symlink:
+      return 'symlink';
+    default:
+      return 'unknown';
+  }
+};
+const mapEntry = entry => ({
+  name: entry.name,
+  type: getEntryType(entry.type)
+});
 const executeListFilesTool = async (args, _options) => {
   const uri = typeof args.uri === 'string' ? args.uri : '';
   if (!uri || !isAbsoluteUri(uri)) {
@@ -1521,9 +1998,9 @@ const executeListFilesTool = async (args, _options) => {
     };
   }
   try {
-    const entries = await invoke('FileSystem.readDirWithFileTypes', uri);
+    const entries = await invoke$1('FileSystem.readDirWithFileTypes', uri);
     return {
-      entries,
+      entries: entries.map(mapEntry),
       uri
     };
   } catch (error) {
@@ -1542,7 +2019,7 @@ const executeOpenEditorTool = async (args, _options) => {
     };
   }
   try {
-    await invoke('Main.openUri', uri);
+    await invoke$1('Main.openUri', uri);
     return {
       ok: true,
       uri
@@ -1563,7 +2040,7 @@ const executeOpenPreviewTool = async (args, _options) => {
     };
   }
   try {
-    await invoke('Preview.open', uri);
+    await invoke$1('Preview.open', uri);
     return {
       ok: true,
       uri
@@ -1597,8 +2074,6 @@ const executeReadFileTool = async (args, _options) => {
   }
 };
 
-/* eslint-disable @cspell/spellchecker */
-/* eslint-disable e18e/prefer-url-canparse */
 const executeRenameTool = async (args, _options) => {
   const oldUri = typeof args.oldUri === 'string' ? args.oldUri : '';
   const newUri = typeof args.newUri === 'string' ? args.newUri : '';
@@ -1612,26 +2087,25 @@ const executeRenameTool = async (args, _options) => {
       error: 'Invalid argument: newUri must be an absolute URI.'
     };
   }
-  try {
-    new URL(oldUri);
-    new URL(newUri);
-  } catch {
+  if (!URL.canParse(oldUri) || !URL.canParse(newUri)) {
     return {
       error: 'Invalid argument: invalid URL.'
     };
   }
+  const oldUrl = new URL(oldUri);
+  const newUrl = new URL(newUri);
   try {
-    await invoke('FileSystem.rename', oldUri, newUri);
+    await invoke$1('FileSystem.rename', oldUrl.toString(), newUrl.toString());
     return {
-      newUri,
+      newUri: newUrl.toString(),
       ok: true,
-      oldUri
+      oldUri: oldUrl.toString()
     };
   } catch (error) {
     return {
       ...getToolErrorPayload(error),
-      newUri,
-      oldUri
+      newUri: newUrl.toString(),
+      oldUri: oldUrl.toString()
     };
   }
 };
@@ -1731,13 +2205,17 @@ const executeRunInTerminalTool = async (args, _options) => {
       error: 'Invalid argument: options must include shell (string) and command (string).'
     };
   }
-  return {
-    output: {
-      exitCode: 0,
-      stderr: '',
-      stdout: `Mock output for "${runInTerminalOptions.command}" using shell "${runInTerminalOptions.shell}"`
-    }
-  };
+  try {
+    const workspaceUri = await getWorkspacePath();
+    const result = await invoke('Terminal.executeShellCommand', {
+      args: ['-c', runInTerminalOptions.command],
+      cwd: workspaceUri,
+      toSpawn: runInTerminalOptions.shell
+    });
+    return result;
+  } catch (error) {
+    return getToolErrorPayload(error);
+  }
 };
 
 const getSearchOptions = args => {
@@ -1793,6 +2271,21 @@ const executeSearchTextTool = async (args, _options) => {
   };
 };
 
+const placeholderResponse = 'Hello From Sub agent - not yet implemented';
+const executeSpawnSubagentTool = async (args, _options) => {
+  const prompt = typeof args.prompt === 'string' ? args.prompt : '';
+  if (!prompt) {
+    return {
+      error: 'Missing required argument: prompt'
+    };
+  }
+  return {
+    ok: true,
+    prompt,
+    response: placeholderResponse
+  };
+};
+
 const todoDbName = 'chat-tool-worker';
 const todoStoreName = 'state';
 const todoKey = 'todoList';
@@ -1883,6 +2376,49 @@ const executeUpdateTodoTool = async (args, _options) => {
   }
 };
 
+const carriageReturnNewLineRegex = /\r\n/g;
+const toLines = content => {
+  if (content === '') {
+    return [];
+  }
+  const normalizedContent = content.replaceAll(carriageReturnNewLineRegex, '\n');
+  const lines = normalizedContent.split('\n');
+  if (lines.at(-1) === '') {
+    lines.pop();
+  }
+  return lines;
+};
+const getLongestCommonSubsequenceLength = (beforeLines, afterLines) => {
+  if (beforeLines.length === 0 || afterLines.length === 0) {
+    return 0;
+  }
+  const outerLines = beforeLines.length >= afterLines.length ? beforeLines : afterLines;
+  const innerLines = beforeLines.length >= afterLines.length ? afterLines : beforeLines;
+  let previousRow = new Uint32Array(innerLines.length + 1);
+  for (let i = 1; i <= outerLines.length; i++) {
+    const currentRow = new Uint32Array(innerLines.length + 1);
+    const outerLine = outerLines[i - 1];
+    for (let j = 1; j <= innerLines.length; j++) {
+      if (outerLine === innerLines[j - 1]) {
+        currentRow[j] = previousRow[j - 1] + 1;
+      } else {
+        currentRow[j] = Math.max(previousRow[j], currentRow[j - 1]);
+      }
+    }
+    previousRow = currentRow;
+  }
+  return previousRow[innerLines.length];
+};
+const getLineDiffStats = (beforeContent, afterContent) => {
+  const beforeLines = toLines(beforeContent);
+  const afterLines = toLines(afterContent);
+  const longestCommonSubsequenceLength = getLongestCommonSubsequenceLength(beforeLines, afterLines);
+  return {
+    addedLines: afterLines.length - longestCommonSubsequenceLength,
+    removedLines: beforeLines.length - longestCommonSubsequenceLength
+  };
+};
+
 const executeWriteFileTool = async (args, _options) => {
   const uri = typeof args.uri === 'string' ? args.uri : '';
   const content = typeof args.content === 'string' ? args.content : '';
@@ -1899,9 +2435,17 @@ const executeWriteFileTool = async (args, _options) => {
     };
   }
   try {
-    await writeFile(uri, content);
+    const exists$1 = await exists(uri);
+    const previousContent = exists$1 ? await readFile$1(uri) : '';
+    const {
+      addedLines,
+      removedLines
+    } = getLineDiffStats(previousContent, content);
+    await writeFile$1(uri, content);
     return {
+      addedLines,
       ok: true,
+      removedLines,
       uri
     };
   } catch (error) {
@@ -1960,6 +2504,8 @@ const executeChatTool = async (name, rawArguments, options) => {
       return executeRunInTerminalTool(args);
     case 'search_text':
       return executeSearchTextTool(args);
+    case 'spawn_subagent':
+      return executeSpawnSubagentTool(args);
     case 'update_todo':
       return executeUpdateTodoTool(args);
     case 'write_file':
@@ -2058,17 +2604,21 @@ const getGetWorkspaceUriTool = () => {
 const getGlobTool = () => {
   return {
     function: {
-      description: 'Find files by glob pattern and return matching relative paths.',
+      description: 'Find files by glob pattern under a specific workspace folder URI and return matching relative paths. If you do not already have a real workspace URI, call getWorkspaceUri first and then pass that returned workspaceUri as baseUri.',
       name: 'glob',
       parameters: {
         additionalProperties: false,
         properties: {
+          baseUri: {
+            description: 'Absolute folder URI for the workspace root or subfolder where the glob search should start. If unknown, call getWorkspaceUri first and pass the returned workspaceUri value.',
+            type: 'string'
+          },
           pattern: {
             description: 'Glob pattern to match files, for example `packages/e2e/src/*.ts`.',
             type: 'string'
           }
         },
-        required: ['pattern'],
+        required: ['baseUri', 'pattern'],
         type: 'object'
       }
     },
@@ -2100,6 +2650,11 @@ const getGrepSearchTool = () => {
             description: "The maximum number of results to return. Do not use this unless necessary, it can slow things down. By default, only some matches are returned. If you use this and don't see what you're looking for, you can try again with a more specific query or a larger maxResults.",
             type: 'number'
           },
+          outputFormat: {
+            description: 'Optional structured output format. Use "xml" for match tags or "json" for machine-readable JSON. When omitted, grep_search returns plain text lines.',
+            enum: ['xml', 'json'],
+            type: 'string'
+          },
           query: {
             description: "The pattern to search for in files in the workspace. Use regex with alternation (e.g., 'word1|word2|word3') or character classes to find multiple potential words in a single search. Be sure to set the isRegexp property properly to declare whether it's a regex or plain text pattern. Is case-insensitive.",
             type: 'string'
@@ -2357,6 +2912,27 @@ const getSearchTextTool = () => {
   };
 };
 
+const getSpawnSubagentTool = () => {
+  return {
+    function: {
+      description: 'Spawn a subagent for a focused subtask. For now this tool is a stub and returns a fixed placeholder response while the integration is being built.',
+      name: 'spawn_subagent',
+      parameters: {
+        additionalProperties: false,
+        properties: {
+          prompt: {
+            description: 'Short task prompt to send to the subagent.',
+            type: 'string'
+          }
+        },
+        required: ['prompt'],
+        type: 'object'
+      }
+    },
+    type: 'function'
+  };
+};
+
 const getUpdateTodoTool = () => {
   return {
     function: {
@@ -2404,7 +2980,7 @@ const getWriteFileTool = () => {
 };
 
 const getBasicChatTools = () => {
-  return [getReadFileTool(), getWriteFileTool(), getRenameTool(), getEditFileTool(), getListFilesTool(), getGetWorkspaceUriTool(), getRenderHtmlTool(), getOpenPreviewTool(), getOpenEditorTool(), getClosePreviewTool(), getSearchTextTool(), getRgTool(), getGrepSearchTool(), getRunInTerminalTool(), getCreateDirectoryTool(), getGlobTool(), getUpdateTodoTool()];
+  return [getReadFileTool(), getWriteFileTool(), getRenameTool(), getEditFileTool(), getListFilesTool(), getGetWorkspaceUriTool(), getRenderHtmlTool(), getOpenPreviewTool(), getOpenEditorTool(), getClosePreviewTool(), getSearchTextTool(), getRgTool(), getGrepSearchTool(), getRunInTerminalTool(), getSpawnSubagentTool(), getCreateDirectoryTool(), getGlobTool(), getUpdateTodoTool()];
 };
 
 const handleMessagePort = async port => {
@@ -2414,9 +2990,41 @@ const handleMessagePort = async port => {
   });
 };
 
+const send$2 = async port => {
+  await sendMessagePortToTerminalProcess(port, 0);
+};
+const initializeTerminalProcessElectron = async () => {
+  const rpc = await create$5({
+    commandMap: commandMap,
+    send: send$2
+  });
+  set(rpc);
+};
+const initializeTerminalProcessRemote = async () => {
+  const rpc = await create$3({
+    commandMap: commandMap,
+    type: 'terminal-process'
+  });
+  set(rpc);
+};
+const initializeTerminalProcess = async platform => {
+  if (platform === Electron) {
+    return initializeTerminalProcessElectron();
+  }
+  if (platform === Remote) {
+    return initializeTerminalProcessRemote();
+  }
+};
+
+const initialize = async platform => {
+  // TODO
+  await initializeTerminalProcess(platform);
+};
+
 const commandMap = {
   'ChatTool.execute': executeChatTool,
   'ChatTool.getTools': getBasicChatTools,
+  'ChatTool.initialize': initialize,
   'HandleMessagePort.handleMessagePort': handleMessagePort
 };
 
@@ -2424,29 +3032,29 @@ const send$1 = async port => {
   await sendMessagePortToChatStorageWorker(port);
 };
 const initializeChatStorageWorker = async () => {
-  const rpc = await create$3({
+  const rpc = await create$5({
     commandMap: commandMap,
     send: send$1
   });
-  set$2(rpc);
+  set$3(rpc);
 };
 
 const send = async port => {
   await sendMessagePortToFileSystemWorker(port, 0);
 };
 const initializeFileSystemWorker = async () => {
-  const rpc = await create$3({
+  const rpc = await create$5({
     commandMap: commandMap,
     send: send
   });
-  set$1(rpc);
+  set$2(rpc);
 };
 
 const initializeRendererWorker = async () => {
   const rpc = await create$1({
     commandMap: commandMap
   });
-  set(rpc);
+  set$1(rpc);
 };
 
 const listen = async () => {