@frontman-ai/astro 0.4.1 → 0.5.0

package/dist/index.js

@@ -1,6 +1,6 @@
-import * as Fs from 'fs';
+import * as Fs7 from 'fs';
 import { existsSync, readFileSync } from 'fs';
-import * as Nodepath from 'path';
+import * as Nodepath5 from 'path';
 import { dirname, join } from 'path';
 import * as Nodebuffer from 'buffer';
 import * as Nodechild_process from 'child_process';
@@ -25,8 +25,6 @@ var require_lib = __commonJS({
     module.exports.rgPath = path.join(__dirname, `../bin/rg${process.platform === "win32" ? ".exe" : ""}`);
   }
 });
-
-// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_JsError.js
 function panic(msg) {
   throw new Error(`Panic! ` + msg);
 }
@@ -72,7 +70,7 @@ function forEach(opt, f) {
     return f(valFromOption(opt));
   }
 }
-function getOrThrow(x, message3) {
+function getOrThrow(x, message4) {
   if (x !== void 0) {
     return valFromOption(x);
   } else {
@@ -124,6 +122,7 @@ var clientCss = "https://app.frontman.sh/frontman.css";
 var devClientJs = "http://localhost:5173/src/Main.res.mjs";
 
 // src/FrontmanAstro__Config.res.mjs
+var packageVersion = "0.5.0" ;
 var host = process.env["FRONTMAN_HOST"];
 var defaultHost = host !== void 0 ? host : apiHost;
 var ensureConfig = (function(c2) {
@@ -138,7 +137,7 @@ function makeFromObject(rawConfig) {
   let raw = getOr(config.basePath, "frontman").replace(/^\/+|\/+$/g, "");
   let basePath = raw === "" ? "frontman" : raw;
   let serverName = getOr(config.serverName, "frontman-astro");
-  let serverVersion = getOr(config.serverVersion, "1.0.0");
+  let serverVersion = getOr(config.serverVersion, packageVersion);
   let isLightTheme = getOr(config.isLightTheme, false);
   let baseUrl = getOr(config.clientUrl, getOr(process.env["FRONTMAN_CLIENT_URL"], isDev ? devClientJs : clientJs));
   let url2 = new URL(baseUrl);
@@ -462,22 +461,22 @@ function create(str) {
 // ../../node_modules/sury/src/Sury.res.mjs
 var immutableEmpty = {};
 var immutableEmpty$1 = [];
-function capitalize(string3) {
-  return string3.slice(0, 1).toUpperCase() + string3.slice(1);
+function capitalize(string4) {
+  return string4.slice(0, 1).toUpperCase() + string4.slice(1);
 }
 var copy = ((d2) => ({ ...d2 }));
-function fromString(string3) {
+function fromString(string4) {
   let _idx = 0;
   while (true) {
     let idx = _idx;
-    let match = string3[idx];
+    let match = string4[idx];
     if (match === void 0) {
-      return `"` + string3 + `"`;
+      return `"` + string4 + `"`;
     }
     switch (match) {
       case '"':
       case "\n":
-        return JSON.stringify(string3);
+        return JSON.stringify(string4);
       default:
         _idx = idx + 1 | 0;
         continue;
@@ -545,14 +544,14 @@ function stringify(unknown2) {
     return "null";
   }
   if (Array.isArray(unknown2)) {
-    let string3 = "[";
+    let string4 = "[";
     for (let i = 0, i_finish = unknown2.length; i < i_finish; ++i) {
       if (i !== 0) {
-        string3 = string3 + ", ";
+        string4 = string4 + ", ";
       }
-      string3 = string3 + stringify(unknown2[i]);
+      string4 = string4 + stringify(unknown2[i]);
     }
-    return string3 + "]";
+    return string4 + "]";
   }
   if (unknown2.constructor !== Object) {
     return Object.prototype.toString.call(unknown2);
@@ -569,9 +568,9 @@ function stringify(unknown2) {
 function toExpression(schema3) {
   let tag = schema3.type;
   let $$const = schema3.const;
-  let name14 = schema3.name;
-  if (name14 !== void 0) {
-    return name14;
+  let name15 = schema3.name;
+  if (name15 !== void 0) {
+    return name15;
   }
   if ($$const !== void 0) {
     return stringify($$const);
@@ -732,8 +731,8 @@ var shakenTraps = {
       return target[prop];
     }
     let l$1 = valFromOption(l);
-    let message3 = `Schema S.` + l$1 + ` is not enabled. To start using it, add S.enable` + capitalize(l$1) + `() at the project root.`;
-    throw new Error(`[Sury] ` + message3);
+    let message4 = `Schema S.` + l$1 + ` is not enabled. To start using it, add S.enable` + capitalize(l$1) + `() at the project root.`;
+    throw new Error(`[Sury] ` + message4);
   }
 };
 function shaken(apiName) {
@@ -1691,10 +1690,10 @@ function isPriority(tagFlag, byKey) {
   }
 }
 function isWiderUnionSchema(schemaAnyOf, inputAnyOf) {
-  return inputAnyOf.every((inputSchema13, idx) => {
+  return inputAnyOf.every((inputSchema14, idx) => {
     let schema3 = schemaAnyOf[idx];
-    if (schema3 !== void 0 && !(flags[inputSchema13.type] & 9152) && inputSchema13.type === schema3.type) {
-      return inputSchema13.const === schema3.const;
+    if (schema3 !== void 0 && !(flags[inputSchema14.type] & 9152) && inputSchema14.type === schema3.type) {
+      return inputSchema14.const === schema3.const;
     } else {
       return false;
     }
@@ -2740,8 +2739,8 @@ function argsToString(args) {
 function stripAnsi(str) {
   return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
 }
-function addLog(state, level, message3, attributes, consoleMethod) {
-  let cleanMessage = stripAnsi(message3).trim();
+function addLog(state, level, message4, attributes, consoleMethod) {
+  let cleanMessage = stripAnsi(message4).trim();
   if (cleanMessage === "") {
     return;
   }
@@ -2818,11 +2817,11 @@ var interceptConsole = (function(state) {
     originalDebug(...args);
   };
 });
-function handleStdoutWrite(state, message3) {
+function handleStdoutWrite(state, message4) {
   try {
-    let matchesPattern2 = state.config.stdoutPatterns.some((pattern2) => message3.includes(pattern2));
+    let matchesPattern2 = state.config.stdoutPatterns.some((pattern2) => message4.includes(pattern2));
     if (matchesPattern2) {
-      return addLog(state, "build", message3, void 0, void 0);
+      return addLog(state, "build", message4, void 0, void 0);
     } else {
       return;
     }
@@ -2834,8 +2833,8 @@ function interceptStdout(_state) {
   (function(_state2) {
     const originalWrite = process.stdout.write.bind(process.stdout);
     process.stdout.write = (chunk, ...args) => {
-      const message3 = typeof chunk === "string" ? chunk : chunk.toString();
-      handleStdoutWrite(_state2, message3);
+      const message4 = typeof chunk === "string" ? chunk : chunk.toString();
+      handleStdoutWrite(_state2, message4);
       return originalWrite(chunk, ...args);
     };
   })(_state);
@@ -2990,12 +2989,65 @@ Parameters:
 
 Returns logs in chronological order (oldest first within buffer).`;
 
-// ../frontman-core/src/FrontmanCore__FileTracker.res.mjs
+// ../frontman-core/src/FrontmanCore__ExnUtils.res.mjs
+function message3(exn) {
+  return getOr(flatMap(fromException(exn), message2), "Unknown error");
+}
 var readFiles = {
-  contents: /* @__PURE__ */ new Set()
+  contents: /* @__PURE__ */ new Map()
 };
-function recordRead(resolvedPath) {
-  readFiles.contents.add(resolvedPath);
+function mergeRanges(ranges) {
+  let match = ranges.length;
+  if (match === 0) {
+    return [];
+  }
+  let sorted = ranges.toSorted((a, b) => a.start - b.start | 0);
+  let first = sorted[0];
+  let merged = [{
+    start: first.start,
+    end_: first.end_
+  }];
+  for (let i = 1, i_finish = sorted.length; i < i_finish; ++i) {
+    let current = sorted[i];
+    let last = merged[merged.length - 1 | 0];
+    if (current.start <= last.end_) {
+      last.end_ = max(last.end_, current.end_);
+    } else {
+      merged.push({
+        start: current.start,
+        end_: current.end_
+      });
+    }
+  }
+  return merged;
+}
+function recordRead(resolvedPath, offset, limit, totalLines) {
+  let now = Date.now();
+  let newRange = {
+    start: offset,
+    end_: min(offset + limit | 0, totalLines)
+  };
+  let record = readFiles.contents.get(resolvedPath);
+  if (record !== void 0) {
+    record.readAt = now;
+    record.totalLines = totalLines;
+    record.ranges = mergeRanges(record.ranges.concat([newRange]));
+  } else {
+    readFiles.contents.set(resolvedPath, {
+      readAt: now,
+      ranges: [newRange],
+      totalLines
+    });
+  }
+}
+function isLineCovered(ranges, line) {
+  return ranges.some((r) => {
+    if (line >= r.start) {
+      return line < r.end_;
+    } else {
+      return false;
+    }
+  });
 }
 function assertReadBefore(resolvedPath) {
   if (readFiles.contents.has(resolvedPath)) {
@@ -3010,6 +3062,90 @@ function assertReadBefore(resolvedPath) {
     };
   }
 }
+async function assertNotStale(resolvedPath) {
+  let record = readFiles.contents.get(resolvedPath);
+  if (record === void 0) {
+    return {
+      TAG: "Ok",
+      _0: void 0
+    };
+  }
+  try {
+    let stats = await Fs7.promises.stat(resolvedPath);
+    let mtimeMs = stats.mtimeMs;
+    if (mtimeMs > record.readAt + 100) {
+      return {
+        TAG: "Error",
+        _0: `File "` + resolvedPath + `" has been modified since it was last read. Please read the file again before editing.`
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: void 0
+      };
+    }
+  } catch (exn) {
+    return {
+      TAG: "Ok",
+      _0: void 0
+    };
+  }
+}
+function checkCoverage(resolvedPath, content, oldText) {
+  let record = readFiles.contents.get(resolvedPath);
+  if (record === void 0) {
+    return;
+  }
+  let ranges = record.ranges;
+  if (ranges.length === 1) {
+    let match = ranges[0];
+    if (match.start === 0) {
+      let end_ = match.end_;
+      if (end_ >= record.totalLines) {
+        return;
+      }
+    }
+  }
+  let lines = content.split("\n");
+  let oldLines = oldText.trim().split("\n");
+  let firstOldLine = getOr(oldLines[0], "").trim();
+  let targetLine = {
+    contents: void 0
+  };
+  lines.forEach((line2, idx) => {
+    let match = targetLine.contents;
+    if (match !== void 0 || line2.trim() !== firstOldLine) {
+      return;
+    } else {
+      targetLine.contents = idx;
+      return;
+    }
+  });
+  let line = targetLine.contents;
+  if (line === void 0) {
+    return;
+  }
+  if (isLineCovered(ranges, line)) {
+    return;
+  }
+  let rangeStr = ranges.map((r) => r.start.toString() + `-` + r.end_.toString()).join(", ");
+  return `Warning: You are editing around line ` + line.toString() + ` but only read lines [` + rangeStr + `] of this ` + record.totalLines.toString() + `-line file. Consider reading the target section first with read_file and an appropriate offset.`;
+}
+async function assertEditSafe(resolvedPath) {
+  let e = assertReadBefore(resolvedPath);
+  if (e.TAG === "Ok") {
+    return await assertNotStale(resolvedPath);
+  } else {
+    return e;
+  }
+}
+function recordWrite(resolvedPath) {
+  let record = readFiles.contents.get(resolvedPath);
+  if (record !== void 0) {
+    record.readAt = Date.now();
+    return;
+  }
+}
 function endsWithSep(path) {
   if (path.endsWith("/")) {
     return true;
@@ -3018,10 +3154,10 @@ function endsWithSep(path) {
   }
 }
 function resolve(sourceRoot, inputPath) {
-  let normalizedRoot = Nodepath.normalize(sourceRoot);
-  let rootWithSep = endsWithSep(normalizedRoot) ? normalizedRoot : normalizedRoot + Nodepath.sep;
-  if (Nodepath.isAbsolute(inputPath)) {
-    let normalizedPath = Nodepath.normalize(inputPath);
+  let normalizedRoot = Nodepath5.normalize(sourceRoot);
+  let rootWithSep = endsWithSep(normalizedRoot) ? normalizedRoot : normalizedRoot + Nodepath5.sep;
+  if (Nodepath5.isAbsolute(inputPath)) {
+    let normalizedPath = Nodepath5.normalize(inputPath);
     if (normalizedPath === normalizedRoot || normalizedPath.startsWith(rootWithSep)) {
       return {
         TAG: "Ok",
@@ -3036,7 +3172,7 @@ function resolve(sourceRoot, inputPath) {
       };
     }
   }
-  let fullPath = Nodepath.normalize(Nodepath.join(sourceRoot, inputPath));
+  let fullPath = Nodepath5.normalize(Nodepath5.join(sourceRoot, inputPath));
   if (fullPath === normalizedRoot || fullPath.startsWith(rootWithSep)) {
     return {
       TAG: "Ok",
@@ -3055,7 +3191,7 @@ function toString(safePath) {
   return safePath.path;
 }
 function dirname2(safePath) {
-  return Nodepath.dirname(safePath.path);
+  return Nodepath5.dirname(safePath.path);
 }
 
 // ../frontman-core/src/FrontmanCore__PathContext.res.mjs
@@ -3067,7 +3203,7 @@ function endsWithSep2(path) {
   }
 }
 function toRelativePath(sourceRoot, absolutePath) {
-  let normalizedRoot = endsWithSep2(sourceRoot) ? sourceRoot : sourceRoot + Nodepath.sep;
+  let normalizedRoot = endsWithSep2(sourceRoot) ? sourceRoot : sourceRoot + Nodepath5.sep;
   if (absolutePath.startsWith(normalizedRoot)) {
     return absolutePath.slice(normalizedRoot.length, absolutePath.length);
   } else if (absolutePath.startsWith(sourceRoot)) {
@@ -3080,17 +3216,30 @@ function resolveSearchPath(sourceRoot, inputPath) {
   if (inputPath === void 0) {
     return sourceRoot;
   }
-  if (!Nodepath.isAbsolute(inputPath)) {
-    return Nodepath.join(sourceRoot, inputPath);
+  if (!Nodepath5.isAbsolute(inputPath)) {
+    return Nodepath5.join(sourceRoot, inputPath);
   }
-  let normalizedPath = Nodepath.normalize(inputPath);
-  let normalizedRoot = Nodepath.normalize(sourceRoot);
+  let normalizedPath = Nodepath5.normalize(inputPath);
+  let normalizedRoot = Nodepath5.normalize(sourceRoot);
   if (normalizedPath.startsWith(normalizedRoot)) {
     return normalizedPath;
   } else {
     return sourceRoot;
   }
 }
+async function resolveSearchDir(sourceRoot, inputPath) {
+  let resolved = resolveSearchPath(sourceRoot, inputPath);
+  try {
+    let stats = await Fs7.promises.stat(resolved);
+    if (stats.isFile()) {
+      return Nodepath5.dirname(resolved);
+    } else {
+      return resolved;
+    }
+  } catch (exn) {
+    return resolved;
+  }
+}
 function detectPathConfusion(sourceRoot, requestedPath) {
   let normalizedPath = requestedPath.replaceAll("\\", "/").replace(/^\.\//, "").replace(/^\//, "");
   let firstSegment = getOr(normalizedPath.split("/")[0], "");
@@ -3099,7 +3248,7 @@ function detectPathConfusion(sourceRoot, requestedPath) {
     return `Path '` + requestedPath + `' not found. The sourceRoot is '` + sourceRoot + `' which already includes '` + firstSegment + `/'. Try using '.' or a path relative to sourceRoot instead.`;
   }
 }
-function dirname3(result) {
+function dirname4(result) {
   return dirname2(result.safePath);
 }
 function resolve2(sourceRoot, inputPath) {
@@ -3617,8 +3766,74 @@ var outputSchema2 = schema2((s2) => ({
   message: s2.m(string2),
   _context: s2.m(option2(pathContextSchema))
 }));
+function toPathCtx(r) {
+  return {
+    sourceRoot: r.sourceRoot,
+    resolvedPath: r.resolvedPath,
+    relativePath: r.relativePath
+  };
+}
+async function createFile(resolved, content, displayPath) {
+  try {
+    await Fs7.promises.mkdir(dirname4(resolved), {
+      recursive: true
+    });
+    await Fs7.promises.writeFile(resolved.resolvedPath, content, "utf8");
+    recordWrite(resolved.resolvedPath);
+    return {
+      TAG: "Ok",
+      _0: {
+        message: "File created successfully.",
+        _context: toPathCtx(resolved)
+      }
+    };
+  } catch (raw_exn) {
+    let exn = internalToException(raw_exn);
+    return {
+      TAG: "Error",
+      _0: `Failed to create file ` + displayPath + `: ` + message3(exn)
+    };
+  }
+}
+async function findAndReplace(resolved, oldText, newText, replaceAll, displayPath) {
+  try {
+    let content = await Fs7.promises.readFile(resolved.resolvedPath, "utf8");
+    let coverageWarning = checkCoverage(resolved.resolvedPath, content, oldText);
+    let newContent = applyEdit(content, oldText, newText, replaceAll);
+    if (typeof newContent !== "object") {
+      if (newContent === "NotFound") {
+        return {
+          TAG: "Error",
+          _0: `oldText not found in file ` + displayPath + `. Make sure the text matches exactly, or read the file again to see its current content.`
+        };
+      } else {
+        return {
+          TAG: "Error",
+          _0: `Found multiple matches for oldText in ` + displayPath + `. Provide more surrounding context to identify the correct match, or use replaceAll to replace all occurrences.`
+        };
+      }
+    }
+    await Fs7.promises.writeFile(resolved.resolvedPath, newContent._0, "utf8");
+    recordWrite(resolved.resolvedPath);
+    let message4 = coverageWarning !== void 0 ? `Edit applied successfully.
+
+` + coverageWarning : "Edit applied successfully.";
+    return {
+      TAG: "Ok",
+      _0: {
+        message: message4,
+        _context: toPathCtx(resolved)
+      }
+    };
+  } catch (raw_exn) {
+    let exn = internalToException(raw_exn);
+    return {
+      TAG: "Error",
+      _0: `Failed to edit file ` + displayPath + `: ` + message3(exn)
+    };
+  }
+}
 async function execute2(ctx2, input) {
-  let replaceAll = getOr(input.replaceAll, false);
   if (input.oldText === input.newText) {
     return {
       TAG: "Error",
@@ -3632,77 +3847,19 @@ async function execute2(ctx2, input) {
       _0: formatError(err._0)
     };
   }
-  let result = err._0;
-  let pathCtx_sourceRoot = result.sourceRoot;
-  let pathCtx_resolvedPath = result.resolvedPath;
-  let pathCtx_relativePath = result.relativePath;
-  let pathCtx = {
-    sourceRoot: pathCtx_sourceRoot,
-    resolvedPath: pathCtx_resolvedPath,
-    relativePath: pathCtx_relativePath
-  };
-  if (input.oldText === "") {
-    try {
-      let dirPath = dirname3(result);
-      await Fs.promises.mkdir(dirPath, {
-        recursive: true
-      });
-      await Fs.promises.writeFile(result.resolvedPath, input.newText, "utf8");
-      return {
-        TAG: "Ok",
-        _0: {
-          message: "File created successfully.",
-          _context: pathCtx
-        }
-      };
-    } catch (raw_exn) {
-      let exn = internalToException(raw_exn);
-      let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
-      return {
-        TAG: "Error",
-        _0: `Failed to create file ` + input.path + `: ` + msg
-      };
-    }
+  let resolved = err._0;
+  let oldText = input.oldText;
+  if (oldText === "") {
+    return await createFile(resolved, input.newText, input.path);
+  }
+  let msg = await assertEditSafe(resolved.resolvedPath);
+  if (msg.TAG === "Ok") {
+    return await findAndReplace(resolved, oldText, input.newText, getOr(input.replaceAll, false), input.path);
   } else {
-    let msg$1 = assertReadBefore(result.resolvedPath);
-    if (msg$1.TAG !== "Ok") {
-      return {
-        TAG: "Error",
-        _0: msg$1._0
-      };
-    }
-    try {
-      let content = await Fs.promises.readFile(result.resolvedPath, "utf8");
-      let newContent = applyEdit(content, input.oldText, input.newText, replaceAll);
-      if (typeof newContent !== "object") {
-        if (newContent === "NotFound") {
-          return {
-            TAG: "Error",
-            _0: `oldText not found in file ` + input.path + `. Make sure the text matches exactly, or read the file again to see its current content.`
-          };
-        } else {
-          return {
-            TAG: "Error",
-            _0: `Found multiple matches for oldText in ` + input.path + `. Provide more surrounding context to identify the correct match, or use replaceAll to replace all occurrences.`
-          };
-        }
-      }
-      await Fs.promises.writeFile(result.resolvedPath, newContent._0, "utf8");
-      return {
-        TAG: "Ok",
-        _0: {
-          message: "Edit applied successfully.",
-          _context: pathCtx
-        }
-      };
-    } catch (raw_exn$1) {
-      let exn$1 = internalToException(raw_exn$1);
-      let msg$2 = getOr(flatMap(fromException(exn$1), message2), "Unknown error");
-      return {
-        TAG: "Error",
-        _0: `Failed to edit file ` + input.path + `: ` + msg$2
-      };
-    }
+    return {
+      TAG: "Error",
+      _0: msg._0
+    };
   }
 }
 var name3 = "edit_file";
@@ -3828,12 +3985,12 @@ function getMostSignificantDynamicType(segments) {
   });
 }
 async function findPages(baseDir, currentPath, projectRoot, sourceRoot) {
-  let fullPath = Nodepath.join(projectRoot, baseDir, currentPath);
+  let fullPath = Nodepath5.join(projectRoot, baseDir, currentPath);
   try {
-    let entries = await Fs.promises.readdir(fullPath);
+    let entries = await Fs7.promises.readdir(fullPath);
     return (await Promise.all(entries.map(async (entry) => {
-      let entryPath = Nodepath.join(fullPath, entry);
-      let stats = await Fs.promises.lstat(entryPath);
+      let entryPath = Nodepath5.join(fullPath, entry);
+      let stats = await Fs7.promises.lstat(entryPath);
       if (stats.isSymbolicLink()) {
         return [];
       }
@@ -3841,13 +3998,13 @@ async function findPages(baseDir, currentPath, projectRoot, sourceRoot) {
         if (entry.startsWith("_") || entry === "api" || entry === "components") {
           return [];
         } else {
-          return await findPages(baseDir, Nodepath.join(currentPath, entry), projectRoot, sourceRoot);
+          return await findPages(baseDir, Nodepath5.join(currentPath, entry), projectRoot, sourceRoot);
         }
       }
       if (!(entry.endsWith(".astro") || entry.endsWith(".md") || entry.endsWith(".mdx") || entry.endsWith(".html"))) {
         return [];
       }
-      let filePath = Nodepath.join(currentPath, entry);
+      let filePath = Nodepath5.join(currentPath, entry);
       let routePath = fileToRoute(filePath);
       let filePathNoExt = filePath.replace(/\.(astro|md|mdx|html)$/, "");
       let segments = filePathNoExt.replaceAll("\\", "/").split("/");
@@ -3906,10 +4063,10 @@ function fromString2(x, radix) {
   }
 }
 function execPromise(command, options) {
+  let maxBuffer = getOr(options.maxBuffer, 52428800);
   return new Promise((resolve3, _reject) => {
     let cwd = options.cwd;
     let env = options.env;
-    let maxBuffer = getOr(options.maxBuffer, 52428800);
     Nodechild_process.exec(command, {
       cwd,
       env,
@@ -3943,108 +4100,123 @@ function spawnPromise(command, args, options) {
   return new Promise((resolve3, _reject) => {
     let cwd = options.cwd;
     let env = options.env;
-    let proc = Nodechild_process.spawn(command, args, {
-      cwd,
-      env
-    });
-    let stdoutChunks = {
-      contents: []
-    };
-    let stderrChunks = {
-      contents: []
-    };
-    let stdoutLen = {
-      contents: 0
-    };
-    let stderrLen = {
-      contents: 0
-    };
-    let resolved = {
-      contents: false
-    };
-    let guardedResolve = (value) => {
-      if (resolved.contents) {
-        return;
-      } else {
-        resolved.contents = true;
-        return resolve3(value);
-      }
-    };
-    proc.stdout.on("data", (chunk) => {
-      if (resolved.contents) {
-        return;
-      } else {
-        stdoutChunks.contents.push(chunk);
-        stdoutLen.contents = stdoutLen.contents + chunk.byteLength | 0;
-        if (stdoutLen.contents > maxBuffer) {
-          proc.kill("SIGTERM");
-          return guardedResolve({
-            TAG: "Error",
-            _0: {
-              code: void 0,
-              stdout: Nodebuffer.Buffer.concat(stdoutChunks.contents).toString("utf8"),
-              stderr: Nodebuffer.Buffer.concat(stderrChunks.contents).toString("utf8"),
-              message: "stdout maxBuffer exceeded"
-            }
-          });
+    try {
+      let proc = Nodechild_process.spawn(command, args, {
+        cwd,
+        env
+      });
+      let stdoutChunks = {
+        contents: []
+      };
+      let stderrChunks = {
+        contents: []
+      };
+      let stdoutLen = {
+        contents: 0
+      };
+      let stderrLen = {
+        contents: 0
+      };
+      let resolved = {
+        contents: false
+      };
+      let guardedResolve = (value) => {
+        if (resolved.contents) {
+          return;
         } else {
+          resolved.contents = true;
+          return resolve3(value);
+        }
+      };
+      proc.stdout.on("data", (chunk) => {
+        if (resolved.contents) {
           return;
+        } else {
+          stdoutChunks.contents.push(chunk);
+          stdoutLen.contents = stdoutLen.contents + chunk.byteLength | 0;
+          if (stdoutLen.contents > maxBuffer) {
+            proc.kill("SIGTERM");
+            return guardedResolve({
+              TAG: "Error",
+              _0: {
+                code: void 0,
+                stdout: Nodebuffer.Buffer.concat(stdoutChunks.contents).toString("utf8"),
+                stderr: Nodebuffer.Buffer.concat(stderrChunks.contents).toString("utf8"),
+                message: "stdout maxBuffer exceeded"
+              }
+            });
+          } else {
+            return;
+          }
         }
-      }
-    });
-    proc.stderr.on("data", (chunk) => {
-      if (resolved.contents) {
-        return;
-      } else {
-        stderrChunks.contents.push(chunk);
-        stderrLen.contents = stderrLen.contents + chunk.byteLength | 0;
-        if (stderrLen.contents > maxBuffer) {
-          proc.kill("SIGTERM");
+      });
+      proc.stderr.on("data", (chunk) => {
+        if (resolved.contents) {
+          return;
+        } else {
+          stderrChunks.contents.push(chunk);
+          stderrLen.contents = stderrLen.contents + chunk.byteLength | 0;
+          if (stderrLen.contents > maxBuffer) {
+            proc.kill("SIGTERM");
+            return guardedResolve({
+              TAG: "Error",
+              _0: {
+                code: void 0,
+                stdout: Nodebuffer.Buffer.concat(stdoutChunks.contents).toString("utf8"),
+                stderr: Nodebuffer.Buffer.concat(stderrChunks.contents).toString("utf8"),
+                message: "stderr maxBuffer exceeded"
+              }
+            });
+          } else {
+            return;
+          }
+        }
+      });
+      proc.on("error", (err) => guardedResolve({
+        TAG: "Error",
+        _0: {
+          code: void 0,
+          stdout: Nodebuffer.Buffer.concat(stdoutChunks.contents).toString("utf8"),
+          stderr: Nodebuffer.Buffer.concat(stderrChunks.contents).toString("utf8"),
+          message: err.message
+        }
+      }));
+      proc.on("close", (nullableCode) => {
+        let code = nullableCode == null ? void 0 : some(nullableCode);
+        if (!(nullableCode == null) && nullableCode === 0) {
           return guardedResolve({
-            TAG: "Error",
+            TAG: "Ok",
             _0: {
-              code: void 0,
               stdout: Nodebuffer.Buffer.concat(stdoutChunks.contents).toString("utf8"),
-              stderr: Nodebuffer.Buffer.concat(stderrChunks.contents).toString("utf8"),
-              message: "stderr maxBuffer exceeded"
+              stderr: Nodebuffer.Buffer.concat(stderrChunks.contents).toString("utf8")
             }
           });
-        } else {
-          return;
         }
-      }
-    });
-    proc.on("error", (err) => guardedResolve({
-      TAG: "Error",
-      _0: {
-        code: void 0,
-        stdout: Nodebuffer.Buffer.concat(stdoutChunks.contents).toString("utf8"),
-        stderr: Nodebuffer.Buffer.concat(stderrChunks.contents).toString("utf8"),
-        message: err.message
-      }
-    }));
-    proc.on("close", (nullableCode) => {
-      let code = nullableCode == null ? void 0 : some(nullableCode);
-      if (!(nullableCode == null) && nullableCode === 0) {
-        return guardedResolve({
-          TAG: "Ok",
+        let codeStr = nullableCode == null ? "null" : nullableCode.toString();
+        guardedResolve({
+          TAG: "Error",
           _0: {
+            code,
             stdout: Nodebuffer.Buffer.concat(stdoutChunks.contents).toString("utf8"),
-            stderr: Nodebuffer.Buffer.concat(stderrChunks.contents).toString("utf8")
+            stderr: Nodebuffer.Buffer.concat(stderrChunks.contents).toString("utf8"),
+            message: `Process exited with code ` + codeStr
           }
         });
-      }
-      let codeStr = nullableCode == null ? "null" : nullableCode.toString();
-      guardedResolve({
+      });
+      return;
+    } catch (raw_exn) {
+      let exn = internalToException(raw_exn);
+      let msg = getOr(flatMap(fromException(exn), message2), "spawn failed");
+      return resolve3({
         TAG: "Error",
         _0: {
-          code,
-          stdout: Nodebuffer.Buffer.concat(stdoutChunks.contents).toString("utf8"),
-          stderr: Nodebuffer.Buffer.concat(stderrChunks.contents).toString("utf8"),
-          message: `Process exited with code ` + codeStr
+          code: void 0,
+          stdout: "",
+          stderr: "",
+          message: msg
         }
       });
-    });
+    }
   });
 }
 async function execWithOptions(command, options) {
@@ -4070,7 +4242,8 @@ var ToolNames = {
   grep: "grep",
   fileExists: "file_exists",
   loadAgentInstructions: "load_agent_instructions",
-  lighthouse: "lighthouse"};
+  lighthouse: "lighthouse",
+  listTree: "list_tree"};
 
 // ../frontman-core/src/tools/FrontmanCore__Tool__Grep.res.mjs
 var name6 = ToolNames.grep;
@@ -4229,15 +4402,40 @@ async function executeRipgrep(rgPath, pattern2, searchPath, type_, glob, caseIns
 }
 async function executeGitGrep(pattern2, searchPath, caseInsensitive, literal3, maxResults, glob, type_) {
   let args = buildGitGrepArgs(pattern2, caseInsensitive, literal3, maxResults, glob, type_);
-  let result = await spawnResult("git", args, searchPath);
+  let match;
+  try {
+    let stats = await Fs7.promises.stat(searchPath);
+    match = stats.isFile() ? [
+      Nodepath5.dirname(searchPath),
+      Nodepath5.basename(searchPath)
+    ] : [
+      searchPath,
+      void 0
+    ];
+  } catch (exn) {
+    match = [
+      searchPath,
+      void 0
+    ];
+  }
+  let filePathspec = match[1];
+  if (filePathspec !== void 0) {
+    if (args.includes("--")) {
+      args.push(filePathspec);
+    } else {
+      args.push("--");
+      args.push(filePathspec);
+    }
+  }
+  let result = await spawnResult("git", args, match[0]);
   if (result.TAG === "Ok") {
     return {
       TAG: "Ok",
       _0: parseGrepOutput(result._0.stdout, maxResults)
     };
   }
-  let match = result._0;
-  let code = match.code;
+  let match$1 = result._0;
+  let code = match$1.code;
   if (code === 1) {
     return {
       TAG: "Ok",
@@ -4248,9 +4446,9 @@ async function executeGitGrep(pattern2, searchPath, caseInsensitive, literal3, m
       }
     };
   }
-  let stderr = match.stderr;
+  let stderr = match$1.stderr;
   let codeStr = getOr(map(code, (c2) => c2.toString()), "unknown");
-  let detail = stderr === "" ? match.message : stderr;
+  let detail = stderr === "" ? match$1.message : stderr;
   return {
     TAG: "Error",
     _0: `Git grep failed (exit ` + codeStr + `): ` + detail
@@ -4335,56 +4533,465 @@ async function execute5(ctx2, input) {
     return await gitGrepWithFallback();
   }
 }
-var description5 = `Fast content search tool that finds files containing specific text or patterns, returning matching lines sorted by file modification time.
+var description5 = `Searches **file contents** for text or regex patterns. Returns matching lines with file paths and line numbers.
 
-WHEN TO USE THIS TOOL:
-- Use when you need to find files containing specific text or patterns
-- Great for searching code bases for function names, variable declarations, or error messages
-- Useful for finding all files that use a particular API or pattern
+Use grep to find where code is *used* \u2014 function calls, variable references, imports, error messages, string literals. If you need to find a file by *name* instead, use search_files.
 
 PARAMETERS:
-- pattern (required): The text or regex pattern to search for
-- path (optional): Directory to search in (defaults to source root)
-- type (optional): File type filter (e.g., "js", "ts", "py", "go")
-- glob (optional): Glob pattern to filter files (e.g., "*.js", "*.{ts,tsx}")
+- pattern (required): Text or regex to search for inside files
+- path (optional): Directory or file to search in (defaults to source root). When a file path is given, only that file is searched.
+- type (optional): File type filter (e.g., "js", "ts", "py")
+- glob (optional): Glob pattern to filter files (e.g., "*.tsx", "*.{ts,tsx}")
 - case_insensitive (optional): Case insensitive search (default: false)
 - literal (optional): Treat pattern as literal text, not regex (default: false)
 - max_results (optional): Maximum number of results to return (default: 20)
 
 EXAMPLES:
-- Find "function" in JavaScript files: pattern="function", type="js"
-- Find imports: pattern="import.*from", glob="*.ts"
-- Case-insensitive search: pattern="error", case_insensitive=true
-- Literal search: pattern="log.error()", literal=true
+- Find where useState is called: pattern="useState"
+- Find API routes: pattern="app\\.(get|post|put)", glob="*.ts"
+- Search within one file: pattern="className", path="src/components/Button.tsx"
+- Literal dot search: pattern="console.log(", literal=true
 
 OUTPUT:
-Returns matching lines grouped by file, with line numbers and content.
-Results are sorted by file modification time (newest first).
+Matching lines grouped by file, with line numbers. Sorted by file modification time (newest first).
 
 LIMITATIONS:
-- Results limited to max_results (default 20)
-- Binary files are automatically skipped
-- Hidden files (starting with '.') are skipped by default`;
-var name7 = ToolNames.readFile;
-var inputSchema6 = schema2((s2) => ({
-  path: s2.m(string2),
-  offset: s2.m(option2(int2)),
-  limit: s2.m(option2(int2))
-}));
-var pathContextSchema2 = schema2((s2) => ({
-  sourceRoot: s2.m(string2),
-  resolvedPath: s2.m(string2),
-  relativePath: s2.m(string2)
-}));
-var outputSchema6 = schema2((s2) => ({
-  content: s2.m(string2),
-  totalLines: s2.m(int2),
-  hasMore: s2.m(bool2),
-  _context: s2.m(option2(pathContextSchema2))
-}));
-async function execute6(ctx2, input) {
-  let offset = getOr(input.offset, 0);
-  let limit = getOr(input.limit, 500);
+- Results capped at max_results (default 20) files
+- Binary files and hidden files (dotfiles) are skipped`;
+
+// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_JSON.js
+function bool3(json3) {
+  if (typeof json3 === "boolean") {
+    return json3;
+  }
+}
+function $$null2(json3) {
+  if (json3 === null) {
+    return null;
+  }
+}
+function string3(json3) {
+  if (typeof json3 === "string") {
+    return json3;
+  }
+}
+function float3(json3) {
+  if (typeof json3 === "number") {
+    return json3;
+  }
+}
+function object2(json3) {
+  if (typeof json3 === "object" && json3 !== null && !Array.isArray(json3)) {
+    return json3;
+  }
+}
+function array3(json3) {
+  if (Array.isArray(json3)) {
+    return json3;
+  }
+}
+var Decode = {
+  bool: bool3,
+  $$null: $$null2,
+  string: string3,
+  float: float3,
+  object: object2,
+  array: array3
+};
+
+// ../../node_modules/@rescript/runtime/lib/es6/Primitive_string.js
+function compare(s1, s2) {
+  if (s1 === s2) {
+    return 0;
+  } else if (s1 < s2) {
+    return -1;
+  } else {
+    return 1;
+  }
+}
+async function pathExists(path) {
+  try {
+    await Fs7.promises.access(path);
+    return true;
+  } catch (exn) {
+    return false;
+  }
+}
+
+// ../frontman-core/src/tools/FrontmanCore__Tool__ListTree.res.mjs
+var name7 = ToolNames.listTree;
+var inputSchema6 = schema2((s2) => ({
+  path: s2.m(option2(string2)),
+  depth: s2.m(option2(int2))
+}));
+var workspaceSchema = schema2((s2) => ({
+  name: s2.m(string2),
+  path: s2.m(string2)
+}));
+var outputSchema6 = schema2((s2) => ({
+  tree: s2.m(string2),
+  workspaces: s2.m(array2(workspaceSchema)),
+  monorepoType: s2.m(option2(string2))
+}));
+var packageJsonNameSchema = schema2((s2) => ({
+  name: s2.m(option2(string2))
+}));
+var packageJsonWorkspacesObjSchema = schema2((s2) => ({
+  packages: s2.m(option2(array2(string2)))
+}));
+var noiseDirs = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "_build",
+  "deps",
+  ".turbo",
+  ".cache",
+  "coverage",
+  ".svelte-kit",
+  ".output",
+  ".nuxt",
+  ".vercel",
+  "__pycache__",
+  "target"
+];
+function makeTrieNode(name15) {
+  return {
+    name: name15,
+    children: {
+      contents: {}
+    },
+    isFile: {
+      contents: false
+    }
+  };
+}
+function buildTrie(files) {
+  let root_children = {
+    contents: {}
+  };
+  let root_isFile = {
+    contents: false
+  };
+  let root = {
+    name: ".",
+    children: root_children,
+    isFile: root_isFile
+  };
+  files.forEach((filePath) => {
+    let parts = filePath.split("/").filter((p2) => p2 !== "");
+    let current = {
+      contents: root
+    };
+    parts.forEach((part, idx) => {
+      let isLast = idx === (parts.length - 1 | 0);
+      let existing = current.contents.children.contents[part];
+      if (existing !== void 0) {
+        if (isLast) {
+          existing.isFile.contents = true;
+        }
+        current.contents = existing;
+        return;
+      }
+      let node = makeTrieNode(part);
+      if (isLast) {
+        node.isFile.contents = true;
+      }
+      current.contents.children.contents[part] = node;
+      current.contents = node;
+    });
+  });
+  return root;
+}
+function getSortedChildren(node) {
+  let entries = Object.entries(node.children.contents).map((param) => {
+    let child = param[1];
+    let hasChildren = Object.keys(child.children.contents).length !== 0;
+    let isDir = hasChildren || !child.isFile.contents;
+    return {
+      entryName: param[0],
+      node: child,
+      isDir
+    };
+  }).filter((e) => !noiseDirs.includes(e.entryName));
+  return entries.toSorted((a, b) => {
+    let match = a.isDir;
+    let match$1 = b.isDir;
+    if (match) {
+      if (!match$1) {
+        return -1;
+      }
+    } else if (match$1) {
+      return 1;
+    }
+    let n = compare(a.entryName, b.entryName);
+    if (n < 0) {
+      return -1;
+    } else if (n > 0) {
+      return 1;
+    } else {
+      return 0;
+    }
+  });
+}
+function renderTree(root, maxDepth, workspacePaths) {
+  let lines = [];
+  let walk = (node, prefix, currentDepth, parentPath) => {
+    if (currentDepth > maxDepth) {
+      return;
+    }
+    let children = getSortedChildren(node);
+    let totalCount = children.length;
+    let truncated = totalCount > 15;
+    let visibleChildren = truncated ? children.slice(0, 10) : children;
+    let visibleCount = visibleChildren.length;
+    visibleChildren.forEach((entry, idx) => {
+      let isLastVisible = idx === (visibleCount - 1 | 0) && !truncated;
+      let connector = isLastVisible ? `\u2514\u2500\u2500 ` : `\u251C\u2500\u2500 `;
+      let childPrefix = isLastVisible ? prefix + "    " : prefix + `\u2502   `;
+      let suffix = entry.isDir ? "/" : "";
+      let entryRelPath = parentPath !== void 0 ? parentPath + "/" + entry.entryName : entry.entryName;
+      let workspaceAnnotation;
+      if (entry.isDir) {
+        let wsName = workspacePaths[entryRelPath];
+        workspaceAnnotation = wsName !== void 0 ? ` [workspace: ` + wsName + `]` : "";
+      } else {
+        workspaceAnnotation = "";
+      }
+      lines.push(prefix + connector + entry.entryName + suffix + workspaceAnnotation);
+      if (entry.isDir) {
+        return walk(entry.node, childPrefix, currentDepth + 1 | 0, entryRelPath);
+      }
+    });
+    if (!truncated) {
+      return;
+    }
+    let remaining = totalCount - 10 | 0;
+    lines.push(prefix + (`\u2514\u2500\u2500 ... and ` + remaining.toString() + ` more entries`));
+  };
+  lines.push(".");
+  walk(root, "", 1, void 0);
+  return lines.join("\n");
+}
+function buildWorkspacePathLookup(workspaces) {
+  let lookup = {};
+  workspaces.forEach((ws) => {
+    lookup[ws.path] = ws.name;
+  });
+  return lookup;
+}
+async function readJsonFile(path) {
+  try {
+    let content = await Fs7.promises.readFile(path, "utf8");
+    return {
+      TAG: "Ok",
+      _0: JSON.parse(content)
+    };
+  } catch (raw_exn) {
+    let exn = internalToException(raw_exn);
+    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
+    return {
+      TAG: "Error",
+      _0: `Failed to read/parse ` + path + `: ` + msg
+    };
+  }
+}
+async function readPackageName(dirPath) {
+  let pkgPath = Nodepath5.join(dirPath, "package.json");
+  let json3 = await readJsonFile(pkgPath);
+  if (json3.TAG !== "Ok") {
+    return;
+  }
+  try {
+    return parseOrThrow2(json3._0, packageJsonNameSchema).name;
+  } catch (exn) {
+    return;
+  }
+}
+function extractWorkspaceGlobs(json3) {
+  let obj = Decode.object(json3);
+  if (obj === void 0) {
+    return;
+  }
+  let wsJson = obj["workspaces"];
+  if (wsJson === void 0) {
+    return;
+  }
+  try {
+    return parseOrThrow2(wsJson, array2(string2));
+  } catch (exn) {
+    try {
+      return parseOrThrow2(wsJson, packageJsonWorkspacesObjSchema).packages;
+    } catch (exn$1) {
+      return;
+    }
+  }
+}
+async function resolveWorkspaceGlobs(rootPath, globs) {
+  let results = [];
+  await Promise.all(globs.map(async (glob) => {
+    if (glob.endsWith("/*")) {
+      let parentDir = glob.slice(0, glob.length - 2 | 0);
+      let fullParent = Nodepath5.join(rootPath, parentDir);
+      try {
+        let entries = await Fs7.promises.readdir(fullParent);
+        await Promise.all(entries.map(async (entry) => {
+          let entryPath = Nodepath5.join(fullParent, entry);
+          let stats = await Fs7.promises.stat(entryPath);
+          if (stats.isDirectory()) {
+            results.push(parentDir + "/" + entry);
+            return;
+          }
+        }));
+        return;
+      } catch (raw_exn) {
+        let exn = internalToException(raw_exn);
+        let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
+        console.warn(`ListTree: failed to resolve workspace glob "` + glob + `": ` + msg);
+        return;
+      }
+    } else {
+      let fullPath = Nodepath5.join(rootPath, glob);
+      if (await pathExists(fullPath)) {
+        results.push(glob);
+        return;
+      } else {
+        return;
+      }
+    }
+  }));
+  return results;
+}
+async function detectMonorepo(rootPath) {
+  let pkgJsonResult = await readJsonFile(Nodepath5.join(rootPath, "package.json"));
+  let workspaceGlobs;
+  workspaceGlobs = pkgJsonResult.TAG === "Ok" ? extractWorkspaceGlobs(pkgJsonResult._0) : void 0;
+  let hasTurbo = await pathExists(Nodepath5.join(rootPath, "turbo.json"));
+  let hasNx = await pathExists(Nodepath5.join(rootPath, "nx.json"));
+  let hasPnpmWorkspace = await pathExists(Nodepath5.join(rootPath, "pnpm-workspace.yaml"));
+  let monorepoType = hasTurbo ? "turborepo" : hasNx ? "nx" : hasPnpmWorkspace ? "pnpm-workspaces" : workspaceGlobs !== void 0 ? "npm-workspaces" : void 0;
+  let workspaces;
+  if (workspaceGlobs !== void 0) {
+    let resolvedPaths = await resolveWorkspaceGlobs(rootPath, workspaceGlobs);
+    workspaces = await Promise.all(resolvedPaths.map(async (wsPath) => {
+      let fullPath = Nodepath5.join(rootPath, wsPath);
+      let n = await readPackageName(fullPath);
+      let name15 = n !== void 0 ? n : wsPath;
+      return {
+        name: name15,
+        path: wsPath
+      };
+    }));
+  } else {
+    workspaces = [];
+  }
+  return {
+    monorepoType,
+    workspaces
+  };
+}
+async function getTrackedFiles(cwd) {
+  let result = await spawnResult("git", ["ls-files"], cwd);
+  if (result.TAG === "Ok") {
+    let lines = result._0.stdout.trim().split("\n").filter((line) => line !== "");
+    return {
+      TAG: "Ok",
+      _0: lines
+    };
+  }
+  let match = result._0;
+  let match$1 = match.code;
+  if (match$1 === 128) {
+    return {
+      TAG: "Error",
+      _0: `Not a git repository: ` + match.stderr
+    };
+  }
+  return {
+    TAG: "Error",
+    _0: `git ls-files failed: ` + match.stderr
+  };
+}
+async function execute6(ctx2, input) {
+  let path = getOr(input.path, ".");
+  let maxDepth = getOr(input.depth, 3);
+  let err = resolve2(ctx2.sourceRoot, path);
+  if (err.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: formatError(err._0)
+    };
+  }
+  let result = err._0;
+  try {
+    let fullPath;
+    try {
+      let stats = await Fs7.promises.stat(result.resolvedPath);
+      fullPath = stats.isFile() ? Nodepath5.dirname(result.resolvedPath) : result.resolvedPath;
+    } catch (exn) {
+      fullPath = result.resolvedPath;
+    }
+    let filesResult = await getTrackedFiles(fullPath);
+    let files;
+    if (filesResult.TAG === "Ok") {
+      files = filesResult._0;
+    } else {
+      console.warn(`ListTree: ` + filesResult._0 + `, falling back to readdir`);
+      files = await Fs7.promises.readdir(fullPath);
+    }
+    let trie = buildTrie(files);
+    let monoInfo = await detectMonorepo(fullPath);
+    let workspacePaths = buildWorkspacePathLookup(monoInfo.workspaces);
+    let tree = renderTree(trie, maxDepth, workspacePaths);
+    return {
+      TAG: "Ok",
+      _0: {
+        tree,
+        workspaces: monoInfo.workspaces,
+        monorepoType: monoInfo.monorepoType
+      }
+    };
+  } catch (raw_exn) {
+    let exn$1 = internalToException(raw_exn);
+    let msg = getOr(flatMap(fromException(exn$1), message2), "Unknown error");
+    return {
+      TAG: "Error",
+      _0: `Failed to list tree for ` + path + `: ` + msg
+    };
+  }
+}
+var description6 = `Returns a **recursive directory tree** of the project structure, with monorepo workspace detection.
+
+Use list_tree to get oriented in a codebase, understand the layout, or explore a subtree. Prefer this over chaining multiple list_files calls. For a flat listing of one directory, use list_files instead.
+
+PARAMETERS:
+- path (optional): Subdirectory to root the tree at. Defaults to "." (project root). If a file path is given, shows the tree from its parent directory.
+- depth (optional): Maximum directory depth to display. Defaults to 3.
+
+OUTPUT:
+Text tree with directories (ending in /) and files. Workspace roots are annotated with [workspace: name]. Respects .gitignore. Skips node_modules, .git, dist, build, etc.`;
+var name8 = ToolNames.readFile;
+var inputSchema7 = schema2((s2) => ({
+  path: s2.m(string2),
+  offset: s2.m(option2(int2)),
+  limit: s2.m(option2(int2))
+}));
+var pathContextSchema2 = schema2((s2) => ({
+  sourceRoot: s2.m(string2),
+  resolvedPath: s2.m(string2),
+  relativePath: s2.m(string2)
+}));
+var outputSchema7 = schema2((s2) => ({
+  content: s2.m(string2),
+  totalLines: s2.m(int2),
+  hasMore: s2.m(bool2),
+  _context: s2.m(option2(pathContextSchema2))
+}));
+async function execute7(ctx2, input) {
+  let offset = getOr(input.offset, 0);
+  let limit = getOr(input.limit, 500);
   let err = resolve2(ctx2.sourceRoot, input.path);
   if (err.TAG !== "Ok") {
     return {
@@ -4394,13 +5001,13 @@ async function execute6(ctx2, input) {
   }
   let result = err._0;
   try {
-    let content = await Fs.promises.readFile(result.resolvedPath, "utf8");
+    let content = await Fs7.promises.readFile(result.resolvedPath, "utf8");
     let lines = content.split("\n");
     let totalLines = lines.length;
     let selectedLines = lines.slice(offset, offset + limit | 0);
     let selectedContent = selectedLines.join("\n");
     let hasMore = (offset + limit | 0) < totalLines;
-    recordRead(result.resolvedPath);
+    recordRead(result.resolvedPath, offset, limit, totalLines);
     return {
       TAG: "Ok",
       _0: {
@@ -4423,7 +5030,7 @@ async function execute6(ctx2, input) {
     };
   }
 }
-var description6 = `Reads a file from the filesystem.
+var description7 = `Reads a file from the filesystem.
 
 Parameters:
 - path (required): Path to file - either relative to source root or absolute (must be under source root)
@@ -4431,7 +5038,12 @@ Parameters:
 - limit (optional): Maximum lines to read (default: 500). Pass null or 500 for default.
 
 Returns file content with metadata about total lines and whether more content exists.
-The _context field provides path resolution details for debugging.`;
+The _context field provides path resolution details for debugging.
+
+When hasMore is true, the file has content beyond what was returned. For large files:
+- Use grep first to find the line numbers of relevant sections, then read_file with a targeted offset.
+- Don't read sequentially from the top \u2014 jump to the section you need.
+- For React/Vue/Astro components, locate the render/return block before editing.`;
 
 // ../../node_modules/@rescript/runtime/lib/es6/Stdlib_Result.js
 function map3(opt, f) {
@@ -4446,8 +5058,8 @@ function map3(opt, f) {
 }
 
 // ../frontman-core/src/tools/FrontmanCore__Tool__ListFiles.res.mjs
-var name8 = ToolNames.listFiles;
-var inputSchema7 = schema2((s2) => ({
+var name9 = ToolNames.listFiles;
+var inputSchema8 = schema2((s2) => ({
   path: s2.m(option2(string2))
 }));
 var fileEntrySchema = schema2((s2) => ({
@@ -4456,7 +5068,7 @@ var fileEntrySchema = schema2((s2) => ({
   isFile: s2.m(bool2),
   isDirectory: s2.m(bool2)
 }));
-var outputSchema7 = array2(fileEntrySchema);
+var outputSchema8 = array2(fileEntrySchema);
 async function getIgnoredEntries(cwd, entries) {
   if (entries.length === 0) {
     return {
@@ -4511,7 +5123,7 @@ async function getIgnoredEntries(cwd, entries) {
     };
   }
 }
-async function execute7(ctx2, input) {
+async function execute8(ctx2, input) {
   let path = getOr(input.path, ".");
   let err = resolve2(ctx2.sourceRoot, path);
   if (err.TAG !== "Ok") {
@@ -4520,22 +5132,40 @@ async function execute7(ctx2, input) {
       _0: formatError(err._0)
     };
   }
+  let result = err._0;
   try {
-    let fullPath = err._0.resolvedPath;
-    let entries = await Fs.promises.readdir(fullPath);
-    let filteredEntriesResult = map3(await getIgnoredEntries(fullPath, entries), (ignored) => entries.filter((name14) => !ignored.includes(name14)));
+    let match;
+    try {
+      let stats = await Fs7.promises.stat(result.resolvedPath);
+      match = stats.isFile() ? [
+        Nodepath5.dirname(result.resolvedPath),
+        Nodepath5.dirname(path)
+      ] : [
+        result.resolvedPath,
+        path
+      ];
+    } catch (exn) {
+      match = [
+        result.resolvedPath,
+        path
+      ];
+    }
+    let relativePath = match[1];
+    let fullPath = match[0];
+    let entries = await Fs7.promises.readdir(fullPath);
+    let filteredEntriesResult = map3(await getIgnoredEntries(fullPath, entries), (ignored) => entries.filter((name15) => !ignored.includes(name15)));
     if (filteredEntriesResult.TAG !== "Ok") {
       return {
         TAG: "Error",
         _0: filteredEntriesResult._0
       };
     }
-    let entriesWithStats = await Promise.all(filteredEntriesResult._0.map(async (name14) => {
-      let entryPath = Nodepath.join(fullPath, name14);
-      let stats = await Fs.promises.stat(entryPath);
+    let entriesWithStats = await Promise.all(filteredEntriesResult._0.map(async (name15) => {
+      let entryPath = Nodepath5.join(fullPath, name15);
+      let stats = await Fs7.promises.stat(entryPath);
       return {
-        name: name14,
-        path: Nodepath.join(path, name14),
+        name: name15,
+        path: Nodepath5.join(relativePath, name15),
         isFile: stats.isFile(),
         isDirectory: stats.isDirectory()
       };
@@ -4545,22 +5175,25 @@ async function execute7(ctx2, input) {
       _0: entriesWithStats
     };
   } catch (raw_exn) {
-    let exn = internalToException(raw_exn);
-    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
+    let exn$1 = internalToException(raw_exn);
+    let msg = getOr(flatMap(fromException(exn$1), message2), "Unknown error");
     return {
       TAG: "Error",
       _0: `Failed to list files in ` + path + `: ` + msg
     };
   }
 }
-var description7 = `Lists files and directories in a given path.
+var description8 = `Lists the **immediate contents** of a single directory \u2014 names, paths, and whether each entry is a file or directory.
 
-Parameters:
-- path (optional): Path to directory - either relative to source root or absolute (must be under source root). Defaults to "." (root directory).
+Use list_files to inspect one directory before reading or editing files. For a recursive multi-level tree, use list_tree instead. To find files by name across the project, use search_files.
 
-Returns array of entries with name, path, and type information.`;
-var name9 = ToolNames.writeFile;
-var inputSchema8 = schema2((s2) => ({
+PARAMETERS:
+- path (optional): Directory to list (relative to source root or absolute). Defaults to "." (project root). If a file path is given, lists its parent directory.
+
+OUTPUT:
+Array of entries, each with name, path, isFile, and isDirectory. Respects .gitignore \u2014 ignored entries are excluded.`;
+var name10 = ToolNames.writeFile;
+var inputSchema9 = schema2((s2) => ({
   path: s2.m(string2),
   content: s2.m(option2(string2)),
   image_ref: s2.m(option2(string2)),
@@ -4571,17 +5204,17 @@ var pathContextSchema3 = schema2((s2) => ({
   resolvedPath: s2.m(string2),
   relativePath: s2.m(string2)
 }));
-var outputSchema8 = schema2((s2) => ({
+var outputSchema9 = schema2((s2) => ({
   _context: s2.m(option2(pathContextSchema3))
 }));
 function writeContent(resolvedPath, content, encoding) {
   if (encoding === void 0) {
-    return Fs.promises.writeFile(resolvedPath, content, "utf8");
+    return Fs7.promises.writeFile(resolvedPath, content, "utf8");
   }
   let buffer = Nodebuffer.Buffer.from(content, "base64");
-  return Fs.promises.writeFile(resolvedPath, buffer);
+  return Fs7.promises.writeFile(resolvedPath, buffer);
 }
-async function execute8(ctx2, input) {
+async function execute9(ctx2, input) {
   let match = input.content;
   let match$1 = input.image_ref;
   if (match === void 0) {
@@ -4610,32 +5243,49 @@ async function execute8(ctx2, input) {
       _0: formatError(err._0)
     };
   }
-  let result = err._0;
+  let resolved = err._0;
+  let fileExists;
   try {
-    await Fs.promises.mkdir(dirname3(result), {
+    await Fs7.promises.stat(resolved.resolvedPath);
+    fileExists = true;
+  } catch (exn) {
+    fileExists = false;
+  }
+  let guardResult = fileExists ? await assertEditSafe(resolved.resolvedPath) : {
+    TAG: "Ok",
+    _0: void 0
+  };
+  if (guardResult.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: guardResult._0
+    };
+  }
+  try {
+    await Fs7.promises.mkdir(dirname4(resolved), {
       recursive: true
     });
-    await writeContent(result.resolvedPath, match, input.encoding);
+    await writeContent(resolved.resolvedPath, match, input.encoding);
+    recordWrite(resolved.resolvedPath);
     return {
       TAG: "Ok",
       _0: {
         _context: {
-          sourceRoot: result.sourceRoot,
-          resolvedPath: result.resolvedPath,
-          relativePath: result.relativePath
+          sourceRoot: resolved.sourceRoot,
+          resolvedPath: resolved.resolvedPath,
+          relativePath: resolved.relativePath
         }
       }
     };
   } catch (raw_exn) {
-    let exn = internalToException(raw_exn);
-    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
+    let exn$1 = internalToException(raw_exn);
     return {
       TAG: "Error",
-      _0: `Failed to write file ` + input.path + `: ` + msg
+      _0: `Failed to write file ` + input.path + `: ` + message3(exn$1)
     };
   }
 }
-var description8 = `Writes content to a file.
+var description9 = `Writes content to a file.
 
 Parameters:
 - path (required): Path to file - either relative to source root or absolute (must be under source root)
@@ -4645,12 +5295,15 @@ Parameters:
 
 Provide either content OR image_ref, not both.
 Creates parent directories if they don't exist. Overwrites existing files.
-The _context field provides path resolution details for debugging.`;
-var name10 = ToolNames.fileExists;
-var inputSchema9 = schema2((s2) => ({
+
+IMPORTANT: If the file already exists, you MUST read it with read_file first. The tool will reject writes to existing files that haven't been read.`;
+
+// ../frontman-core/src/tools/FrontmanCore__Tool__FileExists.res.mjs
+var name11 = ToolNames.fileExists;
+var inputSchema10 = schema2((s2) => ({
   path: s2.m(string2)
 }));
-async function execute9(ctx2, input) {
+async function execute10(ctx2, input) {
   let msg = resolve(ctx2.sourceRoot, input.path);
   if (msg.TAG !== "Ok") {
     return {
@@ -4658,28 +5311,21 @@ async function execute9(ctx2, input) {
       _0: msg._0
     };
   }
-  try {
-    await Fs.promises.access(toString(msg._0));
-    return {
-      TAG: "Ok",
-      _0: true
-    };
-  } catch (exn) {
-    return {
-      TAG: "Ok",
-      _0: false
-    };
-  }
+  let exists = await pathExists(toString(msg._0));
+  return {
+    TAG: "Ok",
+    _0: exists
+  };
 }
-var description9 = `Checks if a file or directory exists.
+var description10 = `Checks if a file or directory exists.
 
 Parameters:
 - path (required): Path to check - either relative to source root or absolute (must be under source root)
 
 Returns true if the path exists, false otherwise.`;
-var outputSchema9 = bool2;
+var outputSchema10 = bool2;
 
-// ../bindings/src/Lighthouse.res.mjs
+// ../frontman-core/src/FrontmanCore__Lighthouse.res.mjs
 var run = ((url2, flags2) => import('module').then(({ createRequire }) => {
   const req = createRequire(import.meta.url);
   try {
@@ -4694,7 +5340,10 @@ var run = ((url2, flags2) => import('module').then(({ createRequire }) => {
   }
 }));
 
-// ../bindings/src/ChromeLauncher.res.mjs
+// ../frontman-core/src/FrontmanCore__ChromeLauncher.res.mjs
+function getPort(prim) {
+  return prim.port;
+}
 var launch = ((options) => import('module').then(({ createRequire }) => {
   const req = createRequire(import.meta.url);
   try {
@@ -4719,17 +5368,37 @@ async function killSafely(chrome) {
 }
 
 // ../frontman-core/src/tools/FrontmanCore__Tool__Lighthouse.res.mjs
-var name11 = ToolNames.lighthouse;
-var inputSchema10 = schema2((s2) => ({
+var name12 = ToolNames.lighthouse;
+var presetSchema = union2([
+  literal2("desktop"),
+  literal2("mobile")
+]);
+function presetToString(preset) {
+  if (preset === "desktop") {
+    return "desktop";
+  } else {
+    return "mobile";
+  }
+}
+var inputSchema11 = schema2((s2) => ({
   url: s2.m(string2),
-  preset: s2.m(option2(string2))
+  preset: s2.m(option2(presetSchema))
+}));
+var elementDetailSchema = schema2((s2) => ({
+  selector: s2.m(option2(string2)),
+  snippet: s2.m(option2(string2)),
+  nodeLabel: s2.m(option2(string2)),
+  explanation: s2.m(option2(string2)),
+  url: s2.m(option2(string2)),
+  sourceLocation: s2.m(option2(string2))
 }));
 var auditIssueSchema = schema2((s2) => ({
   id: s2.m(string2),
   title: s2.m(string2),
   description: s2.m(string2),
   score: s2.m(float2),
-  displayValue: s2.m(option2(string2))
+  displayValue: s2.m(option2(string2)),
+  elements: s2.m(array2(elementDetailSchema))
 }));
 var categoryResultSchema = schema2((s2) => ({
   id: s2.m(string2),
@@ -4737,7 +5406,7 @@ var categoryResultSchema = schema2((s2) => ({
   score: s2.m(int2),
   topIssues: s2.m(array2(auditIssueSchema))
 }));
-var outputSchema10 = schema2((s2) => ({
+var outputSchema11 = schema2((s2) => ({
   url: s2.m(string2),
   fetchTime: s2.m(string2),
   categories: s2.m(array2(categoryResultSchema)),
@@ -4750,30 +5419,126 @@ var categoryIds = [
   "best-practices",
   "seo"
 ];
+function getStr(dict3, key) {
+  return flatMap(dict3[key], Decode.string);
+}
+function extractNodeDetail(itemDict) {
+  let n = flatMap(itemDict["node"], Decode.object);
+  let nodeDict;
+  if (n !== void 0) {
+    nodeDict = n;
+  } else {
+    let match = getStr(itemDict, "type");
+    nodeDict = match === "node" ? itemDict : void 0;
+  }
+  if (nodeDict === void 0) {
+    return;
+  }
+  let selector = getStr(nodeDict, "selector");
+  let snippet = getStr(nodeDict, "snippet");
+  let nodeLabel = getStr(nodeDict, "nodeLabel");
+  let explanation = getStr(nodeDict, "explanation");
+  if (selector === void 0 && snippet === void 0) {
+    return;
+  }
+  return {
+    selector,
+    snippet,
+    nodeLabel,
+    explanation,
+    url: void 0,
+    sourceLocation: void 0
+  };
+}
+function extractSourceLocation(itemDict) {
+  let sourceDict = flatMap(itemDict["source"], Decode.object);
+  if (sourceDict === void 0) {
+    return;
+  }
+  let url2 = getStr(sourceDict, "url");
+  if (url2 === void 0) {
+    return;
+  }
+  let line = map(flatMap(sourceDict["line"], Decode.float), (prim) => prim | 0);
+  let col = map(flatMap(sourceDict["column"], Decode.float), (prim) => prim | 0);
+  if (line !== void 0) {
+    if (col !== void 0) {
+      return url2 + `:` + line.toString() + `:` + col.toString();
+    } else {
+      return url2 + `:` + line.toString();
+    }
+  } else {
+    return url2;
+  }
+}
+function extractResourceDetail(itemDict) {
+  let url2 = getStr(itemDict, "url");
+  let sourceLocation = extractSourceLocation(itemDict);
+  if (url2 === void 0 && sourceLocation === void 0) {
+    return;
+  }
+  return {
+    selector: void 0,
+    snippet: void 0,
+    nodeLabel: void 0,
+    explanation: void 0,
+    url: url2,
+    sourceLocation
+  };
+}
+function extractElements(details) {
+  let detailsDict = flatMap(details, Decode.object);
+  if (detailsDict === void 0) {
+    return [];
+  }
+  let arr = flatMap(detailsDict["items"], Decode.array);
+  let items = arr !== void 0 ? arr : [];
+  return filterMap(items, (item) => {
+    let itemDict = Decode.object(item);
+    if (itemDict === void 0) {
+      return;
+    }
+    let result = extractNodeDetail(itemDict);
+    if (result !== void 0) {
+      return result;
+    } else {
+      return extractResourceDetail(itemDict);
+    }
+  }).slice(0, 3);
+}
 function getTopIssues(category, audits, maxIssues) {
   return filterMap(category.auditRefs, (ref) => audits[ref.id]).filter((audit) => {
-    let score = audit.score;
-    if (!(score == null) && (audit.scoreDisplayMode === "binary" || audit.scoreDisplayMode === "numeric" || audit.scoreDisplayMode === "metricSavings")) {
-      return score < 1;
-    } else {
+    let match = audit.scoreDisplayMode;
+    let match$1 = audit.score;
+    switch (match) {
+      case "numeric":
+      case "binary":
+      case "metricSavings":
+        break;
+      default:
+        return false;
+    }
+    if (match$1 == null) {
       return false;
+    } else {
+      return match$1 < 1;
     }
   }).toSorted((a, b) => {
-    let scoreA = getOr(fromNullable(a.score), 0);
-    let scoreB = getOr(fromNullable(b.score), 0);
+    let scoreA = getOrThrow(fromNullable(a.score));
+    let scoreB = getOrThrow(fromNullable(b.score));
     return scoreA - scoreB;
   }).slice(0, maxIssues).map((audit) => ({
     id: audit.id,
     title: audit.title,
     description: audit.description,
-    score: getOr(fromNullable(audit.score), 0),
-    displayValue: audit.displayValue
+    score: getOrThrow(fromNullable(audit.score)),
+    displayValue: audit.displayValue,
+    elements: extractElements(audit.details)
   }));
 }
 function processLhr(lhr) {
   let categories = filterMap(categoryIds, (id) => lhr.categories[id]).map((category) => {
-    let s2 = category.score;
-    let score = !(s2 == null) ? Math.round(s2 * 100) | 0 : 0;
+    let score = Math.round(getOrThrow(fromNullable(category.score)) * 100) | 0;
     let topIssues = getTopIssues(category, lhr.audits, 3);
     return {
       id: category.id,
@@ -4794,14 +5559,17 @@ function processLhr(lhr) {
   };
 }
 async function runLighthouse(chrome, url2, preset) {
-  let port2 = chrome.port;
+  let port2 = getPort(chrome);
+  let formFactor = presetToString(preset);
+  let tmp;
+  tmp = preset === "desktop";
   let flags_port = port2;
   let flags_output = "json";
   let flags_logLevel = "error";
   let flags_onlyCategories = categoryIds;
-  let flags_formFactor = preset;
+  let flags_formFactor = formFactor;
   let flags_screenEmulation = {
-    disabled: preset === "desktop"
+    disabled: tmp
   };
   let flags_throttlingMethod = "simulate";
   let flags2 = {
@@ -4813,42 +5581,28 @@ async function runLighthouse(chrome, url2, preset) {
     screenEmulation: flags_screenEmulation,
     throttlingMethod: flags_throttlingMethod
   };
+  let result;
   try {
     let runnerResult = await run(url2, flags2);
-    await killSafely(chrome);
-    if (runnerResult == null) {
-      return {
-        TAG: "Error",
-        _0: "Lighthouse returned no results. The URL may be unreachable."
-      };
-    } else {
-      return {
-        TAG: "Ok",
-        _0: processLhr(runnerResult.lhr)
-      };
-    }
+    result = runnerResult == null ? {
+      TAG: "Error",
+      _0: "Lighthouse returned no results. The URL may be unreachable."
+    } : {
+      TAG: "Ok",
+      _0: processLhr(runnerResult.lhr)
+    };
   } catch (raw_exn) {
     let exn = internalToException(raw_exn);
-    await killSafely(chrome);
-    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
-    return {
+    result = {
       TAG: "Error",
-      _0: `Lighthouse audit failed: ` + msg
+      _0: `Lighthouse audit failed: ` + message3(exn)
     };
   }
+  await killSafely(chrome);
+  return result;
 }
-async function execute10(_ctx, input) {
+async function execute11(_ctx, input) {
   let preset = getOr(input.preset, "desktop");
-  switch (preset) {
-    case "desktop":
-    case "mobile":
-      break;
-    default:
-      return {
-        TAG: "Error",
-        _0: `Invalid preset "` + preset + `". Must be "desktop" or "mobile".`
-      };
-  }
   try {
     let chrome = await launch({
       chromeFlags: [
@@ -4861,14 +5615,13 @@ async function execute10(_ctx, input) {
     return await runLighthouse(chrome, input.url, preset);
   } catch (raw_exn) {
     let exn = internalToException(raw_exn);
-    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
     return {
       TAG: "Error",
-      _0: `Failed to launch Chrome: ` + msg + `. Make sure Chrome is installed on the system.`
+      _0: `Failed to launch Chrome: ` + message3(exn) + `. Make sure Chrome is installed on the system.`
     };
   }
 }
-var description10 = `Runs a Lighthouse audit on a URL to analyze performance, accessibility, best practices, and SEO.
+var description11 = `Runs a Lighthouse audit on a URL to analyze performance, accessibility, best practices, and SEO.
 
 WHEN TO USE THIS TOOL:
 - After making changes that might affect page load performance
@@ -4882,21 +5635,27 @@ PARAMETERS:
   IMPORTANT: Check the current_page context for device_emulation - if a mobile device is being emulated (e.g., iPhone, Pixel), use preset: "mobile" to match the user's testing context.
 
 OUTPUT:
-Returns scores (0-100) for each category plus the top 3 issues to fix in each category.
-Higher scores are better. Issues include actionable descriptions.
+Returns scores (0-100) for each category plus the top 3 worst issues per category.
+Higher scores are better. Each issue includes:
+- A description of the problem
+- Specific offending elements with CSS selectors, HTML snippets, and source locations when available
+Use the selectors and snippets to locate the exact elements that need fixing.
+
+IMPORTANT - ITERATIVE FIXING:
+Only the 3 worst-scoring issues per category are returned. Fixing these may reveal additional issues that were previously ranked lower. After making fixes, re-run the lighthouse audit to check for newly surfaced issues and verify improvements. Repeat until scores are satisfactory.
 
 LIMITATIONS:
 - Requires Chrome to be installed on the system
 - Takes 15-30 seconds to complete
 - Results can vary between runs (\xB15 points is normal)
 - URL must be accessible from the machine running the audit`;
-var name12 = ToolNames.searchFiles;
-var inputSchema11 = schema2((s2) => ({
+var name13 = ToolNames.searchFiles;
+var inputSchema12 = schema2((s2) => ({
   pattern: s2.m(string2),
   path: s2.m(option2(string2)),
   max_results: s2.m(option2(int2))
 }));
-var outputSchema11 = schema2((s2) => ({
+var outputSchema12 = schema2((s2) => ({
   files: s2.m(array2(string2)),
   totalResults: s2.m(int2),
   truncated: s2.m(bool2)
@@ -4946,7 +5705,7 @@ function matchesPattern(fileName2, patternLower) {
 function filterAndPaginate(lines, pattern2, maxResults) {
   let patternLower = pattern2.toLowerCase();
   let matchedFiles = lines.filter((filePath) => {
-    let fileName2 = Nodepath.basename(filePath);
+    let fileName2 = Nodepath5.basename(filePath);
     return matchesPattern(fileName2, patternLower);
   });
   let truncated = matchedFiles.length > maxResults;
@@ -5010,8 +5769,8 @@ async function executeGitLsFiles(pattern2, searchPath, maxResults) {
     _0: `Git ls-files failed: ` + match.stderr
   };
 }
-async function execute11(ctx2, input) {
-  let searchPath = resolveSearchPath(ctx2.sourceRoot, input.path);
+async function execute12(ctx2, input) {
+  let searchPath = await resolveSearchDir(ctx2.sourceRoot, input.path);
   let maxResults = getOr(input.max_results, 20);
   let rgPath = getRipgrepPath2();
   if (rgPath === void 0) {
@@ -5024,43 +5783,36 @@ async function execute11(ctx2, input) {
     return await executeGitLsFiles(input.pattern, searchPath, maxResults);
   }
 }
-var description11 = `Fast file name search tool that finds files matching a pattern.
+var description12 = `Searches **file names** across the project. Returns file paths whose name matches a pattern.
 
-WHEN TO USE THIS TOOL:
-- Use when you need to find files by name pattern
-- Great for locating specific files like "config.json" or "*.test.ts"
-- Useful for finding all files with a specific extension or naming convention
-- When you need to discover the file structure of a project
-- Note: this tool only searches file names, not directory names. Use list_files to browse directories.
+Use search_files to locate files by name \u2014 "find the Button component", "where are the test files". This does NOT search file contents; use grep for that. Use list_tree for a structural overview of the project.
 
 PARAMETERS:
-- pattern (required): The filename pattern to search for (supports glob-like patterns)
-- path (optional): Directory to search in (defaults to source root)
+- pattern (required): Filename pattern to match (supports glob-like: "*.test.ts", "config", "Button*")
+- path (optional): Directory to search in (defaults to source root). If a file path is given, searches in its parent directory.
 - max_results (optional): Maximum number of results to return (default: 20)
 
 EXAMPLES:
-- Find all config files: pattern="config"
-- Find TypeScript test files: pattern="*.test.ts"
-- Find files in specific directory: pattern="*.json", path="src/config"
+- Locate a component: pattern="Button"
+- Find test files: pattern="*.test.ts"
+- Find configs in a subdirectory: pattern="*.json", path="src/config"
 
 OUTPUT:
-Returns list of matching file paths.
-Results are sorted by modification time (newest first).
+List of matching file paths, sorted by modification time (newest first).
 
 LIMITATIONS:
-- Results limited to max_results (default 20)
-- Hidden files (starting with '.') are included
-- Respects .gitignore when using git ls-files fallback
-- Only finds files, not directories`;
-var name13 = ToolNames.loadAgentInstructions;
-var inputSchema12 = schema2((s2) => ({
+- Results capped at max_results (default 20)
+- Matches file names only, not directory names
+- Hidden files (dotfiles) are included`;
+var name14 = ToolNames.loadAgentInstructions;
+var inputSchema13 = schema2((s2) => ({
   startPath: s2.m(option2(string2))
 }));
 var instructionFileSchema = schema2((s2) => ({
   content: s2.m(string2),
   fullPath: s2.m(string2)
 }));
-var outputSchema12 = array2(instructionFileSchema);
+var outputSchema13 = array2(instructionFileSchema);
 var agentsVariants = [
   "Agents.md",
   ".claude/Agents.md",
@@ -5073,11 +5825,11 @@ var claudeVariants = [
 ];
 async function findFileCaseInsensitive(dir, targetFileName) {
   try {
-    let files = await Fs.promises.readdir(dir);
+    let files = await Fs7.promises.readdir(dir);
     let targetLower = targetFileName.toLowerCase();
     let found = files.find((file) => file.toLowerCase() === targetLower);
     if (found !== void 0) {
-      return Nodepath.join(dir, found);
+      return Nodepath5.join(dir, found);
     } else {
       return;
     }
@@ -5086,14 +5838,14 @@ async function findFileCaseInsensitive(dir, targetFileName) {
   }
 }
 async function loadIfExists(path) {
-  let dir = Nodepath.dirname(path);
-  let fileName2 = Nodepath.basename(path);
+  let dir = Nodepath5.dirname(path);
+  let fileName2 = Nodepath5.basename(path);
   let actualPath = await findFileCaseInsensitive(dir, fileName2);
   if (actualPath === void 0) {
     return;
   }
   try {
-    let content = await Fs.promises.readFile(actualPath, "utf8");
+    let content = await Fs7.promises.readFile(actualPath, "utf8");
     return {
       content,
       fullPath: actualPath
@@ -5106,7 +5858,7 @@ async function loadVariants(dir, variants) {
   let results = [];
   for (let i = 0, i_finish = variants.length; i < i_finish; ++i) {
     let variant = variants[i];
-    let path = Nodepath.join(dir, variant);
+    let path = Nodepath5.join(dir, variant);
     let file = await loadIfExists(path);
     if (file !== void 0) {
       results.push(file);
@@ -5123,7 +5875,7 @@ async function findAtDirectory(dir) {
   }
 }
 async function walkUpDirectories(current, acc) {
-  let parent = Nodepath.dirname(current);
+  let parent = Nodepath5.dirname(current);
   if (parent === current) {
     return acc;
   }
@@ -5131,7 +5883,7 @@ async function walkUpDirectories(current, acc) {
   let newAcc = acc.concat(filesAtLevel);
   return await walkUpDirectories(parent, newAcc);
 }
-async function execute12(ctx2, input) {
+async function execute13(ctx2, input) {
   let inputPath = getOr(input.startPath, ".");
   let msg = resolve(ctx2.sourceRoot, inputPath);
   if (msg.TAG !== "Ok") {
@@ -5156,7 +5908,7 @@ async function execute12(ctx2, input) {
     };
   }
 }
-var description12 = `Discovers and loads agent instruction files (Agents.md or CLAUDE.md) following Claude Code's discovery algorithm.
+var description13 = `Discovers and loads agent instruction files (Agents.md or CLAUDE.md) following Claude Code's discovery algorithm.
 
 Parameters:
 - startPath (optional): Starting directory for discovery - must be under source root. Defaults to "." (source root).
@@ -5173,22 +5925,6 @@ Discovery:
 function coreTools() {
   return {
     tools: [
-      {
-        name: name7,
-        description: description6,
-        inputSchema: inputSchema6,
-        outputSchema: outputSchema6,
-        execute: execute6,
-        visibleToAgent: true
-      },
-      {
-        name: name9,
-        description: description8,
-        inputSchema: inputSchema8,
-        outputSchema: outputSchema8,
-        execute: execute8,
-        visibleToAgent: true
-      },
       {
         name: name8,
         description: description7,
@@ -5206,11 +5942,27 @@ function coreTools() {
         visibleToAgent: true
       },
       {
-        name: name13,
-        description: description12,
-        inputSchema: inputSchema12,
-        outputSchema: outputSchema12,
-        execute: execute12,
+        name: name9,
+        description: description8,
+        inputSchema: inputSchema8,
+        outputSchema: outputSchema8,
+        execute: execute8,
+        visibleToAgent: true
+      },
+      {
+        name: name11,
+        description: description10,
+        inputSchema: inputSchema10,
+        outputSchema: outputSchema10,
+        execute: execute10,
+        visibleToAgent: true
+      },
+      {
+        name: name14,
+        description: description13,
+        inputSchema: inputSchema13,
+        outputSchema: outputSchema13,
+        execute: execute13,
         visibleToAgent: false
       },
       {
@@ -5221,6 +5973,14 @@ function coreTools() {
         execute: execute5,
         visibleToAgent: true
       },
+      {
+        name: name13,
+        description: description12,
+        inputSchema: inputSchema12,
+        outputSchema: outputSchema12,
+        execute: execute12,
+        visibleToAgent: true
+      },
       {
         name: name12,
         description: description11,
@@ -5229,14 +5989,6 @@ function coreTools() {
         execute: execute11,
         visibleToAgent: true
       },
-      {
-        name: name11,
-        description: description10,
-        inputSchema: inputSchema10,
-        outputSchema: outputSchema10,
-        execute: execute10,
-        visibleToAgent: true
-      },
       {
         name: name3,
         description: description2,
@@ -5244,6 +5996,14 @@ function coreTools() {
         outputSchema: outputSchema2,
         execute: execute2,
         visibleToAgent: true
+      },
+      {
+        name: name7,
+        description: description6,
+        inputSchema: inputSchema6,
+        outputSchema: outputSchema6,
+        execute: execute6,
+        visibleToAgent: true
       }
     ]
   };
@@ -5264,8 +6024,8 @@ function replaceByName(registry, replacement) {
     })
   };
 }
-function getToolByName(registry, name14) {
-  return registry.tools.find((m) => m.name === name14);
+function getToolByName(registry, name15) {
+  return registry.tools.find((m) => m.name === name15);
 }
 function serializeTool(m) {
   return {
@@ -5345,6 +6105,18 @@ function handlePreflight() {
   });
 }
 
+// ../frontman-core/src/FrontmanCore__MiddlewareConfig.res.mjs
+function frameworkIdToString(id) {
+  switch (id) {
+    case "Nextjs":
+      return "nextjs";
+    case "Vite":
+      return "vite";
+    case "Astro":
+      return "astro";
+  }
+}
+
 // ../frontman-core/src/FrontmanCore__UIShell.res.mjs
 function generateHTML(config) {
   let clientCssTag = mapOr(config.clientCssUrl, "", (url2) => `<link rel="stylesheet" href="` + url2 + `">`);
@@ -5358,11 +6130,19 @@ function generateHTML(config) {
   let configObj = Object.fromEntries([
     [
       "framework",
-      config.frameworkLabel
+      frameworkIdToString(config.frameworkId)
     ],
     [
       "basePath",
       config.basePath
+    ],
+    [
+      "projectRoot",
+      config.projectRoot
+    ],
+    [
+      "sourceRoot",
+      config.sourceRoot
     ]
   ]);
   forEach(openrouterKey, (key) => {
@@ -5416,7 +6196,7 @@ function serveWithEntrypoint(config, entrypointUrl) {
     clientCssUrl: config.clientCssUrl,
     entrypointUrl,
     isLightTheme: config.isLightTheme,
-    frameworkLabel: config.frameworkLabel
+    frameworkId: config.frameworkId
   } : config);
 }
 
@@ -5425,80 +6205,6 @@ function $$catch(promise, callback) {
   return promise.catch((err) => callback(internalToException(err)));
 }
 
-// ../frontman-protocol/src/FrontmanProtocol__MCP.res.mjs
-enableJson2();
-var capabilitiesSchema = schema2((s2) => ({
-  tools: s2.m(option2(dict2(json2))),
-  resources: s2.m(option2(dict2(json2))),
-  prompts: s2.m(option2(dict2(json2)))
-}));
-var infoSchema = schema2((s2) => ({
-  name: s2.m(string2),
-  version: s2.m(string2)
-}));
-schema2((s2) => ({
-  protocolVersion: s2.m(string2),
-  capabilities: s2.m(capabilitiesSchema),
-  clientInfo: s2.m(infoSchema)
-}));
-schema2((s2) => ({
-  protocolVersion: s2.m(string2),
-  capabilities: s2.m(capabilitiesSchema),
-  serverInfo: s2.m(infoSchema)
-}));
-schema2((s2) => ({
-  callId: s2.m(string2),
-  name: s2.m(string2),
-  arguments: s2.m(option2(dict2(json2)))
-}));
-var toolResultContentSchema = schema2((s2) => ({
-  type: s2.m(string2),
-  text: s2.m(string2)
-}));
-schema2((s2) => ({
-  code: s2.m(int2),
-  message: s2.m(string2)
-}));
-var callToolResultSchema = schema2((s2) => ({
-  content: s2.m(array2(toolResultContentSchema)),
-  isError: s2.m(option2(bool2))
-}));
-schema2((s2) => ({
-  tools: s2.m(array2(json2))
-}));
-
-// ../frontman-core/src/FrontmanCore__SSE.res.mjs
-function formatEvent(eventType, data) {
-  return `event: ` + eventType + `
-data: ` + data + `
-
-`;
-}
-function resultEvent(result) {
-  let data = JSON.stringify(reverseConvertToJsonOrThrow2(result, callToolResultSchema));
-  return formatEvent("result", data);
-}
-function errorEvent(result) {
-  let data = JSON.stringify(reverseConvertToJsonOrThrow2(result, callToolResultSchema));
-  return formatEvent("error", data);
-}
-function headers() {
-  return Object.fromEntries([
-    [
-      "Content-Type",
-      "text/event-stream"
-    ],
-    [
-      "Cache-Control",
-      "no-cache, no-transform"
-    ],
-    [
-      "Connection",
-      "keep-alive"
-    ]
-  ]);
-}
-
 // ../../node_modules/dom-element-to-component-source/dist/_commonjsHelpers-CqEciG1_.mjs
 function c(e) {
   if (Object.prototype.hasOwnProperty.call(e, "__esModule")) return e;
@@ -7108,6 +7814,80 @@ async function Te(o) {
   }
 }
 
+// ../frontman-protocol/src/FrontmanProtocol__MCP.res.mjs
+enableJson2();
+var capabilitiesSchema = schema2((s2) => ({
+  tools: s2.m(option2(dict2(json2))),
+  resources: s2.m(option2(dict2(json2))),
+  prompts: s2.m(option2(dict2(json2)))
+}));
+var infoSchema = schema2((s2) => ({
+  name: s2.m(string2),
+  version: s2.m(string2)
+}));
+schema2((s2) => ({
+  protocolVersion: s2.m(string2),
+  capabilities: s2.m(capabilitiesSchema),
+  clientInfo: s2.m(infoSchema)
+}));
+schema2((s2) => ({
+  protocolVersion: s2.m(string2),
+  capabilities: s2.m(capabilitiesSchema),
+  serverInfo: s2.m(infoSchema)
+}));
+schema2((s2) => ({
+  callId: s2.m(string2),
+  name: s2.m(string2),
+  arguments: s2.m(option2(dict2(json2)))
+}));
+var toolResultContentSchema = schema2((s2) => ({
+  type: s2.m(string2),
+  text: s2.m(string2)
+}));
+schema2((s2) => ({
+  code: s2.m(int2),
+  message: s2.m(string2)
+}));
+var callToolResultSchema = schema2((s2) => ({
+  content: s2.m(array2(toolResultContentSchema)),
+  isError: s2.m(option2(bool2))
+}));
+schema2((s2) => ({
+  tools: s2.m(array2(json2))
+}));
+
+// ../frontman-core/src/FrontmanCore__SSE.res.mjs
+function formatEvent(eventType, data) {
+  return `event: ` + eventType + `
+data: ` + data + `
+
+`;
+}
+function resultEvent(result) {
+  let data = JSON.stringify(reverseConvertToJsonOrThrow2(result, callToolResultSchema));
+  return formatEvent("result", data);
+}
+function errorEvent(result) {
+  let data = JSON.stringify(reverseConvertToJsonOrThrow2(result, callToolResultSchema));
+  return formatEvent("error", data);
+}
+function headers() {
+  return Object.fromEntries([
+    [
+      "Content-Type",
+      "text/event-stream"
+    ],
+    [
+      "Cache-Control",
+      "no-cache, no-transform"
+    ],
+    [
+      "Connection",
+      "keep-alive"
+    ]
+  ]);
+}
+
 // ../frontman-protocol/src/FrontmanProtocol__Relay.res.mjs
 var remoteToolSchema = schema2((s2) => ({
   name: s2.m(string2),
@@ -7127,12 +7907,12 @@ var toolCallRequestSchema = schema2((s2) => ({
 var protocolVersion = "1.0";
 
 // ../frontman-core/src/FrontmanCore__Server.res.mjs
-async function executeTool(registry, ctx2, name14, $$arguments) {
-  let toolModule = getToolByName(registry, name14);
+async function executeTool(registry, ctx2, name15, $$arguments) {
+  let toolModule = getToolByName(registry, name15);
   if (toolModule === void 0) {
     return {
       TAG: "ToolNotFound",
-      _0: name14
+      _0: name15
     };
   }
   let toolCtx_projectRoot = ctx2.projectRoot;
@@ -7536,7 +8316,7 @@ function toMiddlewareConfig(config) {
     clientCssUrl: config.clientCssUrl,
     entrypointUrl: config.entrypointUrl,
     isLightTheme: config.isLightTheme,
-    frameworkLabel: "Astro"
+    frameworkId: "Astro"
   };
 }
 function createMiddleware2(config) {
@@ -7545,7 +8325,7 @@ function createMiddleware2(config) {
   return createMiddleware(middlewareConfig, registry);
 }
 
-// ../bindings/src/NodeHttp.res.mjs
+// src/FrontmanAstro__ViteAdapter.res.mjs
 var collectRequestBody = (async function(req) {
   const chunks = [];
   for await (const chunk of req) {
@@ -7554,8 +8334,6 @@ var collectRequestBody = (async function(req) {
   const { Buffer: Buffer4 } = await import('buffer');
   return Buffer4.concat(chunks);
 });
-
-// src/FrontmanAstro__ViteAdapter.res.mjs
 var copyHeaders = (function(headers2, res) {
   headers2.forEach(function(value, key) {
     res.setHeader(key, value);
@@ -7695,6 +8473,29 @@ function make5(configInput) {
       },
       "astro:server:setup": (param) => {
         initialize();
+        let prependTrailingSlashRewrite = (function(server, basePath) {
+          var hs = server.httpServer;
+          if (!hs) return;
+          var prefix = "/" + basePath.toLowerCase();
+          var prefixSlash = prefix + "/";
+          var listeners = hs.listeners("request").slice();
+          hs.removeAllListeners("request");
+          hs.on("request", function(req) {
+            var raw = req.url || "";
+            var qIdx = raw.indexOf("?");
+            var path = (qIdx !== -1 ? raw.slice(0, qIdx) : raw).toLowerCase();
+            var needsSlash = false;
+            if (path === prefix) needsSlash = true;
+            else if (path.lastIndexOf("/") < path.length - 1 && (path.startsWith(prefixSlash) || path.endsWith(prefix))) needsSlash = true;
+            if (needsSlash) {
+              var qs = qIdx !== -1 ? raw.slice(qIdx) : "";
+              var pathPart = qIdx !== -1 ? raw.slice(0, qIdx) : raw;
+              req.url = pathPart + "/" + qs;
+            }
+          });
+          for (var i = 0; i < listeners.length; i++) hs.on("request", listeners[i]);
+        });
+        prependTrailingSlashRewrite(param.server, config.basePath);
         param.toolbar.onAppInitialized("frontman:toolbar", () => {
           console.log("[Frontman] Dev toolbar app initialized");
         });