@frontman-ai/astro 0.4.2 → 0.5.1

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 Nodepath4 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);
 }
@@ -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.1" ;
 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);
@@ -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 = Nodepath4.normalize(sourceRoot);
-  let rootWithSep = endsWithSep(normalizedRoot) ? normalizedRoot : normalizedRoot + Nodepath4.sep;
-  if (Nodepath4.isAbsolute(inputPath)) {
-    let normalizedPath = Nodepath4.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 = Nodepath4.normalize(Nodepath4.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 Nodepath4.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 + Nodepath4.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 (!Nodepath4.isAbsolute(inputPath)) {
-    return Nodepath4.join(sourceRoot, inputPath);
+  if (!Nodepath5.isAbsolute(inputPath)) {
+    return Nodepath5.join(sourceRoot, inputPath);
   }
-  let normalizedPath = Nodepath4.normalize(inputPath);
-  let normalizedRoot = Nodepath4.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 = Nodepath4.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 = Nodepath4.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, Nodepath4.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 = Nodepath4.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) {
@@ -4230,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",
@@ -4249,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
@@ -4336,36 +4533,31 @@ 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`;
+- 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) {
@@ -4419,7 +4611,7 @@ function compare(s1, s2) {
 }
 async function pathExists(path) {
   try {
-    await Fs.promises.access(path);
+    await Fs7.promises.access(path);
     return true;
   } catch (exn) {
     return false;
@@ -4592,7 +4784,7 @@ function buildWorkspacePathLookup(workspaces) {
 }
 async function readJsonFile(path) {
   try {
-    let content = await Fs.promises.readFile(path, "utf8");
+    let content = await Fs7.promises.readFile(path, "utf8");
     return {
       TAG: "Ok",
       _0: JSON.parse(content)
@@ -4607,7 +4799,7 @@ async function readJsonFile(path) {
   }
 }
 async function readPackageName(dirPath) {
-  let pkgPath = Nodepath4.join(dirPath, "package.json");
+  let pkgPath = Nodepath5.join(dirPath, "package.json");
   let json3 = await readJsonFile(pkgPath);
   if (json3.TAG !== "Ok") {
     return;
@@ -4642,12 +4834,12 @@ async function resolveWorkspaceGlobs(rootPath, globs) {
   await Promise.all(globs.map(async (glob) => {
     if (glob.endsWith("/*")) {
       let parentDir = glob.slice(0, glob.length - 2 | 0);
-      let fullParent = Nodepath4.join(rootPath, parentDir);
+      let fullParent = Nodepath5.join(rootPath, parentDir);
       try {
-        let entries = await Fs.promises.readdir(fullParent);
+        let entries = await Fs7.promises.readdir(fullParent);
         await Promise.all(entries.map(async (entry) => {
-          let entryPath = Nodepath4.join(fullParent, entry);
-          let stats = await Fs.promises.stat(entryPath);
+          let entryPath = Nodepath5.join(fullParent, entry);
+          let stats = await Fs7.promises.stat(entryPath);
           if (stats.isDirectory()) {
             results.push(parentDir + "/" + entry);
             return;
@@ -4661,7 +4853,7 @@ async function resolveWorkspaceGlobs(rootPath, globs) {
         return;
       }
     } else {
-      let fullPath = Nodepath4.join(rootPath, glob);
+      let fullPath = Nodepath5.join(rootPath, glob);
       if (await pathExists(fullPath)) {
         results.push(glob);
         return;
@@ -4673,18 +4865,18 @@ async function resolveWorkspaceGlobs(rootPath, globs) {
   return results;
 }
 async function detectMonorepo(rootPath) {
-  let pkgJsonResult = await readJsonFile(Nodepath4.join(rootPath, "package.json"));
+  let pkgJsonResult = await readJsonFile(Nodepath5.join(rootPath, "package.json"));
   let workspaceGlobs;
   workspaceGlobs = pkgJsonResult.TAG === "Ok" ? extractWorkspaceGlobs(pkgJsonResult._0) : void 0;
-  let hasTurbo = await pathExists(Nodepath4.join(rootPath, "turbo.json"));
-  let hasNx = await pathExists(Nodepath4.join(rootPath, "nx.json"));
-  let hasPnpmWorkspace = await pathExists(Nodepath4.join(rootPath, "pnpm-workspace.yaml"));
+  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 = Nodepath4.join(rootPath, wsPath);
+      let fullPath = Nodepath5.join(rootPath, wsPath);
       let n = await readPackageName(fullPath);
       let name15 = n !== void 0 ? n : wsPath;
       return {
@@ -4732,15 +4924,22 @@ async function execute6(ctx2, input) {
       _0: formatError(err._0)
     };
   }
+  let result = err._0;
   try {
-    let fullPath = err._0.resolvedPath;
+    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 Fs.promises.readdir(fullPath);
+      files = await Fs7.promises.readdir(fullPath);
     }
     let trie = buildTrie(files);
     let monoInfo = await detectMonorepo(fullPath);
@@ -4755,30 +4954,24 @@ async function execute6(ctx2, input) {
       }
     };
   } 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 tree for ` + path + `: ` + msg
     };
   }
 }
-var description6 = `Returns a text tree view of the project directory structure with monorepo workspace detection.
+var description6 = `Returns a **recursive directory tree** of the project structure, with monorepo workspace detection.
 
-WHEN TO USE THIS TOOL:
-- Getting oriented in an unfamiliar codebase
-- Understanding monorepo workspace layout and boundaries
-- Exploring a specific subdirectory's structure in depth
-- Prefer this over chaining multiple list_files calls for structure discovery
+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).
+- 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:
-Returns a text tree with directories and files. Directories end with /.
-Workspace roots are annotated with [workspace: name].
-Respects .gitignore. Skips node_modules, .git, dist, build, etc.`;
+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),
@@ -4808,13 +5001,13 @@ async function execute7(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: {
@@ -4845,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) {
@@ -4934,9 +5132,27 @@ async function execute8(ctx2, input) {
       _0: formatError(err._0)
     };
   }
+  let result = err._0;
   try {
-    let fullPath = err._0.resolvedPath;
-    let entries = await Fs.promises.readdir(fullPath);
+    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 {
@@ -4945,11 +5161,11 @@ async function execute8(ctx2, input) {
       };
     }
     let entriesWithStats = await Promise.all(filteredEntriesResult._0.map(async (name15) => {
-      let entryPath = Nodepath4.join(fullPath, name15);
-      let stats = await Fs.promises.stat(entryPath);
+      let entryPath = Nodepath5.join(fullPath, name15);
+      let stats = await Fs7.promises.stat(entryPath);
       return {
         name: name15,
-        path: Nodepath4.join(path, name15),
+        path: Nodepath5.join(relativePath, name15),
         isFile: stats.isFile(),
         isDirectory: stats.isDirectory()
       };
@@ -4959,29 +5175,23 @@ async function execute8(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 description8 = `Lists files and directories in a single directory.
+var description8 = `Lists the **immediate contents** of a single directory \u2014 names, paths, and whether each entry is a file or directory.
 
-WHEN TO USE THIS TOOL:
-- Browsing one directory's immediate contents in detail (names, types)
-- Checking what files exist in a specific directory before reading or editing
-- Verifying file organization after making changes
-- Use list_tree instead when you need a multi-level project overview or monorepo layout
-- Use search_files instead when you need to find files by name pattern across the project
+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.
 
 PARAMETERS:
-- path (optional): Path to directory - either relative to source root or absolute (must be under source root). Defaults to "." (root directory).
+- 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:
-Returns array of entries with name, path, and type (file or directory) information.
-Respects .gitignore \u2014 ignored files are excluded from results.`;
+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),
@@ -4999,10 +5209,10 @@ var outputSchema9 = schema2((s2) => ({
 }));
 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 execute9(ctx2, input) {
   let match = input.content;
@@ -5033,28 +5243,45 @@ async function execute9(ctx2, input) {
       _0: formatError(err._0)
     };
   }
-  let result = err._0;
+  let resolved = err._0;
+  let fileExists;
+  try {
+    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 Fs.promises.mkdir(dirname3(result), {
+    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)
     };
   }
 }
@@ -5068,7 +5295,8 @@ 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.`;
+
+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;
@@ -5097,7 +5325,7 @@ Parameters:
 Returns true if the path exists, false otherwise.`;
 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 {
@@ -5112,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 {
@@ -5136,11 +5367,6 @@ async function killSafely(chrome) {
   }
 }
 
-// ../frontman-core/src/FrontmanCore__ExnUtils.res.mjs
-function message3(exn) {
-  return getOr(flatMap(fromException(exn), message2), "Unknown error");
-}
-
 // ../frontman-core/src/tools/FrontmanCore__Tool__Lighthouse.res.mjs
 var name12 = ToolNames.lighthouse;
 var presetSchema = union2([
@@ -5333,7 +5559,7 @@ 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";
@@ -5479,7 +5705,7 @@ function matchesPattern(fileName2, patternLower) {
 function filterAndPaginate(lines, pattern2, maxResults) {
   let patternLower = pattern2.toLowerCase();
   let matchedFiles = lines.filter((filePath) => {
-    let fileName2 = Nodepath4.basename(filePath);
+    let fileName2 = Nodepath5.basename(filePath);
     return matchesPattern(fileName2, patternLower);
   });
   let truncated = matchedFiles.length > maxResults;
@@ -5544,7 +5770,7 @@ async function executeGitLsFiles(pattern2, searchPath, maxResults) {
   };
 }
 async function execute12(ctx2, input) {
-  let searchPath = resolveSearchPath(ctx2.sourceRoot, input.path);
+  let searchPath = await resolveSearchDir(ctx2.sourceRoot, input.path);
   let maxResults = getOr(input.max_results, 20);
   let rgPath = getRipgrepPath2();
   if (rgPath === void 0) {
@@ -5557,34 +5783,27 @@ async function execute12(ctx2, input) {
     return await executeGitLsFiles(input.pattern, searchPath, maxResults);
   }
 }
-var description12 = `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`;
+- 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))
@@ -5606,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 Nodepath4.join(dir, found);
+      return Nodepath5.join(dir, found);
     } else {
       return;
     }
@@ -5619,14 +5838,14 @@ async function findFileCaseInsensitive(dir, targetFileName) {
   }
 }
 async function loadIfExists(path) {
-  let dir = Nodepath4.dirname(path);
-  let fileName2 = Nodepath4.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
@@ -5639,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 = Nodepath4.join(dir, variant);
+    let path = Nodepath5.join(dir, variant);
     let file = await loadIfExists(path);
     if (file !== void 0) {
       results.push(file);
@@ -5656,7 +5875,7 @@ async function findAtDirectory(dir) {
   }
 }
 async function walkUpDirectories(current, acc) {
-  let parent = Nodepath4.dirname(current);
+  let parent = Nodepath5.dirname(current);
   if (parent === current) {
     return acc;
   }
@@ -5886,29 +6105,54 @@ 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 + `">`);
   let entrypointTemplate = mapOr(config.entrypointUrl, "", (url2) => `<script type="template" id="frontman-entrypoint-url">` + url2 + `</script>`);
   let themeClass = config.isLightTheme ? "" : "dark";
-  let openrouterKey = flatMap(process.env["OPENROUTER_API_KEY"], (key) => {
+  let getEnvKey = (varName) => flatMap(process.env[varName], (key) => {
     if (key !== "") {
       return key;
     }
   });
+  let openrouterKey = getEnvKey("OPENROUTER_API_KEY");
+  let anthropicKey = getEnvKey("ANTHROPIC_API_KEY");
   let configObj = Object.fromEntries([
     [
       "framework",
-      config.frameworkLabel
+      frameworkIdToString(config.frameworkId)
     ],
     [
       "basePath",
       config.basePath
+    ],
+    [
+      "projectRoot",
+      config.projectRoot
+    ],
+    [
+      "sourceRoot",
+      config.sourceRoot
     ]
   ]);
   forEach(openrouterKey, (key) => {
     configObj["openrouterKeyValue"] = key;
   });
+  forEach(anthropicKey, (key) => {
+    configObj["anthropicKeyValue"] = key;
+  });
   let payload = JSON.stringify(configObj);
   let runtimeConfigScript = `<script>window.__frontmanRuntime=` + payload + `</script>`;
   return `<!DOCTYPE html>
@@ -5957,7 +6201,7 @@ function serveWithEntrypoint(config, entrypointUrl) {
     clientCssUrl: config.clientCssUrl,
     entrypointUrl,
     isLightTheme: config.isLightTheme,
-    frameworkLabel: config.frameworkLabel
+    frameworkId: config.frameworkId
   } : config);
 }
 
@@ -5966,80 +6210,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;
@@ -7649,6 +7819,102 @@ async function Te(o) {
   }
 }
 
+// ../frontman-protocol/src/FrontmanProtocol__Types.res.mjs
+enableJson2();
+var modelSelectionSchema = schema2((s2) => ({
+  provider: s2.m(string2),
+  value: s2.m(string2)
+}));
+
+// ../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 toolResultContentTypeSchema = union2([
+  literal2("text"),
+  literal2("image"),
+  literal2("resource")
+]);
+var toolResultContentSchema = schema2((s2) => ({
+  type: s2.m(toolResultContentTypeSchema),
+  text: s2.m(string2)
+}));
+schema2((s2) => ({
+  code: s2.m(int2),
+  message: s2.m(string2)
+}));
+var callToolResultMetaSchema = schema2((s2) => ({
+  model: s2.m(option2(modelSelectionSchema)),
+  envApiKey: s2.m(dict2(string2))
+}));
+var emptyMeta_envApiKey = {};
+var emptyMeta = {
+  model: void 0,
+  envApiKey: emptyMeta_envApiKey
+};
+var callToolResultSchema = schema2((s2) => ({
+  content: s2.m(array2(toolResultContentSchema)),
+  isError: s2.m(option2(bool2)),
+  _meta: s2.m(callToolResultMetaSchema)
+}));
+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),
@@ -7694,7 +7960,8 @@ async function executeTool(registry, ctx2, name15, $$arguments) {
             type: "text",
             text: result._0
           }],
-          isError: true
+          isError: true,
+          _meta: emptyMeta
         }
       };
     }
@@ -7706,7 +7973,8 @@ async function executeTool(registry, ctx2, name15, $$arguments) {
           type: "text",
           text: JSON.stringify(outputJson)
         }],
-        isError: void 0
+        isError: void 0,
+        _meta: emptyMeta
       }
     };
   } catch (raw_e) {
@@ -7734,7 +8002,8 @@ function resultToMCP(result) {
           type: "text",
           text: `Tool not found: ` + result._0
         }],
-        isError: true
+        isError: true,
+        _meta: emptyMeta
       };
     case "InvalidInput":
       return {
@@ -7742,7 +8011,8 @@ function resultToMCP(result) {
           type: "text",
           text: `Invalid input: ` + result._0
         }],
-        isError: true
+        isError: true,
+        _meta: emptyMeta
       };
     case "ExecutionError":
       return {
@@ -7750,7 +8020,8 @@ function resultToMCP(result) {
           type: "text",
           text: `Execution error: ` + result._0
         }],
-        isError: true
+        isError: true,
+        _meta: emptyMeta
       };
   }
 }
@@ -7839,7 +8110,8 @@ async function handleToolCall(registry, config, req) {
           let errorResult_isError2 = true;
           let errorResult2 = {
             content: errorResult_content2,
-            isError: errorResult_isError2
+            isError: errorResult_isError2,
+            _meta: emptyMeta
           };
           controller.enqueue(encoder.encode(errorEvent(errorResult2)));
           controller.close();
@@ -7858,7 +8130,8 @@ async function handleToolCall(registry, config, req) {
   let errorResult_isError = true;
   let errorResult = {
     content: errorResult_content,
-    isError: errorResult_isError
+    isError: errorResult_isError,
+    _meta: emptyMeta
   };
   let json3 = reverseConvertToJsonOrThrow2(errorResult, callToolResultSchema);
   return Response.json(json3, {
@@ -7966,19 +8239,19 @@ function isFrontmanRoute(pathname, basePath, method) {
 function getCanonicalRedirect(prefixPath, basePath) {
   let suffix = "/" + basePath;
   if (prefixPath === basePath) {
-    return "/" + basePath;
+    return "/" + basePath + "/";
   }
   if (prefixPath.endsWith(suffix)) {
     let stripped = prefixPath.slice(0, prefixPath.length - suffix.length | 0);
     let cleanPrefix = stripped === "" ? "" : stripped;
-    let tmp = cleanPrefix === "" ? "/" + basePath : "/" + cleanPrefix + "/" + basePath;
+    let tmp = cleanPrefix === "" ? "/" + basePath + "/" : "/" + cleanPrefix + "/" + basePath + "/";
     return tmp;
   }
   if (!prefixPath.startsWith(basePath + "/")) {
     return;
   }
-  let rest = prefixPath.slice(basePath.length + 1 | 0);
-  let tmp$1 = rest === "" ? "/" + basePath : "/" + rest + "/" + basePath;
+  let rest = prefixPath.slice(basePath.length + 1 | 0, prefixPath.length);
+  let tmp$1 = rest === "" ? "/" + basePath + "/" : "/" + rest + "/" + basePath + "/";
   return tmp$1;
 }
 function buildEntrypointUrl(config, requestUrl, prefixPath) {
@@ -7988,7 +8261,7 @@ function buildEntrypointUrl(config, requestUrl, prefixPath) {
   }
   let url2 = new URL(requestUrl);
   let origin = url2.origin;
-  let pagePath = prefixPath === "" ? "/" : "/" + prefixPath;
+  let pagePath = prefixPath === "" ? "/" : "/" + prefixPath + "/";
   return origin + pagePath;
 }
 function createMiddleware(config, registry) {
@@ -8077,7 +8350,7 @@ function toMiddlewareConfig(config) {
     clientCssUrl: config.clientCssUrl,
     entrypointUrl: config.entrypointUrl,
     isLightTheme: config.isLightTheme,
-    frameworkLabel: "Astro"
+    frameworkId: "Astro"
   };
 }
 function createMiddleware2(config) {
@@ -8086,7 +8359,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) {
@@ -8095,8 +8368,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);
@@ -8186,7 +8457,7 @@ function adaptToConnect(middleware, basePath) {
 
 // src/FrontmanAstro__Integration.res.mjs
 var annotationCaptureScript2 = annotationCaptureScript;
-var icon = `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><circle cx="12" cy="12" r="3"/></svg>`;
+var icon = `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="90 70 230 270" fill="none"><path d="M145.925 316.925C136.175 316.925 129.242 315.517 125.125 312.7C121.008 309.667 118.517 305.875 117.65 301.325C116.783 296.558 116.35 291.792 116.35 287.025V119C116.35 107.733 118.517 100.042 122.85 95.925C127.4 91.5917 135.417 89.425 146.9 89.425H265.85C270.833 89.425 275.492 89.8583 279.825 90.725C284.375 91.5917 288.058 94.0833 290.875 98.2C293.692 102.317 295.1 109.358 295.1 119.325C295.1 129.075 293.583 136.008 290.55 140.125C287.733 144.242 284.05 146.733 279.5 147.6C274.95 148.467 270.183 148.9 265.2 148.9H175.825V177.825H235.625C240.608 177.825 245.05 178.258 248.95 179.125C253.067 179.775 256.208 181.942 258.375 185.625C260.758 189.092 261.95 195.158 261.95 203.825C261.95 212.058 260.758 217.908 258.375 221.375C255.992 224.842 252.742 226.9 248.625 227.55C244.725 228.2 240.283 228.525 235.3 228.525H175.825V287.35C175.825 292.117 175.392 296.775 174.525 301.325C173.658 305.875 171.167 309.667 167.05 312.7C162.933 315.517 155.892 316.925 145.925 316.925Z" fill="currentColor"/></svg>`;
 function getToolbarAppPath() {
   return new URL("./toolbar.js", import.meta.url).pathname;
 }
@@ -8236,6 +8507,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");
         });