@frontman-ai/astro 0.2.3 → 0.2.4

package/dist/index.js

@@ -1,5 +1,5 @@
 import * as Web from 'stream/web';
-import * as Fs3 from 'fs';
+import * as Fs from 'fs';
 import { existsSync, readFileSync } from 'fs';
 import * as Nodepath from 'path';
 import { dirname, join } from 'path';
@@ -26,6 +26,11 @@ var require_lib = __commonJS({
   }
 });
 
+// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_JsError.js
+function panic(msg) {
+  throw new Error(`Panic! ` + msg);
+}
+
 // ../../node_modules/@rescript/runtime/lib/es6/Primitive_option.js
 function some(x) {
   if (x === void 0) {
@@ -67,6 +72,20 @@ function forEach(opt, f) {
     return f(valFromOption(opt));
   }
 }
+function getOrThrow(x, message3) {
+  if (x !== void 0) {
+    return valFromOption(x);
+  } else {
+    return panic("Option.getOrThrow called for None value");
+  }
+}
+function mapOr(opt, $$default, f) {
+  if (opt !== void 0) {
+    return f(valFromOption(opt));
+  } else {
+    return $$default;
+  }
+}
 function map(opt, f) {
   if (opt !== void 0) {
     return some(f(valFromOption(opt)));
@@ -94,6 +113,9 @@ function orElse(opt, other) {
 function isSome(x) {
   return x !== void 0;
 }
+function isNone(x) {
+  return x === void 0;
+}
 
 // ../frontman-core/src/FrontmanCore__Hosts.res.mjs
 var apiHost = "api.frontman.sh";
@@ -113,7 +135,8 @@ function makeFromObject(rawConfig) {
   let isDev = host2 !== apiHost;
   let projectRoot = getOr(orElse(config.projectRoot, orElse(process.env["PROJECT_ROOT"], process.env["PWD"])), ".");
   let sourceRoot = getOr(config.sourceRoot, projectRoot);
-  let basePath = getOr(config.basePath, "frontman");
+  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 isLightTheme = getOr(config.isLightTheme, false);
@@ -371,7 +394,57 @@ function renderComponent(result, displayName, Component, props, slots) {
   };
 }
 
+// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_Dict.js
+var forEachWithKey = ((dict3, f) => {
+  for (var i in dict3) {
+    f(dict3[i], i);
+  }
+});
+
+// ../frontman-core/src/FrontmanCore__CORS.res.mjs
+var corsHeaders = Object.fromEntries([
+  [
+    "Access-Control-Allow-Origin",
+    "*"
+  ],
+  [
+    "Access-Control-Allow-Methods",
+    "GET, POST, OPTIONS"
+  ],
+  [
+    "Access-Control-Allow-Headers",
+    "Content-Type"
+  ]
+]);
+function withCors(response) {
+  let headers2 = response.headers;
+  forEachWithKey(corsHeaders, (value, key) => {
+    headers2.set(key, value);
+  });
+  return response;
+}
+function handlePreflight() {
+  return new Response(null, {
+    status: 204,
+    headers: some(corsHeaders)
+  });
+}
+
 // ../../node_modules/@rescript/runtime/lib/es6/Primitive_int.js
+function min(x, y) {
+  if (x < y) {
+    return x;
+  } else {
+    return y;
+  }
+}
+function max(x, y) {
+  if (x > y) {
+    return x;
+  } else {
+    return y;
+  }
+}
 function div(x, y) {
   if (y === 0) {
     throw {
@@ -381,6 +454,15 @@ function div(x, y) {
   }
   return x / y | 0;
 }
+function mod_(x, y) {
+  if (y === 0) {
+    throw {
+      RE_EXN_ID: "Division_by_zero",
+      Error: new Error()
+    };
+  }
+  return x % y;
+}
 
 // ../../node_modules/@rescript/runtime/lib/es6/Primitive_exceptions.js
 function isExtension(e) {
@@ -415,22 +497,22 @@ function create(str) {
 // ../../node_modules/sury/src/Sury.res.mjs
 var immutableEmpty = {};
 var immutableEmpty$1 = [];
-function capitalize(string4) {
-  return string4.slice(0, 1).toUpperCase() + string4.slice(1);
+function capitalize(string3) {
+  return string3.slice(0, 1).toUpperCase() + string3.slice(1);
 }
 var copy = ((d2) => ({ ...d2 }));
-function fromString(string4) {
+function fromString(string3) {
   let _idx = 0;
   while (true) {
     let idx = _idx;
-    let match = string4[idx];
+    let match = string3[idx];
     if (match === void 0) {
-      return `"` + string4 + `"`;
+      return `"` + string3 + `"`;
     }
     switch (match) {
       case '"':
       case "\n":
-        return JSON.stringify(string4);
+        return JSON.stringify(string3);
       default:
         _idx = idx + 1 | 0;
         continue;
@@ -498,14 +580,14 @@ function stringify(unknown2) {
     return "null";
   }
   if (Array.isArray(unknown2)) {
-    let string4 = "[";
+    let string3 = "[";
     for (let i = 0, i_finish = unknown2.length; i < i_finish; ++i) {
       if (i !== 0) {
-        string4 = string4 + ", ";
+        string3 = string3 + ", ";
       }
-      string4 = string4 + stringify(unknown2[i]);
+      string3 = string3 + stringify(unknown2[i]);
     }
-    return string4 + "]";
+    return string3 + "]";
   }
   if (unknown2.constructor !== Object) {
     return Object.prototype.toString.call(unknown2);
@@ -522,9 +604,9 @@ function stringify(unknown2) {
 function toExpression(schema3) {
   let tag = schema3.type;
   let $$const = schema3.const;
-  let name11 = schema3.name;
-  if (name11 !== void 0) {
-    return name11;
+  let name14 = schema3.name;
+  if (name14 !== void 0) {
+    return name14;
   }
   if ($$const !== void 0) {
     return stringify($$const);
@@ -1069,8 +1151,8 @@ function refinement(b, inputVar, schema3, negative) {
   }
   let additionalItems = schema3.additionalItems;
   let items = schema3.items;
-  let length2 = items.length;
-  let code = tag === "array" ? additionalItems === "strip" || additionalItems === "strict" ? additionalItems === "strip" ? and_ + inputVar + `.length` + gt + length2 : and_ + inputVar + `.length` + eq + length2 : "" : additionalItems === "strip" ? "" : and_ + not_ + `Array.isArray(` + inputVar + `)`;
+  let length3 = items.length;
+  let code = tag === "array" ? additionalItems === "strip" || additionalItems === "strict" ? additionalItems === "strip" ? and_ + inputVar + `.length` + gt + length3 : and_ + inputVar + `.length` + eq + length3 : "" : additionalItems === "strip" ? "" : and_ + not_ + `Array.isArray(` + inputVar + `)`;
   for (let idx = 0, idx_finish = items.length; idx < idx_finish; ++idx) {
     let match$3 = items[idx];
     let location = match$3.location;
@@ -1644,10 +1726,10 @@ function isPriority(tagFlag, byKey) {
   }
 }
 function isWiderUnionSchema(schemaAnyOf, inputAnyOf) {
-  return inputAnyOf.every((inputSchema10, idx) => {
+  return inputAnyOf.every((inputSchema13, idx) => {
     let schema3 = schemaAnyOf[idx];
-    if (schema3 !== void 0 && !(flags[inputSchema10.type] & 9152) && inputSchema10.type === schema3.type) {
-      return inputSchema10.const === schema3.const;
+    if (schema3 !== void 0 && !(flags[inputSchema13.type] & 9152) && inputSchema13.type === schema3.type) {
+      return inputSchema13.const === schema3.const;
     } else {
       return false;
     }
@@ -2222,9 +2304,9 @@ function definitionToSchema(definition) {
     };
   }
   let fieldNames = Object.keys(definition);
-  let length2 = fieldNames.length;
+  let length3 = fieldNames.length;
   let items = [];
-  for (let idx$1 = 0; idx$1 < length2; ++idx$1) {
+  for (let idx$1 = 0; idx$1 < length3; ++idx$1) {
     let location$1 = fieldNames[idx$1];
     let schema$1 = definitionToSchema(definition[location$1]);
     let item = {
@@ -2294,9 +2376,9 @@ function internalToJSONSchema(schema3, defs) {
               jsonSchema.maxLength = match.length;
               return;
             case "Length":
-              let length2 = match.length;
-              jsonSchema.minLength = length2;
-              jsonSchema.maxLength = length2;
+              let length3 = match.length;
+              jsonSchema.minLength = length3;
+              jsonSchema.maxLength = length3;
               return;
             case "Pattern":
               jsonSchema.pattern = String(match.re);
@@ -2370,9 +2452,9 @@ function internalToJSONSchema(schema3, defs) {
               jsonSchema.maxItems = match.length;
               return;
             case "Length":
-              let length2 = match.length;
-              jsonSchema.maxItems = length2;
-              jsonSchema.minItems = length2;
+              let length3 = match.length;
+              jsonSchema.maxItems = length3;
+              jsonSchema.minItems = length3;
               return;
           }
         });
@@ -2514,46 +2596,6 @@ var reverseConvertToJsonOrThrow2 = reverseConvertToJsonOrThrow;
 var schema2 = schema;
 var toJSONSchema2 = toJSONSchema;
 
-// ../../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/Stdlib_JsExn.js
 function fromException(exn) {
   if (exn.RE_EXN_ID === "JsExn") {
@@ -2563,6 +2605,11 @@ function fromException(exn) {
 var getOrUndefined = ((fieldName) => (t) => t && typeof t[fieldName] === "string" ? t[fieldName] : void 0);
 var message2 = getOrUndefined("message");
 
+// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_Promise.js
+function $$catch(promise, callback) {
+  return promise.catch((err) => callback(internalToException(err)));
+}
+
 // ../frontman-protocol/src/FrontmanProtocol__MCP.res.mjs
 enableJson2();
 var capabilitiesSchema = schema2((s2) => ({
@@ -4247,6 +4294,24 @@ async function Te(o) {
 }
 
 // ../../node_modules/@rescript/runtime/lib/es6/Stdlib_Array.js
+function make2(length3, x) {
+  if (length3 <= 0) {
+    return [];
+  }
+  let arr = new Array(length3);
+  arr.fill(x);
+  return arr;
+}
+function fromInitializer(length3, f) {
+  if (length3 <= 0) {
+    return [];
+  }
+  let arr = new Array(length3);
+  for (let i = 0; i < length3; ++i) {
+    arr[i] = f(i);
+  }
+  return arr;
+}
 function reduce(arr, init, f) {
   return arr.reduce(f, init);
 }
@@ -4852,177 +4917,776 @@ LIMITATIONS:
 - Results limited to max_results (default 20)
 - Binary files are automatically skipped
 - Hidden files (starting with '.') are skipped by default`;
-var name3 = ToolNames.readFile;
-var inputSchema2 = schema2((s2) => ({
-  path: s2.m(string2),
-  offset: s2.m(option2(int2)),
-  limit: s2.m(option2(int2))
-}));
-var pathContextSchema = schema2((s2) => ({
-  sourceRoot: s2.m(string2),
-  resolvedPath: s2.m(string2),
-  relativePath: s2.m(string2)
-}));
-var outputSchema2 = schema2((s2) => ({
-  content: s2.m(string2),
-  totalLines: s2.m(int2),
-  hasMore: s2.m(bool2),
-  _context: s2.m(option2(pathContextSchema))
-}));
-async function execute2(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 {
-      TAG: "Error",
-      _0: formatError(err._0)
-    };
-  }
-  let result = err._0;
-  try {
-    let content = await Fs3.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;
+
+// ../frontman-core/src/FrontmanCore__FileTracker.res.mjs
+var readFiles = {
+  contents: /* @__PURE__ */ new Set()
+};
+function recordRead(resolvedPath) {
+  readFiles.contents.add(resolvedPath);
+}
+function assertReadBefore(resolvedPath) {
+  if (readFiles.contents.has(resolvedPath)) {
     return {
       TAG: "Ok",
-      _0: {
-        content: selectedContent,
-        totalLines,
-        hasMore,
-        _context: {
-          sourceRoot: result.sourceRoot,
-          resolvedPath: result.resolvedPath,
-          relativePath: result.relativePath
-        }
-      }
+      _0: void 0
     };
-  } catch (raw_exn) {
-    let exn = internalToException(raw_exn);
-    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
+  } else {
     return {
       TAG: "Error",
-      _0: `Failed to read file ` + input.path + `: ` + msg
+      _0: `File must be read before editing. Use read_file on "` + resolvedPath + `" first to see its current content.`
     };
   }
 }
-var description2 = `Reads a file from the filesystem.
-
-Parameters:
-- path (required): Path to file - either relative to source root or absolute (must be under source root)
-- offset (optional): Line number to start from (0-indexed, default: 0). Pass null or 0 to start from beginning.
-- 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.`;
+// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_String.js
+function indexOfOpt(s2, search) {
+  let index = s2.indexOf(search);
+  if (index !== -1) {
+    return index;
+  }
+}
 
-// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_Result.js
-function map3(opt, f) {
-  if (opt.TAG === "Ok") {
-    return {
-      TAG: "Ok",
-      _0: f(opt._0)
-    };
+// ../frontman-core/src/tools/FrontmanCore__Tool__EditFile__Matcher.res.mjs
+function levenshtein(a, b) {
+  let match = a.length;
+  let match$1 = b.length;
+  if (match === 0) {
+    return b.length;
+  }
+  if (match$1 === 0) {
+    return a.length;
+  }
+  let matrix = fromInitializer(match + 1 | 0, (i) => fromInitializer(match$1 + 1 | 0, (j2) => {
+    if (i !== 0) {
+      if (j2 !== 0) {
+        return 0;
+      } else {
+        return i;
+      }
+    } else {
+      return j2;
+    }
+  }));
+  for (let i = 1; i <= match; ++i) {
+    for (let j2 = 1; j2 <= match$1; ++j2) {
+      let cost = a.charAt(i - 1 | 0) === b.charAt(j2 - 1 | 0) ? 0 : 1;
+      let del = getOrThrow(matrix[i - 1 | 0])[j2] + 1 | 0;
+      let ins = getOrThrow(matrix[i])[j2 - 1 | 0] + 1 | 0;
+      let sub = getOrThrow(matrix[i - 1 | 0])[j2 - 1 | 0] + cost | 0;
+      getOrThrow(matrix[i])[j2] = min(del, min(ins, sub));
+    }
+  }
+  return getOrThrow(matrix[match])[match$1];
+}
+function lineOffset(lines, lineIndex) {
+  let offset = 0;
+  for (let k2 = 0; k2 < lineIndex; ++k2) {
+    offset = (offset + getOrThrow(lines[k2]).length | 0) + 1 | 0;
+  }
+  return offset;
+}
+function extractBlock(content, lines, startLine, endLine) {
+  let startIdx = lineOffset(lines, startLine);
+  let endIdx = lineOffset(lines, endLine) + getOrThrow(lines[endLine]).length | 0;
+  return content.slice(startIdx, endIdx);
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&");
+}
+function exactMatch(content, find) {
+  if (content.includes(find)) {
+    return [find];
   } else {
-    return opt;
+    return [];
   }
 }
-
-// ../frontman-core/src/tools/FrontmanCore__Tool__ListFiles.res.mjs
-var name4 = ToolNames.listFiles;
-var inputSchema3 = schema2((s2) => ({
-  path: s2.m(option2(string2))
-}));
-var fileEntrySchema = schema2((s2) => ({
-  name: s2.m(string2),
-  path: s2.m(string2),
-  isFile: s2.m(bool2),
-  isDirectory: s2.m(bool2)
-}));
-var outputSchema3 = array2(fileEntrySchema);
-async function getIgnoredEntries(cwd, entries) {
-  if (entries.length === 0) {
-    return {
-      TAG: "Ok",
-      _0: []
-    };
+function lineTrimMatch(content, find) {
+  let contentLines = content.split("\n");
+  let searchLines = find.split("\n");
+  let last = searchLines[searchLines.length - 1 | 0];
+  let searchLines$1 = last === "" ? searchLines.slice(0, searchLines.length - 1 | 0) : searchLines;
+  let searchLen = searchLines$1.length;
+  let results = [];
+  for (let i = 0, i_finish = contentLines.length - searchLen | 0; i <= i_finish; ++i) {
+    let matches2 = true;
+    let j2 = 0;
+    while (j2 < searchLen && matches2) {
+      let origTrimmed = getOrThrow(contentLines[i + j2 | 0]).trim();
+      let searchTrimmed = getOrThrow(searchLines$1[j2]).trim();
+      if (origTrimmed === searchTrimmed) {
+        j2 = j2 + 1 | 0;
+      } else {
+        matches2 = false;
+      }
+    }
+    if (matches2) {
+      results.push(extractBlock(content, contentLines, i, (i + searchLen | 0) - 1 | 0));
+    }
   }
-  try {
-    let entriesArg = entries.join("\n");
-    let command = `printf "%s" "` + entriesArg + `" | git check-ignore --stdin`;
-    let result = await execWithOptions(command, {
-      cwd
-    });
-    if (result.TAG === "Ok") {
-      return {
-        TAG: "Ok",
-        _0: result._0.stdout.trim().split("\n").filter((s2) => s2 !== "")
-      };
+  return results;
+}
+function anchoredBlockMatch(content, find) {
+  let contentLines = content.split("\n");
+  let searchLines = find.split("\n");
+  let last = searchLines[searchLines.length - 1 | 0];
+  let searchLines$1 = last === "" ? searchLines.slice(0, searchLines.length - 1 | 0) : searchLines;
+  if (searchLines$1.length < 3) {
+    return [];
+  }
+  let firstLineSearch = getOrThrow(searchLines$1[0]).trim();
+  let lastLineSearch = getOrThrow(searchLines$1[searchLines$1.length - 1 | 0]).trim();
+  let searchBlockSize = searchLines$1.length;
+  let candidates = [];
+  for (let i = 0, i_finish = contentLines.length; i < i_finish; ++i) {
+    if (getOrThrow(contentLines[i]).trim() === firstLineSearch) {
+      let j2 = i + 2 | 0;
+      while (j2 < contentLines.length) {
+        if (getOrThrow(contentLines[j2]).trim() === lastLineSearch) {
+          candidates.push({
+            startLine: i,
+            endLine: j2
+          });
+          j2 = j2 + 1 | 0;
+        } else {
+          j2 = j2 + 1 | 0;
+        }
+      }
     }
-    let match = result._0;
-    let match$1 = match.code;
-    let exit = 0;
-    if (match$1 !== void 0) {
-      if (match$1 === 1) {
-        return {
-          TAG: "Ok",
-          _0: []
-        };
+  }
+  let match = candidates.length;
+  if (match === 0) {
+    return [];
+  }
+  if (match !== 1) {
+    let bestMatch = {
+      contents: void 0
+    };
+    let maxSim = {
+      contents: -1
+    };
+    candidates.forEach((cand) => {
+      let startLine2 = cand.startLine;
+      let actualBlockSize2 = (cand.endLine - startLine2 | 0) + 1 | 0;
+      let linesToCheck2 = min(searchBlockSize - 2 | 0, actualBlockSize2 - 2 | 0);
+      let similarity2;
+      if (linesToCheck2 > 0) {
+        let sim = 0;
+        for (let j2 = 1, j_finish = min(searchBlockSize - 2 | 0, actualBlockSize2 - 2 | 0); j2 <= j_finish; ++j2) {
+          let origLine = getOrThrow(contentLines[startLine2 + j2 | 0]).trim();
+          let searchLine = getOrThrow(searchLines$1[j2]).trim();
+          let maxLen = max(origLine.length, searchLine.length);
+          if (maxLen > 0) {
+            let distance = levenshtein(origLine, searchLine);
+            sim = sim + (1 - distance / maxLen);
+          }
+        }
+        similarity2 = sim / linesToCheck2;
+      } else {
+        similarity2 = 1;
       }
-      if (match$1 === 128) {
-        return {
-          TAG: "Error",
-          _0: `Not a git repository: ` + match.stderr
-        };
+      if (similarity2 > maxSim.contents) {
+        maxSim.contents = similarity2;
+        bestMatch.contents = cand;
+        return;
+      }
+    });
+    let match$1 = maxSim.contents >= 0.3;
+    let match$2 = bestMatch.contents;
+    if (match$1) {
+      if (match$2 !== void 0) {
+        return [extractBlock(content, contentLines, match$2.startLine, match$2.endLine)];
+      } else {
+        return [];
       }
-      exit = 1;
     } else {
-      exit = 1;
+      return [];
     }
-    if (exit === 1) {
-      return {
-        TAG: "Error",
-        _0: `git check-ignore failed: ` + match.stderr
-      };
+  }
+  let match$3 = getOrThrow(candidates[0]);
+  let endLine = match$3.endLine;
+  let startLine = match$3.startLine;
+  let actualBlockSize = (endLine - startLine | 0) + 1 | 0;
+  let linesToCheck = min(searchBlockSize - 2 | 0, actualBlockSize - 2 | 0);
+  let similarity;
+  if (linesToCheck > 0) {
+    let sim = 0;
+    let j$1 = 1;
+    while (j$1 < (searchBlockSize - 1 | 0) && j$1 < (actualBlockSize - 1 | 0)) {
+      let origLine = getOrThrow(contentLines[startLine + j$1 | 0]).trim();
+      let searchLine = getOrThrow(searchLines$1[j$1]).trim();
+      let maxLen = max(origLine.length, searchLine.length);
+      if (maxLen > 0) {
+        let distance = levenshtein(origLine, searchLine);
+        sim = sim + (1 - distance / maxLen) / linesToCheck;
+      }
+      j$1 = sim >= 0 ? searchBlockSize : j$1 + 1 | 0;
     }
-  } catch (raw_exn) {
-    let exn = internalToException(raw_exn);
-    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
-    return {
-      TAG: "Error",
-      _0: `git check-ignore error: ` + msg
-    };
+    similarity = sim;
+  } else {
+    similarity = 1;
   }
-}
-async function execute3(ctx2, input) {
-  let path = getOr(input.path, ".");
-  let err = resolve2(ctx2.sourceRoot, path);
-  if (err.TAG !== "Ok") {
-    return {
-      TAG: "Error",
-      _0: formatError(err._0)
-    };
+  if (similarity >= 0) {
+    return [extractBlock(content, contentLines, startLine, endLine)];
+  } else {
+    return [];
   }
-  try {
-    let fullPath = err._0.resolvedPath;
-    let entries = await Fs3.promises.readdir(fullPath);
-    let filteredEntriesResult = map3(await getIgnoredEntries(fullPath, entries), (ignored) => entries.filter((name11) => !ignored.includes(name11)));
-    if (filteredEntriesResult.TAG !== "Ok") {
-      return {
-        TAG: "Error",
-        _0: filteredEntriesResult._0
-      };
+}
+function normalizedWhitespaceMatch(content, find) {
+  let normalize3 = (text) => text.replace(/\s+/g, " ").trim();
+  let normalizedFind = normalize3(find);
+  let contentLines = content.split("\n");
+  let results = [];
+  contentLines.forEach((line) => {
+    if (normalize3(line) === normalizedFind) {
+      results.push(line);
+      return;
     }
-    let entriesWithStats = await Promise.all(filteredEntriesResult._0.map(async (name11) => {
-      let entryPath = Nodepath.join(fullPath, name11);
-      let stats = await Fs3.promises.stat(entryPath);
-      return {
-        name: name11,
-        path: Nodepath.join(path, name11),
-        isFile: stats.isFile(),
+    let normalizedLine = normalize3(line);
+    if (!normalizedLine.includes(normalizedFind)) {
+      return;
+    }
+    let words = filterMap(find.trim().split(/\s+/), (x) => x);
+    if (words.length === 0) {
+      return;
+    }
+    let pattern2 = words.map(escapeRegex).join("\\s+");
+    try {
+      let regex = new RegExp(pattern2);
+      let result = line.match(regex);
+      if (result == null) {
+        return;
+      }
+      let m = result[0];
+      if (m.length > 0) {
+        results.push(m);
+        return;
+      } else {
+        return;
+      }
+    } catch (exn) {
+      return;
+    }
+  });
+  let findLines = find.split("\n");
+  if (findLines.length > 1) {
+    for (let i = 0, i_finish = contentLines.length - findLines.length | 0; i <= i_finish; ++i) {
+      let block = contentLines.slice(i, i + findLines.length | 0).join("\n");
+      if (normalize3(block) === normalizedFind) {
+        results.push(block);
+      }
+    }
+  }
+  return results;
+}
+function flexibleIndentMatch(content, find) {
+  let removeIndent = (text) => {
+    let lines = text.split("\n");
+    let nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+    let match = nonEmptyLines.length;
+    if (match === 0) {
+      return text;
+    }
+    let minIndent = reduce(nonEmptyLines, 999999, (acc, line) => {
+      let m = line.match(/^(\s*)/);
+      let indent = !(m == null) ? m[0].length : 0;
+      return min(acc, indent);
+    });
+    return lines.map((line) => {
+      let match2 = line.trim().length;
+      if (match2 !== 0) {
+        return line.slice(minIndent, line.length);
+      } else {
+        return line;
+      }
+    }).join("\n");
+  };
+  let normalizedFind = removeIndent(find);
+  let contentLines = content.split("\n");
+  let findLines = find.split("\n");
+  let results = [];
+  for (let i = 0, i_finish = contentLines.length - findLines.length | 0; i <= i_finish; ++i) {
+    let block = contentLines.slice(i, i + findLines.length | 0).join("\n");
+    if (removeIndent(block) === normalizedFind) {
+      results.push(block);
+    }
+  }
+  return results;
+}
+function escapeNormalizedMatch(content, find) {
+  let unescape = (function(str) {
+    return str.replace(/\\([ntr'"\\/$])/g, function(_m, c2) {
+      if (c2 === "n") return String.fromCharCode(10);
+      if (c2 === "t") return String.fromCharCode(9);
+      if (c2 === "r") return String.fromCharCode(13);
+      return c2;
+    });
+  });
+  let unescapedFind = unescape(find);
+  let results = [];
+  if (content.includes(unescapedFind)) {
+    results.push(unescapedFind);
+  }
+  let contentLines = content.split("\n");
+  let findLines = unescapedFind.split("\n");
+  for (let i = 0, i_finish = contentLines.length - findLines.length | 0; i <= i_finish; ++i) {
+    let block = contentLines.slice(i, i + findLines.length | 0).join("\n");
+    let unescapedBlock = unescape(block);
+    if (unescapedBlock === unescapedFind && !results.includes(block)) {
+      results.push(block);
+    }
+  }
+  return results;
+}
+function trimmedBoundaryMatch(content, find) {
+  let trimmedFind = find.trim();
+  if (trimmedFind === find) {
+    return [];
+  }
+  let results = [];
+  if (content.includes(trimmedFind)) {
+    results.push(trimmedFind);
+  }
+  let contentLines = content.split("\n");
+  let findLines = find.split("\n");
+  for (let i = 0, i_finish = contentLines.length - findLines.length | 0; i <= i_finish; ++i) {
+    let block = contentLines.slice(i, i + findLines.length | 0).join("\n");
+    if (block.trim() === trimmedFind && !results.includes(block)) {
+      results.push(block);
+    }
+  }
+  return results;
+}
+function contextAnchorMatch(content, find) {
+  let findLines = find.split("\n");
+  let last = findLines[findLines.length - 1 | 0];
+  let findLines$1 = last === "" ? findLines.slice(0, findLines.length - 1 | 0) : findLines;
+  if (findLines$1.length < 3) {
+    return [];
+  }
+  let contentLines = content.split("\n");
+  let firstLine = getOrThrow(findLines$1[0]).trim();
+  let lastLine = getOrThrow(findLines$1[findLines$1.length - 1 | 0]).trim();
+  let results = [];
+  for (let i = 0, i_finish = contentLines.length; i < i_finish; ++i) {
+    if (getOrThrow(contentLines[i]).trim() === firstLine) {
+      let j2 = i + 2 | 0;
+      while (j2 < contentLines.length) {
+        if (getOrThrow(contentLines[j2]).trim() === lastLine) {
+          let blockLines = contentLines.slice(i, j2 + 1 | 0);
+          if (blockLines.length === findLines$1.length) {
+            let matchingLines = 0;
+            let totalNonEmpty = 0;
+            for (let k2 = 1, k_finish = blockLines.length - 2 | 0; k2 <= k_finish; ++k2) {
+              let blockLine = getOrThrow(blockLines[k2]).trim();
+              let findLine = getOrThrow(findLines$1[k2]).trim();
+              let match = blockLine.length > 0;
+              let match$1 = findLine.length > 0;
+              let exit = 0;
+              if (match || match$1) {
+                exit = 1;
+              }
+              if (exit === 1) {
+                totalNonEmpty = totalNonEmpty + 1 | 0;
+                if (blockLine === findLine) {
+                  matchingLines = matchingLines + 1 | 0;
+                }
+              }
+            }
+            let total = totalNonEmpty;
+            let passes = total !== 0 ? matchingLines / total >= 0.5 : true;
+            if (passes) {
+              results.push(extractBlock(content, contentLines, i, j2));
+            }
+          }
+          j2 = j2 + 1 | 0;
+        } else {
+          j2 = j2 + 1 | 0;
+        }
+      }
+    }
+  }
+  return results;
+}
+function multiOccurrenceMatch(content, find) {
+  let results = [];
+  let startIndex = {
+    contents: 0
+  };
+  let continue_ = true;
+  while (continue_) {
+    let searchContent = content.slice(startIndex.contents, content.length);
+    let idx = map(indexOfOpt(searchContent, find), (i) => i + startIndex.contents | 0);
+    if (idx !== void 0) {
+      results.push(find);
+      startIndex.contents = idx + find.length | 0;
+    } else {
+      continue_ = false;
+    }
+  }
+  return results;
+}
+var strategies = [
+  exactMatch,
+  lineTrimMatch,
+  anchoredBlockMatch,
+  normalizedWhitespaceMatch,
+  flexibleIndentMatch,
+  escapeNormalizedMatch,
+  trimmedBoundaryMatch,
+  contextAnchorMatch,
+  multiOccurrenceMatch
+];
+function applyEdit(content, oldText, newText, replaceAllOpt) {
+  let replaceAll = replaceAllOpt !== void 0 ? replaceAllOpt : false;
+  let notFound = {
+    contents: true
+  };
+  let result = {
+    contents: void 0
+  };
+  let strategyIdx = 0;
+  while (isNone(result.contents) && strategyIdx < strategies.length) {
+    let strategy = getOrThrow(strategies[strategyIdx]);
+    let candidates = strategy(content, oldText);
+    let match = !replaceAll && candidates.length > 1;
+    if (match) {
+      notFound.contents = false;
+    } else if (replaceAll) {
+      candidates.forEach((candidate) => {
+        let match2 = result.contents;
+        if (match2 !== void 0) {
+          return;
+        }
+        let idx = content.indexOf(candidate);
+        if (idx >= 0) {
+          notFound.contents = false;
+          result.contents = {
+            TAG: "Applied",
+            _0: content.split(candidate).join(newText)
+          };
+          return;
+        }
+      });
+    } else {
+      let candidate = candidates[0];
+      if (candidate !== void 0) {
+        let idx = content.indexOf(candidate);
+        if (idx >= 0) {
+          notFound.contents = false;
+          let lastIdx = content.lastIndexOf(candidate);
+          if (idx === lastIdx) {
+            let before = content.slice(0, idx);
+            let after = content.slice(idx + candidate.length | 0, content.length);
+            result.contents = {
+              TAG: "Applied",
+              _0: before + newText + after
+            };
+          }
+        }
+      }
+    }
+    strategyIdx = strategyIdx + 1 | 0;
+  }
+  let r = result.contents;
+  if (r !== void 0) {
+    return r;
+  } else if (notFound.contents) {
+    return "NotFound";
+  } else {
+    return "Ambiguous";
+  }
+}
+
+// ../frontman-core/src/tools/FrontmanCore__Tool__EditFile.res.mjs
+var inputSchema2 = schema2((s2) => ({
+  path: s2.m(string2),
+  oldText: s2.m(string2),
+  newText: s2.m(string2),
+  replaceAll: s2.m(option2(bool2))
+}));
+var pathContextSchema = schema2((s2) => ({
+  sourceRoot: s2.m(string2),
+  resolvedPath: s2.m(string2),
+  relativePath: s2.m(string2)
+}));
+var outputSchema2 = schema2((s2) => ({
+  message: s2.m(string2),
+  _context: s2.m(option2(pathContextSchema))
+}));
+async function execute2(ctx2, input) {
+  let replaceAll = getOr(input.replaceAll, false);
+  if (input.oldText === input.newText) {
+    return {
+      TAG: "Error",
+      _0: "oldText and newText must be different"
+    };
+  }
+  let err = resolve2(ctx2.sourceRoot, input.path);
+  if (err.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _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
+      };
+    }
+  } 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
+      };
+    }
+  }
+}
+var name3 = "edit_file";
+var description2 = `Edits a file by replacing text using fuzzy matching.
+
+Parameters:
+- path (required): Path to file - either relative to source root or absolute (must be under source root)
+- oldText (required): The text to find and replace. An empty oldText creates a new file with newText as content.
+- newText (required): The replacement text (must differ from oldText)
+- replaceAll (optional): If true, replaces all occurrences. Default: false.
+
+The tool uses multiple matching strategies (exact, line-trimmed, whitespace-normalized,
+indentation-flexible, etc.) to handle common formatting differences.
+
+IMPORTANT: You must read_file before editing. The tool will reject edits on unread files.`;
+var name4 = ToolNames.readFile;
+var inputSchema3 = 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 outputSchema3 = schema2((s2) => ({
+  content: s2.m(string2),
+  totalLines: s2.m(int2),
+  hasMore: s2.m(bool2),
+  _context: s2.m(option2(pathContextSchema2))
+}));
+async function execute3(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 {
+      TAG: "Error",
+      _0: formatError(err._0)
+    };
+  }
+  let result = err._0;
+  try {
+    let content = await Fs.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);
+    return {
+      TAG: "Ok",
+      _0: {
+        content: selectedContent,
+        totalLines,
+        hasMore,
+        _context: {
+          sourceRoot: result.sourceRoot,
+          resolvedPath: result.resolvedPath,
+          relativePath: result.relativePath
+        }
+      }
+    };
+  } catch (raw_exn) {
+    let exn = internalToException(raw_exn);
+    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
+    return {
+      TAG: "Error",
+      _0: `Failed to read file ` + input.path + `: ` + msg
+    };
+  }
+}
+var description3 = `Reads a file from the filesystem.
+
+Parameters:
+- path (required): Path to file - either relative to source root or absolute (must be under source root)
+- offset (optional): Line number to start from (0-indexed, default: 0). Pass null or 0 to start from beginning.
+- 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.`;
+
+// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_Result.js
+function map3(opt, f) {
+  if (opt.TAG === "Ok") {
+    return {
+      TAG: "Ok",
+      _0: f(opt._0)
+    };
+  } else {
+    return opt;
+  }
+}
+
+// ../frontman-core/src/tools/FrontmanCore__Tool__ListFiles.res.mjs
+var name5 = ToolNames.listFiles;
+var inputSchema4 = schema2((s2) => ({
+  path: s2.m(option2(string2))
+}));
+var fileEntrySchema = schema2((s2) => ({
+  name: s2.m(string2),
+  path: s2.m(string2),
+  isFile: s2.m(bool2),
+  isDirectory: s2.m(bool2)
+}));
+var outputSchema4 = array2(fileEntrySchema);
+async function getIgnoredEntries(cwd, entries) {
+  if (entries.length === 0) {
+    return {
+      TAG: "Ok",
+      _0: []
+    };
+  }
+  try {
+    let entriesArg = entries.join("\n");
+    let command = `printf "%s" "` + entriesArg + `" | git check-ignore --stdin`;
+    let result = await execWithOptions(command, {
+      cwd
+    });
+    if (result.TAG === "Ok") {
+      return {
+        TAG: "Ok",
+        _0: result._0.stdout.trim().split("\n").filter((s2) => s2 !== "")
+      };
+    }
+    let match = result._0;
+    let match$1 = match.code;
+    let exit = 0;
+    if (match$1 !== void 0) {
+      if (match$1 === 1) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      }
+      if (match$1 === 128) {
+        return {
+          TAG: "Error",
+          _0: `Not a git repository: ` + match.stderr
+        };
+      }
+      exit = 1;
+    } else {
+      exit = 1;
+    }
+    if (exit === 1) {
+      return {
+        TAG: "Error",
+        _0: `git check-ignore failed: ` + match.stderr
+      };
+    }
+  } catch (raw_exn) {
+    let exn = internalToException(raw_exn);
+    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
+    return {
+      TAG: "Error",
+      _0: `git check-ignore error: ` + msg
+    };
+  }
+}
+async function execute4(ctx2, input) {
+  let path = getOr(input.path, ".");
+  let err = resolve2(ctx2.sourceRoot, path);
+  if (err.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: formatError(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)));
+    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);
+      return {
+        name: name14,
+        path: Nodepath.join(path, name14),
+        isFile: stats.isFile(),
         isDirectory: stats.isDirectory()
       };
     }));
@@ -5039,35 +5703,35 @@ async function execute3(ctx2, input) {
     };
   }
 }
-var description3 = `Lists files and directories in a given path.
+var description4 = `Lists files and directories in a given path.
 
 Parameters:
 - path (optional): Path to directory - either relative to source root or absolute (must be under source root). Defaults to "." (root directory).
 
 Returns array of entries with name, path, and type information.`;
-var name5 = ToolNames.writeFile;
-var inputSchema4 = schema2((s2) => ({
+var name6 = ToolNames.writeFile;
+var inputSchema5 = schema2((s2) => ({
   path: s2.m(string2),
   content: s2.m(option2(string2)),
   image_ref: s2.m(option2(string2)),
   encoding: s2.m(option2(literal2("base64")))
 }));
-var pathContextSchema2 = schema2((s2) => ({
+var pathContextSchema3 = schema2((s2) => ({
   sourceRoot: s2.m(string2),
   resolvedPath: s2.m(string2),
   relativePath: s2.m(string2)
 }));
-var outputSchema4 = schema2((s2) => ({
-  _context: s2.m(option2(pathContextSchema2))
+var outputSchema5 = schema2((s2) => ({
+  _context: s2.m(option2(pathContextSchema3))
 }));
 function writeContent(resolvedPath, content, encoding) {
   if (encoding === void 0) {
-    return Fs3.promises.writeFile(resolvedPath, content, "utf8");
+    return Fs.promises.writeFile(resolvedPath, content, "utf8");
   }
   let buffer = Nodebuffer.Buffer.from(content, "base64");
-  return Fs3.promises.writeFile(resolvedPath, buffer);
+  return Fs.promises.writeFile(resolvedPath, buffer);
 }
-async function execute4(ctx2, input) {
+async function execute5(ctx2, input) {
   let match = input.content;
   let match$1 = input.image_ref;
   if (match === void 0) {
@@ -5098,7 +5762,7 @@ async function execute4(ctx2, input) {
   }
   let result = err._0;
   try {
-    await Fs3.promises.mkdir(dirname3(result), {
+    await Fs.promises.mkdir(dirname3(result), {
       recursive: true
     });
     await writeContent(result.resolvedPath, match, input.encoding);
@@ -5121,7 +5785,7 @@ async function execute4(ctx2, input) {
     };
   }
 }
-var description4 = `Writes content to a file.
+var description5 = `Writes content to a file.
 
 Parameters:
 - path (required): Path to file - either relative to source root or absolute (must be under source root)
@@ -5132,11 +5796,11 @@ 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 name6 = ToolNames.fileExists;
-var inputSchema5 = schema2((s2) => ({
+var name7 = ToolNames.fileExists;
+var inputSchema6 = schema2((s2) => ({
   path: s2.m(string2)
 }));
-async function execute5(ctx2, input) {
+async function execute6(ctx2, input) {
   let msg = resolve(ctx2.sourceRoot, input.path);
   if (msg.TAG !== "Ok") {
     return {
@@ -5145,7 +5809,7 @@ async function execute5(ctx2, input) {
     };
   }
   try {
-    await Fs3.promises.access(toString(msg._0));
+    await Fs.promises.access(toString(msg._0));
     return {
       TAG: "Ok",
       _0: true
@@ -5157,13 +5821,13 @@ async function execute5(ctx2, input) {
     };
   }
 }
-var description5 = `Checks if a file or directory exists.
+var description6 = `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 outputSchema5 = bool2;
+var outputSchema6 = bool2;
 
 // ../bindings/src/Lighthouse.res.mjs
 var run = ((url2, flags2) => import('module').then(({ createRequire }) => {
@@ -5205,8 +5869,8 @@ async function killSafely(chrome) {
 }
 
 // ../frontman-core/src/tools/FrontmanCore__Tool__Lighthouse.res.mjs
-var name7 = ToolNames.lighthouse;
-var inputSchema6 = schema2((s2) => ({
+var name8 = ToolNames.lighthouse;
+var inputSchema7 = schema2((s2) => ({
   url: s2.m(string2),
   preset: s2.m(option2(string2))
 }));
@@ -5223,7 +5887,7 @@ var categoryResultSchema = schema2((s2) => ({
   score: s2.m(int2),
   topIssues: s2.m(array2(auditIssueSchema))
 }));
-var outputSchema6 = schema2((s2) => ({
+var outputSchema7 = schema2((s2) => ({
   url: s2.m(string2),
   fetchTime: s2.m(string2),
   categories: s2.m(array2(categoryResultSchema)),
@@ -5323,7 +5987,7 @@ async function runLighthouse(chrome, url2, preset) {
     };
   }
 }
-async function execute6(_ctx, input) {
+async function execute7(_ctx, input) {
   let preset = getOr(input.preset, "desktop");
   switch (preset) {
     case "desktop":
@@ -5354,7 +6018,7 @@ async function execute6(_ctx, input) {
     };
   }
 }
-var description6 = `Runs a Lighthouse audit on a URL to analyze performance, accessibility, best practices, and SEO.
+var description7 = `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
@@ -5376,13 +6040,13 @@ LIMITATIONS:
 - 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 name8 = ToolNames.searchFiles;
-var inputSchema7 = schema2((s2) => ({
+var name9 = ToolNames.searchFiles;
+var inputSchema8 = schema2((s2) => ({
   pattern: s2.m(string2),
   path: s2.m(option2(string2)),
   max_results: s2.m(option2(int2))
 }));
-var outputSchema7 = schema2((s2) => ({
+var outputSchema8 = schema2((s2) => ({
   files: s2.m(array2(string2)),
   totalResults: s2.m(int2),
   truncated: s2.m(bool2)
@@ -5496,7 +6160,7 @@ async function executeGitLsFiles(pattern2, searchPath, maxResults) {
     _0: `Git ls-files failed: ` + match.stderr
   };
 }
-async function execute7(ctx2, input) {
+async function execute8(ctx2, input) {
   let searchPath = resolveSearchPath(ctx2.sourceRoot, input.path);
   let maxResults = getOr(input.max_results, 20);
   let rgPath = getRipgrepPath2();
@@ -5510,7 +6174,7 @@ async function execute7(ctx2, input) {
     return await executeGitLsFiles(input.pattern, searchPath, maxResults);
   }
 }
-var description7 = `Fast file name search tool that finds files matching a pattern.
+var description8 = `Fast file name search tool that finds files matching a pattern.
 
 WHEN TO USE THIS TOOL:
 - Use when you need to find files by name pattern
@@ -5538,15 +6202,15 @@ LIMITATIONS:
 - Hidden files (starting with '.') are included
 - Respects .gitignore when using git ls-files fallback
 - Only finds files, not directories`;
-var name9 = ToolNames.loadAgentInstructions;
-var inputSchema8 = schema2((s2) => ({
+var name10 = ToolNames.loadAgentInstructions;
+var inputSchema9 = schema2((s2) => ({
   startPath: s2.m(option2(string2))
 }));
 var instructionFileSchema = schema2((s2) => ({
   content: s2.m(string2),
   fullPath: s2.m(string2)
 }));
-var outputSchema8 = array2(instructionFileSchema);
+var outputSchema9 = array2(instructionFileSchema);
 var agentsVariants = [
   "Agents.md",
   ".claude/Agents.md",
@@ -5559,7 +6223,7 @@ var claudeVariants = [
 ];
 async function findFileCaseInsensitive(dir, targetFileName) {
   try {
-    let files = await Fs3.promises.readdir(dir);
+    let files = await Fs.promises.readdir(dir);
     let targetLower = targetFileName.toLowerCase();
     let found = files.find((file) => file.toLowerCase() === targetLower);
     if (found !== void 0) {
@@ -5579,7 +6243,7 @@ async function loadIfExists(path) {
     return;
   }
   try {
-    let content = await Fs3.promises.readFile(actualPath, "utf8");
+    let content = await Fs.promises.readFile(actualPath, "utf8");
     return {
       content,
       fullPath: actualPath
@@ -5616,7 +6280,7 @@ async function walkUpDirectories(current, acc) {
   let newAcc = acc.concat(filesAtLevel);
   return await walkUpDirectories(Nodepath.dirname(current), newAcc);
 }
-async function execute8(ctx2, input) {
+async function execute9(ctx2, input) {
   let inputPath = getOr(input.startPath, ".");
   let msg = resolve(ctx2.sourceRoot, inputPath);
   if (msg.TAG !== "Ok") {
@@ -5641,7 +6305,7 @@ async function execute8(ctx2, input) {
     };
   }
 }
-var description8 = `Discovers and loads agent instruction files (Agents.md or CLAUDE.md) following Claude Code's discovery algorithm.
+var description9 = `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).
@@ -5658,22 +6322,6 @@ Discovery:
 function coreTools() {
   return {
     tools: [
-      {
-        name: name3,
-        description: description2,
-        inputSchema: inputSchema2,
-        outputSchema: outputSchema2,
-        execute: execute2,
-        visibleToAgent: true
-      },
-      {
-        name: name5,
-        description: description4,
-        inputSchema: inputSchema4,
-        outputSchema: outputSchema4,
-        execute: execute4,
-        visibleToAgent: true
-      },
       {
         name: name4,
         description: description3,
@@ -5691,11 +6339,27 @@ function coreTools() {
         visibleToAgent: true
       },
       {
-        name: name9,
-        description: description8,
-        inputSchema: inputSchema8,
-        outputSchema: outputSchema8,
-        execute: execute8,
+        name: name5,
+        description: description4,
+        inputSchema: inputSchema4,
+        outputSchema: outputSchema4,
+        execute: execute4,
+        visibleToAgent: true
+      },
+      {
+        name: name7,
+        description: description6,
+        inputSchema: inputSchema6,
+        outputSchema: outputSchema6,
+        execute: execute6,
+        visibleToAgent: true
+      },
+      {
+        name: name10,
+        description: description9,
+        inputSchema: inputSchema9,
+        outputSchema: outputSchema9,
+        execute: execute9,
         visibleToAgent: false
       },
       {
@@ -5706,6 +6370,14 @@ function coreTools() {
         execute,
         visibleToAgent: true
       },
+      {
+        name: name9,
+        description: description8,
+        inputSchema: inputSchema8,
+        outputSchema: outputSchema8,
+        execute: execute8,
+        visibleToAgent: true
+      },
       {
         name: name8,
         description: description7,
@@ -5715,11 +6387,11 @@ function coreTools() {
         visibleToAgent: true
       },
       {
-        name: name7,
-        description: description6,
-        inputSchema: inputSchema6,
-        outputSchema: outputSchema6,
-        execute: execute6,
+        name: name3,
+        description: description2,
+        inputSchema: inputSchema2,
+        outputSchema: outputSchema2,
+        execute: execute2,
         visibleToAgent: true
       }
     ]
@@ -5730,8 +6402,19 @@ function addTools(registry, newTools) {
     tools: registry.tools.concat(newTools)
   };
 }
-function getToolByName(registry, name11) {
-  return registry.tools.find((m) => m.name === name11);
+function replaceByName(registry, replacement) {
+  return {
+    tools: registry.tools.map((m) => {
+      if (m.name === replacement.name) {
+        return replacement;
+      } else {
+        return m;
+      }
+    })
+  };
+}
+function getToolByName(registry, name14) {
+  return registry.tools.find((m) => m.name === name14);
 }
 function serializeTool(m) {
   return {
@@ -5764,12 +6447,12 @@ var toolCallRequestSchema = schema2((s2) => ({
 var protocolVersion = "1.0";
 
 // ../frontman-core/src/FrontmanCore__Server.res.mjs
-async function executeTool(registry, ctx2, name11, $$arguments) {
-  let toolModule = getToolByName(registry, name11);
+async function executeTool(registry, ctx2, name14, $$arguments) {
+  let toolModule = getToolByName(registry, name14);
   if (toolModule === void 0) {
     return {
       TAG: "ToolNotFound",
-      _0: name11
+      _0: name14
     };
   }
   let toolCtx_projectRoot = ctx2.projectRoot;
@@ -5861,7 +6544,23 @@ function getToolsResponse(registry, serverName, serverVersion) {
   };
 }
 
-// src/FrontmanAstro__Server.res.mjs
+// ../frontman-core/src/FrontmanCore__RequestHandlers.res.mjs
+var resolveSourceLocationRequestSchema = schema2((s2) => ({
+  componentName: s2.m(string2),
+  file: s2.m(string2),
+  line: s2.m(int2),
+  column: s2.m(int2)
+}));
+var resolveSourceLocationResponseSchema = schema2((s2) => ({
+  componentName: s2.m(string2),
+  file: s2.m(string2),
+  line: s2.m(int2),
+  column: s2.m(int2)
+}));
+var errorResponseSchema = schema2((s2) => ({
+  error: s2.m(string2),
+  details: s2.m(option2(string2))
+}));
 function handleGetTools(registry, config) {
   let response = getToolsResponse(registry, config.serverName, config.serverVersion);
   let json3 = reverseConvertToJsonOrThrow2(response, toolsResponseSchema);
@@ -5903,13 +6602,27 @@ async function handleToolCall(registry, config, req) {
     let encoder = new TextEncoder();
     let stream = new Web.ReadableStream({
       start: (controller) => {
-        resultPromise.then((result) => {
+        $$catch(resultPromise.then((result) => {
           let mcpResult = resultToMCP(result);
           let match = mcpResult.isError;
           let eventData = match !== void 0 && match ? errorEvent(mcpResult) : resultEvent(mcpResult);
           controller.enqueue(encoder.encode(eventData));
           controller.close();
           return Promise.resolve();
+        }), (error) => {
+          let msg = getOr(flatMap(fromException(error), message2), "Unknown error");
+          let errorResult_content2 = [{
+            type: "text",
+            text: `Tool execution failed: ` + msg
+          }];
+          let errorResult_isError2 = true;
+          let errorResult2 = {
+            content: errorResult_content2,
+            isError: errorResult_isError2
+          };
+          controller.enqueue(encoder.encode(errorEvent(errorResult2)));
+          controller.close();
+          return Promise.resolve();
         });
       }
     });
@@ -5931,113 +6644,582 @@ async function handleToolCall(registry, config, req) {
     status: 400
   });
 }
-function corsHeaders() {
-  return Object.fromEntries([
-    [
-      "Access-Control-Allow-Origin",
-      "*"
-    ],
-    [
-      "Access-Control-Allow-Methods",
-      "GET, POST, OPTIONS"
-    ],
-    [
-      "Access-Control-Allow-Headers",
-      "Content-Type"
-    ]
-  ]);
-}
-function handleCORS() {
-  return new Response(null, {
-    status: 204,
-    headers: some(corsHeaders())
-  });
-}
-async function handleResolveSourceLocation(config, req) {
+async function handleResolveSourceLocation(sourceRoot, req) {
   let body = await req.json();
-  let requestObj = Decode.object(body);
-  if (requestObj === void 0) {
-    return Response.json(Object.fromEntries([[
-      "error",
-      "Invalid request body"
-    ]]), {
-      status: 400
-    });
+  let request;
+  try {
+    request = {
+      TAG: "Ok",
+      _0: parseOrThrow2(body, resolveSourceLocationRequestSchema)
+    };
+  } catch (raw_e) {
+    let e = internalToException(raw_e);
+    if (e.RE_EXN_ID === $$Error2) {
+      request = {
+        TAG: "Error",
+        _0: e._1.message
+      };
+    } else {
+      throw e;
+    }
   }
-  let componentName = flatMap(requestObj["componentName"], Decode.string);
-  let file = flatMap(requestObj["file"], Decode.string);
-  let line = flatMap(requestObj["line"], Decode.float);
-  let column = flatMap(requestObj["column"], Decode.float);
-  if (componentName !== void 0 && file !== void 0 && line !== void 0 && column !== void 0) {
+  if (request.TAG === "Ok") {
+    let request$1 = request._0;
     try {
-      let sourceLocation_line = line | 0;
-      let sourceLocation_column = column | 0;
+      let sourceLocation_componentName = request$1.componentName;
+      let sourceLocation_file = request$1.file;
+      let sourceLocation_line = request$1.line;
+      let sourceLocation_column = request$1.column;
       let sourceLocation = {
-        componentName,
-        file,
+        componentName: sourceLocation_componentName,
+        file: sourceLocation_file,
         line: sourceLocation_line,
         column: sourceLocation_column,
         componentProps: void 0,
         parent: void 0
       };
       let resolved = await Te(sourceLocation);
-      let relativeFile = toRelativePath(config.sourceRoot, resolved.file);
-      let responseJson = Object.fromEntries([
-        [
-          "componentName",
-          resolved.componentName
-        ],
-        [
-          "file",
-          relativeFile
-        ],
-        [
-          "line",
-          resolved.line
-        ],
-        [
-          "column",
-          resolved.column
-        ]
-      ]);
+      let relativeFile = toRelativePath(sourceRoot, resolved.file);
+      let responseJson_componentName = resolved.componentName;
+      let responseJson_line = resolved.line;
+      let responseJson_column = resolved.column;
+      let responseJson = {
+        componentName: responseJson_componentName,
+        file: relativeFile,
+        line: responseJson_line,
+        column: responseJson_column
+      };
+      let json3 = reverseConvertToJsonOrThrow2(responseJson, resolveSourceLocationResponseSchema);
       let headers2 = Object.fromEntries([[
         "Content-Type",
         "application/json"
       ]]);
-      return Response.json(responseJson, {
+      return Response.json(json3, {
         headers: some(headers2)
       });
     } catch (raw_exn) {
       let exn = internalToException(raw_exn);
       let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
-      return Response.json(Object.fromEntries([
+      let json$1 = reverseConvertToJsonOrThrow2({
+        error: "Failed to resolve source location",
+        details: msg
+      }, errorResponseSchema);
+      return Response.json(json$1, {
+        status: 500
+      });
+    }
+  } else {
+    let json$2 = reverseConvertToJsonOrThrow2({
+      error: `Invalid request: ` + request._0,
+      details: void 0
+    }, errorResponseSchema);
+    return Response.json(json$2, {
+      status: 400
+    });
+  }
+}
+
+// src/FrontmanAstro__Server.res.mjs
+function toHandlerConfig(config) {
+  return {
+    projectRoot: config.projectRoot,
+    sourceRoot: config.sourceRoot,
+    serverName: config.serverName,
+    serverVersion: config.serverVersion
+  };
+}
+function handleGetTools2(registry, config) {
+  return handleGetTools(registry, toHandlerConfig(config));
+}
+async function handleToolCall2(registry, config, req) {
+  return await handleToolCall(registry, toHandlerConfig(config), req);
+}
+async function handleResolveSourceLocation2(config, req) {
+  return await handleResolveSourceLocation(config.sourceRoot, req);
+}
+
+// ../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) => {
+    if (key !== "") {
+      return key;
+    }
+  });
+  let configObj = Object.fromEntries([[
+    "framework",
+    config.frameworkLabel
+  ]]);
+  forEach(openrouterKey, (key) => {
+    configObj["openrouterKeyValue"] = key;
+  });
+  let payload = JSON.stringify(configObj);
+  let runtimeConfigScript = `<script>window.__frontmanRuntime=` + payload + `</script>`;
+  return `<!DOCTYPE html>
+<html lang="en" class="` + themeClass + `">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Frontman</title>
+    ` + entrypointTemplate + `
+    ` + clientCssTag + `
+    <style>
+      html, body, #root {
+        margin: 0;
+        padding: 0;
+        height: 100%;
+        width: 100%;
+      }
+    </style>
+</head>
+<body>
+    <div id="root"></div>
+    ` + runtimeConfigScript + `
+    <script>if(typeof process==="undefined"){window.process={env:{NODE_ENV:"production"}}}</script>
+    <script type="module" src="` + config.clientUrl + `"></script>
+</body>
+</html>`;
+}
+function serve(config) {
+  let html = generateHTML(config);
+  let headers2 = Object.fromEntries([[
+    "Content-Type",
+    "text/html"
+  ]]);
+  return new Response(html, {
+    headers: some(headers2)
+  });
+}
+
+// ../frontman-core/src/FrontmanCore__CircularBuffer.res.mjs
+function make3(capacity) {
+  return {
+    data: make2(capacity, void 0),
+    writeIndex: 0,
+    count: 0,
+    maxSize: capacity
+  };
+}
+function push(buffer, entry) {
+  buffer.data[buffer.writeIndex] = some(entry);
+  return {
+    data: buffer.data,
+    writeIndex: mod_(buffer.writeIndex + 1 | 0, buffer.maxSize),
+    count: min(buffer.count + 1 | 0, buffer.maxSize),
+    maxSize: buffer.maxSize
+  };
+}
+function toArray3(buffer) {
+  let c2 = buffer.count;
+  if (c2 === 0) {
+    return [];
+  }
+  if (c2 < buffer.maxSize) {
+    return filterMap(buffer.data.slice(0, buffer.count), (x) => x);
+  }
+  let tail = filterMap(buffer.data.slice(buffer.writeIndex, buffer.maxSize), (x) => x);
+  let head = filterMap(buffer.data.slice(0, buffer.writeIndex), (x) => x);
+  return tail.concat(head);
+}
+function length2(buffer) {
+  return buffer.count;
+}
+
+// ../frontman-core/src/FrontmanCore__LogCapture.res.mjs
+enableJson2();
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+function getPatchedFlag() {
+  return globalThis.__FRONTMAN_CORE_CONSOLE_PATCHED__;
+}
+function setPatchedFlag(_value) {
+  globalThis.__FRONTMAN_CORE_CONSOLE_PATCHED__ = _value;
+}
+var logLevelSchema = union2([
+  literal2("console"),
+  literal2("build"),
+  literal2("error")
+]);
+var consoleMethodSchema = union2([
+  literal2("log"),
+  literal2("info"),
+  literal2("warn"),
+  literal2("error"),
+  literal2("debug")
+]);
+var logEntrySchema = schema2((s2) => ({
+  timestamp: s2.m(string2),
+  level: s2.m(logLevelSchema),
+  message: s2.m(string2),
+  attributes: s2.m(option2(json2)),
+  resource: s2.m(option2(json2)),
+  consoleMethod: s2.m(option2(consoleMethodSchema))
+}));
+var defaultConfig_stdoutPatterns = [
+  "webpack",
+  "turbopack",
+  "Compiled",
+  "Failed",
+  "vite",
+  "hmr",
+  "error",
+  "Error",
+  "astro",
+  "build"
+];
+var defaultConfig = {
+  bufferCapacity: 1024,
+  stdoutPatterns: defaultConfig_stdoutPatterns
+};
+function getGlobalInstanceOpt() {
+  return globalThis.__FRONTMAN_CORE_INSTANCE__;
+}
+function setGlobalInstance(_state) {
+  globalThis.__FRONTMAN_CORE_INSTANCE__ = _state;
+}
+function getOrCreateInstance(config) {
+  let state = getGlobalInstanceOpt();
+  if (state !== void 0) {
+    return state;
+  }
+  let state_buffer = {
+    contents: make3(config.bufferCapacity)
+  };
+  let state$1 = {
+    buffer: state_buffer,
+    config
+  };
+  setGlobalInstance(state$1);
+  return state$1;
+}
+function getInstance() {
+  let state = getGlobalInstanceOpt();
+  if (state !== void 0) {
+    return state;
+  } else {
+    return getOrCreateInstance(defaultConfig);
+  }
+}
+function argsToString(args) {
+  return args.map((arg) => {
+    let match = typeof arg;
+    if (match === "string") {
+      return arg;
+    } else if (match === "object") {
+      if (arg instanceof Error) {
+        return getOr(arg.stack, arg.message);
+      } else {
+        return getOr(JSON.stringify(arg), "null");
+      }
+    } else {
+      return String(arg);
+    }
+  }).join(" ");
+}
+function stripAnsi(str) {
+  return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
+}
+function addLog(state, level, message3, attributes, consoleMethod) {
+  let cleanMessage = stripAnsi(message3).trim();
+  if (cleanMessage === "") {
+    return;
+  }
+  let entry_timestamp = new Date(Date.now()).toISOString();
+  let entry = {
+    timestamp: entry_timestamp,
+    level,
+    message: cleanMessage,
+    attributes,
+    resource: void 0,
+    consoleMethod
+  };
+  state.buffer.contents = push(state.buffer.contents, entry);
+}
+function handleConsoleLog(state, args) {
+  try {
+    return addLog(state, "console", argsToString(args), void 0, "log");
+  } catch (exn) {
+    return;
+  }
+}
+function handleConsoleWarn(state, args) {
+  try {
+    return addLog(state, "console", argsToString(args), void 0, "warn");
+  } catch (exn) {
+    return;
+  }
+}
+function handleConsoleError(state, args) {
+  try {
+    return addLog(state, "console", argsToString(args), void 0, "error");
+  } catch (exn) {
+    return;
+  }
+}
+function handleConsoleInfo(state, args) {
+  try {
+    return addLog(state, "console", argsToString(args), void 0, "info");
+  } catch (exn) {
+    return;
+  }
+}
+function handleConsoleDebug(state, args) {
+  try {
+    return addLog(state, "console", argsToString(args), void 0, "debug");
+  } catch (exn) {
+    return;
+  }
+}
+var interceptConsole = (function(state) {
+  const originalLog = console.log.bind(console);
+  const originalWarn = console.warn.bind(console);
+  const originalError = console.error.bind(console);
+  const originalInfo = console.info.bind(console);
+  const originalDebug = console.debug.bind(console);
+  console.log = (...args) => {
+    handleConsoleLog(state, args);
+    originalLog(...args);
+  };
+  console.warn = (...args) => {
+    handleConsoleWarn(state, args);
+    originalWarn(...args);
+  };
+  console.error = (...args) => {
+    handleConsoleError(state, args);
+    originalError(...args);
+  };
+  console.info = (...args) => {
+    handleConsoleInfo(state, args);
+    originalInfo(...args);
+  };
+  console.debug = (...args) => {
+    handleConsoleDebug(state, args);
+    originalDebug(...args);
+  };
+});
+function handleStdoutWrite(state, message3) {
+  try {
+    let matchesPattern2 = state.config.stdoutPatterns.some((pattern2) => message3.includes(pattern2));
+    if (matchesPattern2) {
+      return addLog(state, "build", message3, void 0, void 0);
+    } else {
+      return;
+    }
+  } catch (exn) {
+    return;
+  }
+}
+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);
+      return originalWrite(chunk, ...args);
+    };
+  })(_state);
+}
+function interceptUncaughtErrors(state) {
+  process.on("uncaughtException", (error) => {
+    try {
+      let errorMessage = getOr(error.message, "Unknown error");
+      let attributes = Object.fromEntries([
         [
-          "error",
-          "Failed to resolve source location"
+          "stack",
+          getOr(map(error.stack, (prim) => prim), null)
         ],
         [
-          "details",
-          msg
+          "name",
+          error.name
         ]
-      ]), {
-        status: 500
-      });
+      ]);
+      return addLog(state, "error", errorMessage, attributes, void 0);
+    } catch (exn) {
+      return;
+    }
+  });
+  process.on("unhandledRejection", (reason2) => {
+    try {
+      let reasonMessage = getOr(reason2.message, String.toString(reason2));
+      let attributes = Object.fromEntries([[
+        "stack",
+        getOr(map(reason2.stack, (prim) => prim), null)
+      ]]);
+      return addLog(state, "error", reasonMessage, attributes, void 0);
+    } catch (exn) {
+      return;
     }
+  });
+}
+function initialize(configOpt, param) {
+  let config = defaultConfig;
+  if (isBrowser()) {
+    return;
   }
-  return Response.json(Object.fromEntries([[
-    "error",
-    "Missing required fields: componentName, file, line, column"
-  ]]), {
-    status: 400
+  let match = getPatchedFlag();
+  if (match !== void 0 && match) {
+    return;
+  }
+  setPatchedFlag(true);
+  let state = getOrCreateInstance(config);
+  interceptConsole(state);
+  interceptStdout(state);
+  interceptUncaughtErrors(state);
+}
+var regexCache = {
+  pattern: void 0,
+  regex: void 0
+};
+function getCompiledRegex(pattern2) {
+  let cached = regexCache.pattern;
+  if (cached !== void 0 && cached === pattern2) {
+    let r = regexCache.regex;
+    if (r !== void 0) {
+      return r;
+    }
+    let regex = new RegExp(pattern2, "i");
+    regexCache.regex = regex;
+    return regex;
+  }
+  let regex$1 = new RegExp(pattern2, "i");
+  regexCache.pattern = pattern2;
+  regexCache.regex = regex$1;
+  return regex$1;
+}
+function getLogs(pattern2, level, since, tail) {
+  try {
+    let state = getInstance();
+    let allLogs = toArray3(state.buffer.contents);
+    let logs = since !== void 0 ? allLogs.filter((entry) => new Date(entry.timestamp).getTime() >= since) : allLogs;
+    let logs$1 = level !== void 0 ? logs.filter((entry) => entry.level === level) : logs;
+    let logs$2;
+    if (pattern2 !== void 0) {
+      let regex = getCompiledRegex(pattern2);
+      logs$2 = logs$1.filter((entry) => regex.test(entry.message));
+    } else {
+      logs$2 = logs$1;
+    }
+    if (tail === void 0) {
+      return logs$2;
+    }
+    let len = logs$2.length;
+    return logs$2.slice(max(0, len - tail | 0), len);
+  } catch (exn) {
+    return [];
+  }
+}
+
+// src/tools/FrontmanAstro__Tool__GetLogs.res.mjs
+var inputSchema10 = schema2((s2) => ({
+  pattern: s2.m(option2(string2)),
+  level: s2.m(option2(logLevelSchema)),
+  since: s2.m(option2(string2)),
+  tail: s2.m(option2(int2))
+}));
+var outputSchema10 = schema2((s2) => ({
+  logs: s2.m(array2(logEntrySchema)),
+  totalMatched: s2.m(int2),
+  bufferSize: s2.m(int2),
+  hasMore: s2.m(bool2)
+}));
+async function execute10(_ctx, input) {
+  try {
+    let sinceTimestamp = map(input.since, (isoString) => new Date(isoString).getTime());
+    let allMatchedLogs = getLogs(input.pattern, input.level, sinceTimestamp, void 0);
+    let totalMatched = allMatchedLogs.length;
+    let n = input.tail;
+    let logs = n !== void 0 ? allMatchedLogs.slice(max(0, totalMatched - n | 0), totalMatched) : allMatchedLogs;
+    let n$1 = input.tail;
+    let hasMore = n$1 !== void 0 ? totalMatched > n$1 : false;
+    let bufferSize = length2(getInstance().buffer.contents);
+    return {
+      TAG: "Ok",
+      _0: {
+        logs,
+        totalMatched,
+        bufferSize,
+        hasMore
+      }
+    };
+  } catch (raw_exn) {
+    let exn = internalToException(raw_exn);
+    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
+    return {
+      TAG: "Error",
+      _0: `Failed to retrieve logs: ` + msg
+    };
+  }
+}
+var name11 = "get_logs";
+var description10 = `Retrieves dev server logs from rotating 1024-entry buffer.
+
+Captures:
+- Console output (console.log, warn, error, info, debug)
+- Astro build logs (compilation, errors, warnings)
+- Uncaught exceptions with stack traces
+
+Parameters:
+- pattern (optional): JavaScript regex pattern to filter messages (case-insensitive)
+  Examples: "error", "astro.*build", "TypeError"
+- level (optional): Filter by log type: "console", "build", or "error"
+- since (optional): ISO 8601 timestamp - only return logs after this time
+  Example: "2025-12-28T10:30:00.000Z"
+- tail (optional): Limit to most recent N entries
+  Example: 100 (returns last 100 matching logs)
+
+Returns logs in chronological order (oldest first within buffer).`;
+
+// src/tools/FrontmanAstro__Tool__EditFile.res.mjs
+function sleep(ms) {
+  return new Promise((resolve3, param) => {
+    setTimeout(() => resolve3(), ms);
+  });
+}
+async function execute11(ctx2, input) {
+  let beforeTimestamp = Date.now();
+  let result = await execute2(ctx2, input);
+  if (result.TAG !== "Ok") {
+    return result;
+  }
+  let output = result._0;
+  await sleep(800);
+  let recentLogs = getLogs(void 0, "error", beforeTimestamp, void 0);
+  let errorLogs = getLogs("error|Error|failed|Failed", void 0, beforeTimestamp, void 0);
+  let seen = /* @__PURE__ */ new Set();
+  recentLogs.forEach((entry) => {
+    seen.add(entry.timestamp + "|" + entry.message);
   });
+  let allErrors = recentLogs.concat(errorLogs.filter((entry) => !seen.has(entry.timestamp + "|" + entry.message)));
+  if (allErrors.length === 0) {
+    return {
+      TAG: "Ok",
+      _0: output
+    };
+  }
+  let errorMessages = allErrors.slice(0, 5).map((entry) => entry.message).join("\n");
+  let newrecord = { ...output };
+  return {
+    TAG: "Ok",
+    _0: (newrecord.message = output.message + (`
+
+Warning: Dev server errors detected after edit:
+` + errorMessages), newrecord)
+  };
 }
+var name12 = "edit_file";
+var description11 = description2;
+var inputSchema11 = inputSchema2;
+var outputSchema11 = outputSchema2;
 var dynamicTypeSchema = union2([
   literal2("static"),
   literal2("single"),
   literal2("rest"),
   literal2("optional")
 ]);
-var inputSchema9 = schema2((s2) => ({
+var inputSchema12 = schema2((s2) => ({
   placeholder: s2.m(option2(bool2))
 }));
 var pageSchema = schema2((s2) => ({
@@ -6046,7 +7228,7 @@ var pageSchema = schema2((s2) => ({
   isDynamic: s2.m(bool2),
   dynamicType: s2.m(dynamicTypeSchema)
 }));
-var outputSchema9 = array2(pageSchema);
+var outputSchema12 = array2(pageSchema);
 function analyzeDynamicSegment(segment) {
   if (segment.startsWith("[[") && segment.endsWith("]]")) {
     return "optional";
@@ -6101,10 +7283,10 @@ function getMostSignificantDynamicType(segments) {
 async function findPages(baseDir, currentPath, projectRoot, sourceRoot) {
   let fullPath = Nodepath.join(projectRoot, baseDir, currentPath);
   try {
-    let entries = await Fs3.promises.readdir(fullPath);
+    let entries = await Fs.promises.readdir(fullPath);
     return (await Promise.all(entries.map(async (entry) => {
       let entryPath = Nodepath.join(fullPath, entry);
-      let stats = await Fs3.promises.lstat(entryPath);
+      let stats = await Fs.promises.lstat(entryPath);
       if (stats.isSymbolicLink()) {
         return [];
       }
@@ -6141,7 +7323,7 @@ async function findPages(baseDir, currentPath, projectRoot, sourceRoot) {
     throw exn;
   }
 }
-async function execute9(ctx2, _input) {
+async function execute12(ctx2, _input) {
   try {
     let srcPages = await findPages("src/pages", "", ctx2.projectRoot, ctx2.sourceRoot);
     let rootPages = await findPages("pages", "", ctx2.projectRoot, ctx2.sourceRoot);
@@ -6159,8 +7341,8 @@ async function execute9(ctx2, _input) {
     };
   }
 }
-var name10 = "get_client_pages";
-var description9 = `Lists Astro client pages from the pages directory.
+var name13 = "get_client_pages";
+var description12 = `Lists Astro client pages from the pages directory.
 
 Parameters: None
 
@@ -6168,70 +7350,53 @@ Returns array of page paths based on file-system routing conventions.
 Excludes API routes (src/pages/api/) - focuses on renderable pages only.`;
 
 // src/FrontmanAstro__ToolRegistry.res.mjs
-var astroTools = [{
-  name: name10,
-  description: description9,
-  inputSchema: inputSchema9,
-  outputSchema: outputSchema9,
-  execute: execute9,
-  visibleToAgent: true
-}];
-function make2() {
-  return addTools(coreTools(), astroTools);
+var astroTools = [
+  {
+    name: name13,
+    description: description12,
+    inputSchema: inputSchema12,
+    outputSchema: outputSchema12,
+    execute: execute12,
+    visibleToAgent: true
+  },
+  {
+    name: name11,
+    description: description10,
+    inputSchema: inputSchema10,
+    outputSchema: outputSchema10,
+    execute: execute10,
+    visibleToAgent: true
+  }
+];
+function make4() {
+  return replaceByName(addTools(coreTools(), astroTools), {
+    name: name12,
+    description: description11,
+    inputSchema: inputSchema11,
+    outputSchema: outputSchema11,
+    execute: execute11,
+    visibleToAgent: true
+  });
 }
 
 // src/FrontmanAstro__Middleware.res.mjs
-function uiHtml(clientUrl, clientCssUrl, isLightTheme) {
-  let openrouterKey = flatMap(process.env["OPENROUTER_API_KEY"], (key) => {
-    if (key !== "") {
-      return key;
-    }
-  });
-  let configObj = Object.fromEntries([[
-    "framework",
-    "Astro"
-  ]]);
-  forEach(openrouterKey, (key) => {
-    configObj["openrouterKeyValue"] = key;
-  });
-  let runtimeConfig = JSON.stringify(configObj);
-  let themeClass = isLightTheme ? "" : "dark";
-  let cssLink = clientCssUrl !== void 0 ? `<link rel="stylesheet" href="` + clientCssUrl + `">` : "";
-  return `<!DOCTYPE html>
-<html lang="en" class="` + themeClass + `">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Frontman</title>
-  ` + cssLink + `
-  <style>
-    html, body, #root {
-      margin: 0;
-      padding: 0;
-      height: 100%;
-      width: 100%;
-    }
-  </style>
-</head>
-<body>
-  <div id="root"></div>
-  <script>window.__frontmanRuntime=` + runtimeConfig + `</script>
-  <script type="module" src="` + clientUrl + `"></script>
-</body>
-</html>`;
-}
-function serveUI(config) {
-  let html = uiHtml(config.clientUrl, config.clientCssUrl, config.isLightTheme);
-  let headers2 = Object.fromEntries([[
-    "Content-Type",
-    "text/html"
-  ]]);
-  return new Response(html, {
-    headers: some(headers2)
-  });
+function toMiddlewareConfig(config) {
+  return {
+    projectRoot: config.projectRoot,
+    sourceRoot: config.sourceRoot,
+    basePath: config.basePath,
+    serverName: config.serverName,
+    serverVersion: config.serverVersion,
+    clientUrl: config.clientUrl,
+    clientCssUrl: config.clientCssUrl,
+    entrypointUrl: void 0,
+    isLightTheme: config.isLightTheme,
+    frameworkLabel: "Astro"
+  };
 }
 function createMiddleware(config) {
-  let registry = make2();
+  let registry = make4();
+  let middlewareConfig = toMiddlewareConfig(config);
   return async (request) => {
     let url2 = new URL(request.url);
     let pathname = url2.pathname;
@@ -6239,15 +7404,15 @@ function createMiddleware(config) {
     let basePath = `/` + config.basePath;
     if (pathname === basePath || pathname.startsWith(basePath + `/`)) {
       if (method === "OPTIONS") {
-        return handleCORS();
+        return handlePreflight();
       } else if (pathname === basePath || pathname === basePath + `/`) {
-        return serveUI(config);
+        return withCors(serve(middlewareConfig));
       } else if (pathname === basePath + `/tools` && method === "GET") {
-        return handleGetTools(registry, config);
+        return withCors(handleGetTools2(registry, config));
       } else if (pathname === basePath + `/tools/call` && method === "POST") {
-        return await handleToolCall(registry, config, request);
+        return withCors(await handleToolCall2(registry, config, request));
       } else if (pathname === basePath + `/resolve-source-location` && method === "POST") {
-        return await handleResolveSourceLocation(config, request);
+        return withCors(await handleResolveSourceLocation2(config, request));
       } else {
         return Response.json(Object.fromEntries([[
           "error",
@@ -6260,11 +7425,6 @@ function createMiddleware(config) {
   };
 }
 
-// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_Promise.js
-function $$catch(promise, callback) {
-  return promise.catch((err) => callback(internalToException(err)));
-}
-
 // ../bindings/src/NodeHttp.res.mjs
 var collectRequestBody = (async function(req) {
   const chunks = [];
@@ -6369,42 +7529,53 @@ var icon = `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewB
 function getToolbarAppPath() {
   return new URL("./toolbar.js", import.meta.url).pathname;
 }
-function make3(configInput) {
+function make5(configInput) {
   let config = makeFromObject(configInput);
   return {
     name: "frontman",
     hooks: {
       "astro:config:setup": (ctx2) => {
-        let match = ctx2.command;
-        if (match === "dev") {
-          if (ctx2.config.devToolbar.enabled) ; else {
-            console.warn("[Frontman] Astro devToolbar is disabled \u2014 element source detection will be limited. Set `devToolbar: { enabled: true }` in your astro.config to enable full component source resolution.");
-          }
-          ctx2.updateConfig({
-            vite: {
-              plugins: [frontmanPropsInjectionPlugin()]
-            }
-          });
-          ctx2.addDevToolbarApp({
-            id: "frontman:toolbar",
-            name: "Frontman",
-            icon,
-            entrypoint: getToolbarAppPath()
-          });
-          return ctx2.injectScript("head-inline", annotationCaptureScript2);
+        if (ctx2.command !== "dev") {
+          return;
+        }
+        if (!ctx2.config.devToolbar.enabled) {
+          console.warn("[Frontman] Astro devToolbar is disabled \u2014 element source detection will be limited. Set `devToolbar: { enabled: true }` in your astro.config to enable full component source resolution.");
         }
+        ctx2.updateConfig({
+          vite: {
+            plugins: [frontmanPropsInjectionPlugin()]
+          }
+        });
+        ctx2.addDevToolbarApp({
+          id: "frontman:toolbar",
+          name: "Frontman",
+          icon,
+          entrypoint: getToolbarAppPath()
+        });
+        let safeBasePath = getOr(JSON.stringify(config.basePath), `"frontman"`);
+        let basePathMeta = `{
+              const meta = document.createElement('meta');
+              meta.name = 'frontman-base-path';
+              meta.content = ` + safeBasePath + `;
+              document.head.appendChild(meta);
+            }`;
+        ctx2.injectScript("head-inline", basePathMeta + "\n" + annotationCaptureScript2);
       },
       "astro:server:setup": (param) => {
+        initialize();
         let webMiddleware = createMiddleware(config);
         let connectMiddleware = adaptToConnect(webMiddleware, config.basePath);
         param.server.middlewares.use(connectMiddleware);
+        param.toolbar.onAppInitialized("frontman:toolbar", () => {
+          console.log("[Frontman] Dev toolbar app initialized");
+        });
       }
     }
   };
 }
 
 // src/FrontmanAstro.res.mjs
-var frontmanIntegration = make3;
+var frontmanIntegration = make5;
 
 // index.mjs
 var index_default = frontmanIntegration;