@frontman-ai/astro 0.1.6 → 0.2.1

package/dist/index.js

@@ -1,9 +1,11 @@
 import * as Web from 'stream/web';
-import * as Fs2 from 'fs';
+import * as Fs3 from 'fs';
 import { existsSync, readFileSync } from 'fs';
 import * as Nodepath from 'path';
 import { dirname, join } from 'path';
 import { createRequire } from 'module';
+import * as Nodebuffer from 'buffer';
+import * as Nodechild_process from 'child_process';
 
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
@@ -16,9 +18,9 @@ var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 
-// ../../node_modules/vscode-ripgrep/lib/index.js
+// ../../node_modules/@vscode/ripgrep/lib/index.js
 var require_lib = __commonJS({
-  "../../node_modules/vscode-ripgrep/lib/index.js"(exports$1, module) {
+  "../../node_modules/@vscode/ripgrep/lib/index.js"(exports$1, module) {
     var path = __require("path");
     module.exports.rgPath = path.join(__dirname, `../bin/rg${process.platform === "win32" ? ".exe" : ""}`);
   }
@@ -89,6 +91,9 @@ function orElse(opt, other) {
     return other;
   }
 }
+function isSome(x) {
+  return x !== void 0;
+}
 
 // ../frontman-core/src/FrontmanCore__Hosts.res.mjs
 var apiHost = "api.frontman.sh";
@@ -135,6 +140,267 @@ function makeFromObject(rawConfig) {
   };
 }
 
+// src/annotation-capture.mjs
+var annotationCaptureScript = `(function() {
+  var PROPS_PREFIX = '__frontman_props__:';
+
+  function parsePropsPayload(text) {
+    text = text.trim();
+    if (text.indexOf(PROPS_PREFIX) !== 0) return null;
+    try {
+      var encoded = text.slice(PROPS_PREFIX.length).trim();
+      return JSON.parse(atob(encoded));
+    } catch(e) {
+      return null;
+    }
+  }
+
+  function captureAnnotations() {
+    var annotations = new Map();
+    var propsMap = new Map();
+    var pendingProps = [];
+
+    var walker = document.createTreeWalker(
+      document.documentElement,
+      NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_ELEMENT,
+      null
+    );
+
+    var node;
+    while (node = walker.nextNode()) {
+      if (node.nodeType === 8) {
+        var parsed = parsePropsPayload(node.textContent);
+        if (parsed) {
+          pendingProps.push(parsed);
+        }
+      } else if (node.nodeType === 1) {
+        if (pendingProps.length > 0 && node.hasAttribute('data-astro-source-file')) {
+          propsMap.set(node, pendingProps.slice());
+          pendingProps = [];
+        }
+      }
+    }
+
+    document.querySelectorAll('[data-astro-source-file]').forEach(function(el) {
+      var sourceFile = el.getAttribute('data-astro-source-file');
+      var annotation = {
+        file: sourceFile,
+        loc: el.getAttribute('data-astro-source-loc')
+      };
+
+      var propsChain = propsMap.get(el);
+
+      if (!propsChain) {
+        var parent = el.parentElement;
+        var maxSteps = 30;
+        while (parent && maxSteps-- > 0) {
+          propsChain = propsMap.get(parent);
+          if (propsChain) break;
+          parent = parent.parentElement;
+        }
+      }
+
+      if (propsChain && propsChain.length > 0) {
+        var match = null;
+        for (var i = 0; i < propsChain.length; i++) {
+          var entry = propsChain[i];
+          if (entry.moduleId) {
+            var entryFile = entry.moduleId.split('/').pop() || '';
+            var srcFile = sourceFile.split('/').pop() || '';
+            if (entryFile === srcFile && entryFile !== '') {
+              match = entry;
+              break;
+            }
+          }
+        }
+        if (!match) match = propsChain[0];
+
+        if (match) {
+          annotation.componentProps = match.props || null;
+          if (match.displayName) {
+            annotation.displayName = match.displayName;
+          }
+        }
+      }
+
+      annotations.set(el, annotation);
+    });
+
+    window.__frontman_annotations__ = {
+      _map: annotations,
+      get: function(el) { return annotations.get(el); },
+      has: function(el) { return annotations.has(el); },
+      size: function() { return annotations.size; }
+    };
+  }
+
+  document.addEventListener('DOMContentLoaded', captureAnnotations);
+
+  var initialLoad = true;
+  document.addEventListener('astro:page-load', function() {
+    if (initialLoad) { initialLoad = false; return; }
+    captureAnnotations();
+  });
+})();`;
+
+// src/vite-plugin-props-injection.mjs
+function frontmanPropsInjectionPlugin() {
+  return {
+    name: "frontman:props-injection",
+    enforce: "pre",
+    apply: "serve",
+    // Only apply in SSR (server-side rendering) mode
+    transform(code, id, options) {
+      if (!options?.ssr) return null;
+      if (!id.includes("astro/dist/runtime/server/render/component") && !id.includes("astro/runtime/server/render/component")) {
+        return null;
+      }
+      if (!code.includes("function renderComponent(")) {
+        console.warn(
+          "[Frontman] Could not find renderComponent in Astro internals \u2014 component props injection will be disabled. This may happen after an Astro upgrade. File: " + id
+        );
+        return null;
+      }
+      let transformed = code.replace(
+        "function renderComponent(",
+        "function __original_renderComponent("
+      );
+      const wrapperCode = `
+
+// --- Frontman props injection wrapper ---
+
+function __frontman_safeSerialize(displayName, Component, props) {
+  try {
+    const clean = {};
+    for (const [key, value] of Object.entries(props || {})) {
+      // Skip internal Astro props (scoped CSS hashes)
+      if (key.startsWith('data-astro-cid-')) continue;
+      // Skip class (styling detail, not semantic)
+      if (key === 'class' || key === 'class:list') continue;
+
+      const t = typeof value;
+      if (t === 'string' || t === 'number' || t === 'boolean') {
+        clean[key] = value;
+      } else if (value === null || value === undefined) {
+        clean[key] = value;
+      } else if (Array.isArray(value)) {
+        try {
+          const serialized = JSON.stringify(value);
+          clean[key] = serialized.length < 1000 ? value : '[Array(' + value.length + ')]';
+        } catch {
+          clean[key] = '[Array]';
+        }
+      } else if (t === 'object') {
+        try {
+          const serialized = JSON.stringify(value);
+          clean[key] = serialized.length < 500 ? value : '{...}';
+        } catch {
+          clean[key] = '{...}';
+        }
+      }
+      // Skip functions, symbols, etc.
+    }
+
+    const entry = { displayName, props: clean };
+    // Include the component's moduleId (file path) if available
+    if (Component && Component.moduleId) {
+      entry.moduleId = Component.moduleId;
+    }
+    return JSON.stringify(entry);
+  } catch {
+    return null;
+  }
+}
+
+function __frontman_toBase64(str) {
+  if (typeof Buffer !== 'undefined') return Buffer.from(str, 'utf-8').toString('base64');
+  if (typeof btoa === 'function') return btoa(unescape(encodeURIComponent(str)));
+  return null;
+}
+
+function __frontman_wrapInstance(renderInstance, displayName, Component, props) {
+  // If no render method (e.g. fragment), pass through
+  if (!renderInstance || typeof renderInstance.render !== 'function') {
+    return renderInstance;
+  }
+
+  const serialized = __frontman_safeSerialize(displayName, Component, props);
+  if (!serialized) return renderInstance;
+
+  const encoded = __frontman_toBase64(serialized);
+  if (!encoded) return renderInstance;
+
+  const originalRender = renderInstance.render;
+
+  renderInstance.render = function(destination) {
+    // Write the props comment BEFORE the component renders.
+    // This creates a Comment node in the DOM immediately preceding
+    // the component's first rendered element.
+    // Guard: markHTMLString is assumed to be in scope from Astro's module.
+    // If it's missing (e.g., after an Astro upgrade), skip injection gracefully.
+    if (typeof markHTMLString === 'function') {
+      destination.write(markHTMLString('<!-- __frontman_props__:' + encoded + ' -->'));
+    }
+    return originalRender.call(renderInstance, destination);
+  };
+
+  return renderInstance;
+}
+
+function renderComponent(result, displayName, Component, props, slots) {
+  const renderInstance = __original_renderComponent(result, displayName, Component, props, slots);
+
+  // Handle promise (async component resolution)
+  if (renderInstance && typeof renderInstance.then === 'function') {
+    return renderInstance.then(function(resolved) {
+      return __frontman_wrapInstance(resolved, displayName, Component, props);
+    });
+  }
+
+  return __frontman_wrapInstance(renderInstance, displayName, Component, props);
+}
+
+// --- End Frontman props injection wrapper ---
+`;
+      transformed += wrapperCode;
+      return {
+        code: transformed,
+        map: null
+      };
+    }
+  };
+}
+
+// ../../node_modules/@rescript/runtime/lib/es6/Primitive_int.js
+function div(x, y) {
+  if (y === 0) {
+    throw {
+      RE_EXN_ID: "Division_by_zero",
+      Error: new Error()
+    };
+  }
+  return x / y | 0;
+}
+
+// ../../node_modules/@rescript/runtime/lib/es6/Belt_Array.js
+function concatMany(arrs) {
+  let lenArrs = arrs.length;
+  let totalLen = 0;
+  for (let i = 0; i < lenArrs; ++i) {
+    totalLen = totalLen + arrs[i].length | 0;
+  }
+  let result = new Array(totalLen);
+  totalLen = 0;
+  for (let j2 = 0; j2 < lenArrs; ++j2) {
+    let cur = arrs[j2];
+    for (let k2 = 0, k_finish = cur.length; k2 < k_finish; ++k2) {
+      result[totalLen] = cur[k2];
+      totalLen = totalLen + 1 | 0;
+    }
+  }
+  return result;
+}
+
 // ../../node_modules/@rescript/runtime/lib/es6/Primitive_exceptions.js
 function isExtension(e) {
   if (e == null) {
@@ -275,9 +541,9 @@ function stringify(unknown2) {
 function toExpression(schema3) {
   let tag = schema3.type;
   let $$const = schema3.const;
-  let name10 = schema3.name;
-  if (name10 !== void 0) {
-    return name10;
+  let name11 = schema3.name;
+  if (name11 !== void 0) {
+    return name11;
   }
   if ($$const !== void 0) {
     return stringify($$const);
@@ -1397,10 +1663,10 @@ function isPriority(tagFlag, byKey) {
   }
 }
 function isWiderUnionSchema(schemaAnyOf, inputAnyOf) {
-  return inputAnyOf.every((inputSchema9, idx) => {
+  return inputAnyOf.every((inputSchema10, idx) => {
     let schema3 = schemaAnyOf[idx];
-    if (schema3 !== void 0 && !(flags[inputSchema9.type] & 9152) && inputSchema9.type === schema3.type) {
-      return inputSchema9.const === schema3.const;
+    if (schema3 !== void 0 && !(flags[inputSchema10.type] & 9152) && inputSchema10.type === schema3.type) {
+      return inputSchema10.const === schema3.const;
     } else {
       return false;
     }
@@ -2003,6 +2269,7 @@ var ctx = {
 function factory$4(definer) {
   return definitionToSchema(definer(ctx));
 }
+var js_schema = definitionToSchema;
 function option(item) {
   return factory$1(item, unit);
 }
@@ -2242,8 +2509,10 @@ function toJSONSchema(schema3) {
   }
   return jsonSchema;
 }
+var literal = js_schema;
 var array = factory$2;
 var dict = factory$3;
+var union = factory;
 var schema = factory$4;
 
 // ../../node_modules/sury/src/S.res.mjs
@@ -2251,11 +2520,14 @@ var $$Error2 = $$Error;
 var string2 = string;
 var bool2 = bool;
 var int2 = int;
+var float2 = float;
 var json2 = json;
 var enableJson2 = enableJson;
+var literal2 = literal;
 var array2 = array;
 var dict2 = dict;
 var option2 = option;
+var union2 = union;
 var parseOrThrow2 = parseOrThrow;
 var reverseConvertToJsonOrThrow2 = reverseConvertToJsonOrThrow;
 var schema2 = schema;
@@ -2277,7 +2549,7 @@ function string3(json3) {
     return json3;
   }
 }
-function float2(json3) {
+function float3(json3) {
   if (typeof json3 === "number") {
     return json3;
   }
@@ -2296,7 +2568,7 @@ var Decode = {
   bool: bool3,
   $$null: $$null2,
   string: string3,
-  float: float2,
+  float: float3,
   object: object2,
   array: array3
 };
@@ -4000,6 +4272,21 @@ function reduce(arr, init, f) {
 function reduceWithIndex(arr, init, f) {
   return arr.reduce(f, init);
 }
+function filterMap(a, f) {
+  let l = a.length;
+  let r = new Array(l);
+  let j2 = 0;
+  for (let i = 0; i < l; ++i) {
+    let v = a[i];
+    let v$1 = f(v);
+    if (v$1 !== void 0) {
+      r[j2] = valFromOption(v$1);
+      j2 = j2 + 1 | 0;
+    }
+  }
+  r.length = j2;
+  return r;
+}
 
 // ../../node_modules/@rescript/runtime/lib/es6/Stdlib_Int.js
 function fromString2(x, radix) {
@@ -4010,69 +4297,160 @@ function fromString2(x, radix) {
     return maybeInt | 0;
   }
 }
-
-// ../bindings/src/ChildProcess.res.mjs
-var execPromise = (async function(command, options) {
-  const { exec: exec2 } = await import('child_process');
-  const { promisify } = await import('util');
-  const execP = promisify(exec2);
-  return await execP(command, options);
-});
-var bufferToString = (function(value) {
-  if (value == null) return "";
-  if (typeof value === "string") return value;
-  if (Buffer.isBuffer(value)) return value.toString("utf8");
-  return String(value);
-});
-async function exec(command) {
-  try {
-    let result = await execPromise(command, {
-      maxBuffer: 52428800
-    });
-    return {
-      TAG: "Ok",
-      _0: {
-        stdout: bufferToString(result.stdout),
-        stderr: bufferToString(result.stderr)
+function execPromise(command, options) {
+  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,
+      maxBuffer,
+      encoding: "utf8"
+    }, (err, stdout, stderr) => {
+      if (err == null) {
+        return resolve3({
+          TAG: "Ok",
+          _0: {
+            stdout,
+            stderr
+          }
+        });
+      } else {
+        return resolve3({
+          TAG: "Error",
+          _0: {
+            code: fromNullable(err.code),
+            stdout,
+            stderr,
+            message: err.message
+          }
+        });
       }
+    });
+  });
+}
+function spawnPromise(command, args, options) {
+  let maxBuffer = getOr(options.maxBuffer, 52428800);
+  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: []
     };
-  } catch (raw_exn) {
-    let exn = internalToException(raw_exn);
-    let actualError = getOr(fromNullable(exn._1), exn);
-    return {
-      TAG: "Error",
-      _0: {
-        code: fromNullable(actualError.code),
-        stdout: getOr(map(fromNullable(actualError.stdout), bufferToString), ""),
-        stderr: getOr(map(fromNullable(actualError.stderr), bufferToString), "")
-      }
+    let stderrChunks = {
+      contents: []
     };
-  }
-}
-async function execWithOptions(command, options) {
-  try {
-    let newrecord = { ...options };
-    newrecord.maxBuffer = getOr(options.maxBuffer, 52428800);
-    let result = await execPromise(command, newrecord);
-    return {
-      TAG: "Ok",
-      _0: {
-        stdout: bufferToString(result.stdout),
-        stderr: bufferToString(result.stderr)
+    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);
       }
     };
-  } catch (raw_exn) {
-    let exn = internalToException(raw_exn);
-    let actualError = getOr(fromNullable(exn._1), exn);
-    return {
+    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");
+          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: fromNullable(actualError.code),
-        stdout: getOr(map(fromNullable(actualError.stdout), bufferToString), ""),
-        stderr: getOr(map(fromNullable(actualError.stderr), bufferToString), "")
+        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",
+          _0: {
+            stdout: Nodebuffer.Buffer.concat(stdoutChunks.contents).toString("utf8"),
+            stderr: Nodebuffer.Buffer.concat(stderrChunks.contents).toString("utf8")
+          }
+        });
+      }
+      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"),
+          message: `Process exited with code ` + codeStr
+        }
+      });
+    });
+  });
+}
+async function execWithOptions(command, options) {
+  let newrecord = { ...options };
+  newrecord.maxBuffer = getOr(options.maxBuffer, 52428800);
+  return await execPromise(command, newrecord);
+}
+async function spawnResult(command, args, cwd) {
+  let options_maxBuffer = 52428800;
+  let options = {
+    cwd,
+    maxBuffer: options_maxBuffer
+  };
+  return await spawnPromise(command, args, options);
 }
 function resolve(sourceRoot, inputPath) {
   let normalizedRoot = Nodepath.normalize(sourceRoot);
@@ -4189,7 +4567,18 @@ Hint: ` + hint;
   }
 }
 
+// ../frontman-protocol/src/FrontmanProtocol__Tool.res.mjs
+var ToolNames = {
+  writeFile: "write_file",
+  readFile: "read_file",
+  listFiles: "list_files",
+  searchFiles: "search_files",
+  grep: "grep",
+  fileExists: "file_exists",
+  loadAgentInstructions: "load_agent_instructions"};
+
 // ../frontman-core/src/tools/FrontmanCore__Tool__Grep.res.mjs
+var name2 = ToolNames.grep;
 var inputSchema = schema2((s2) => ({
   pattern: s2.m(string2),
   path: s2.m(option2(string2)),
@@ -4220,14 +4609,14 @@ function getRipgrepPath() {
     return;
   }
 }
-function buildRipgrepArgs(pattern2, searchPath, type_, glob, caseInsensitive, literal2, maxResults) {
+function buildRipgrepArgs(pattern2, searchPath, type_, glob, caseInsensitive, literal3, maxResults) {
   let args = [];
   args.push("-n");
   args.push("-H");
   if (caseInsensitive) {
     args.push("-i");
   }
-  if (literal2) {
+  if (literal3) {
     args.push("-F");
   }
   args.push("-m");
@@ -4244,7 +4633,7 @@ function buildRipgrepArgs(pattern2, searchPath, type_, glob, caseInsensitive, li
   args.push(searchPath);
   return args;
 }
-function buildGitGrepArgs(pattern2, caseInsensitive, literal2, maxResults) {
+function buildGitGrepArgs(pattern2, caseInsensitive, literal3, maxResults, glob, type_) {
   let args = [
     "grep",
     "-n",
@@ -4253,12 +4642,22 @@ function buildGitGrepArgs(pattern2, caseInsensitive, literal2, maxResults) {
   if (caseInsensitive) {
     args.push("-i");
   }
-  if (literal2) {
+  if (literal3) {
     args.push("-F");
   }
   args.push("--max-count");
   args.push(maxResults.toString());
   args.push(pattern2);
+  let hasPathspec = isSome(glob) || isSome(type_);
+  if (hasPathspec) {
+    args.push("--");
+    if (glob !== void 0) {
+      args.push(glob);
+    }
+    if (type_ !== void 0 && glob === void 0) {
+      args.push(`*.` + type_);
+    }
+  }
   return args;
 }
 function parseGrepOutput(output, maxResults) {
@@ -4293,122 +4692,154 @@ function parseGrepOutput(output, maxResults) {
     });
     fileMap[filePath] = matches2;
   });
-  let files = Object.entries(fileMap).map((param) => ({
+  let allFiles = Object.entries(fileMap).map((param) => ({
     path: param[0],
     matches: param[1]
-  })).slice(0, maxResults);
+  }));
+  let totalFiles = allFiles.length;
+  let files = allFiles.slice(0, maxResults);
   return {
     files,
     totalMatches: totalMatches.contents,
-    truncated: totalMatches.contents > maxResults
+    truncated: totalFiles > maxResults
   };
 }
-async function executeRipgrep(rgPath, pattern2, searchPath, type_, glob, caseInsensitive, literal2, maxResults) {
-  let args = buildRipgrepArgs(pattern2, searchPath, type_, glob, caseInsensitive, literal2, maxResults);
-  let command = rgPath + ` ` + args.join(" ");
-  try {
-    let result = await exec(command);
-    if (result.TAG === "Ok") {
-      return {
-        TAG: "Ok",
-        _0: parseGrepOutput(result._0.stdout, maxResults)
-      };
-    }
-    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: {
-            files: [],
-            totalMatches: 0,
-            truncated: false
-          }
-        };
+async function executeRipgrep(rgPath, pattern2, searchPath, type_, glob, caseInsensitive, literal3, maxResults) {
+  let args = buildRipgrepArgs(pattern2, searchPath, type_, glob, caseInsensitive, literal3, maxResults);
+  let result = await spawnResult(rgPath, args, void 0);
+  if (result.TAG === "Ok") {
+    return {
+      TAG: "Ok",
+      _0: parseGrepOutput(result._0.stdout, maxResults)
+    };
+  }
+  let match = result._0;
+  let match$1 = match.code;
+  if (match$1 === 1) {
+    return {
+      TAG: "Ok",
+      _0: {
+        files: [],
+        totalMatches: 0,
+        truncated: false
       }
-      exit = 1;
-    } else {
-      exit = 1;
-    }
-    if (exit === 1) {
-      return {
-        TAG: "Error",
-        _0: `Ripgrep failed: ` + match.stderr
-      };
-    }
-  } catch (raw_exn) {
-    let exn = internalToException(raw_exn);
-    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
+    };
+  }
+  let stderr = match.stderr;
+  let detail = stderr === "" ? match.message : stderr;
+  return {
+    TAG: "Error",
+    _0: `Ripgrep failed: ` + detail
+  };
+}
+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);
+  if (result.TAG === "Ok") {
     return {
-      TAG: "Error",
-      _0: `Ripgrep execution failed: ` + msg
+      TAG: "Ok",
+      _0: parseGrepOutput(result._0.stdout, maxResults)
+    };
+  }
+  let match = result._0;
+  let code = match.code;
+  if (code === 1) {
+    return {
+      TAG: "Ok",
+      _0: {
+        files: [],
+        totalMatches: 0,
+        truncated: false
+      }
     };
   }
+  let stderr = match.stderr;
+  let codeStr = getOr(map(code, (c2) => c2.toString()), "unknown");
+  let detail = stderr === "" ? match.message : stderr;
+  return {
+    TAG: "Error",
+    _0: `Git grep failed (exit ` + codeStr + `): ` + detail
+  };
 }
-async function executeGitGrep(pattern2, searchPath, caseInsensitive, literal2, maxResults) {
-  let args = buildGitGrepArgs(pattern2, caseInsensitive, literal2, maxResults);
-  try {
-    let result = await execWithOptions(`git ` + args.join(" "), {
-      cwd: searchPath
-    });
-    if (result.TAG === "Ok") {
-      return {
-        TAG: "Ok",
-        _0: parseGrepOutput(result._0.stdout, maxResults)
-      };
-    }
-    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: {
-            files: [],
-            totalMatches: 0,
-            truncated: false
-          }
-        };
-      }
-      exit = 1;
-    } else {
-      exit = 1;
-    }
-    if (exit === 1) {
-      return {
-        TAG: "Error",
-        _0: `Git grep failed: ` + match.stderr
-      };
-    }
-  } catch (raw_exn) {
-    let exn = internalToException(raw_exn);
-    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
+function buildPlainGrepArgs(pattern2, searchPath, caseInsensitive, literal3, maxResults, glob, type_) {
+  let args = ["-rn"];
+  if (caseInsensitive) {
+    args.push("-i");
+  }
+  if (literal3) {
+    args.push("-F");
+  }
+  args.push("-m");
+  args.push(maxResults.toString());
+  if (glob !== void 0) {
+    args.push("--include");
+    args.push(glob);
+  } else if (type_ !== void 0) {
+    args.push("--include");
+    args.push(`*.` + type_);
+  }
+  args.push("--exclude-dir=node_modules");
+  args.push("--exclude-dir=.git");
+  args.push("--exclude-dir=dist");
+  args.push("--exclude-dir=build");
+  args.push("--exclude-dir=_build");
+  args.push(pattern2);
+  args.push(searchPath);
+  return args;
+}
+async function executePlainGrep(pattern2, searchPath, caseInsensitive, literal3, maxResults, glob, type_) {
+  let args = buildPlainGrepArgs(pattern2, searchPath, caseInsensitive, literal3, maxResults, glob, type_);
+  let result = await spawnResult("grep", args, void 0);
+  if (result.TAG === "Ok") {
     return {
-      TAG: "Error",
-      _0: `Git grep execution failed: ` + msg
+      TAG: "Ok",
+      _0: parseGrepOutput(result._0.stdout, maxResults)
     };
   }
+  let match = result._0;
+  let code = match.code;
+  if (code === 1) {
+    return {
+      TAG: "Ok",
+      _0: {
+        files: [],
+        totalMatches: 0,
+        truncated: false
+      }
+    };
+  }
+  let stderr = match.stderr;
+  let codeStr = getOr(map(code, (c2) => c2.toString()), "unknown");
+  let detail = stderr === "" ? match.message : stderr;
+  return {
+    TAG: "Error",
+    _0: `Grep failed (exit ` + codeStr + `): ` + detail
+  };
 }
 async function execute(ctx2, input) {
   let searchPath = resolveSearchPath(ctx2.sourceRoot, input.path);
   let caseInsensitive = getOr(input.case_insensitive, false);
-  let literal2 = getOr(input.literal, false);
-  let maxResults = getOr(input.max_results, 100);
+  let literal3 = getOr(input.literal, false);
+  let maxResults = getOr(input.max_results, 20);
+  let gitGrepWithFallback = async () => {
+    let gitResult = await executeGitGrep(input.pattern, searchPath, caseInsensitive, literal3, maxResults, input.glob, input.type);
+    if (gitResult.TAG === "Ok") {
+      return gitResult;
+    } else {
+      return await executePlainGrep(input.pattern, searchPath, caseInsensitive, literal3, maxResults, input.glob, input.type);
+    }
+  };
   let rgPath = getRipgrepPath();
   if (rgPath === void 0) {
-    return await executeGitGrep(input.pattern, searchPath, caseInsensitive, literal2, maxResults);
+    return await gitGrepWithFallback();
   }
-  let result = await executeRipgrep(rgPath, input.pattern, searchPath, input.type, input.glob, caseInsensitive, literal2, maxResults);
+  let result = await executeRipgrep(rgPath, input.pattern, searchPath, input.type, input.glob, caseInsensitive, literal3, maxResults);
   if (result.TAG === "Ok") {
     return result;
   } else {
-    return await executeGitGrep(input.pattern, searchPath, caseInsensitive, literal2, maxResults);
+    return await gitGrepWithFallback();
   }
 }
-var name2 = "grep";
 var description = `Fast content search tool that finds files containing specific text or patterns, returning matching lines sorted by file modification time.
 
 WHEN TO USE THIS TOOL:
@@ -4439,6 +4870,7 @@ 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)),
@@ -4467,7 +4899,7 @@ async function execute2(ctx2, input) {
   }
   let result = err._0;
   try {
-    let content = await Fs2.promises.readFile(result.resolvedPath, "utf8");
+    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);
@@ -4495,7 +4927,6 @@ async function execute2(ctx2, input) {
     };
   }
 }
-var name3 = "read_file";
 var description2 = `Reads a file from the filesystem.
 
 Parameters:
@@ -4519,6 +4950,7 @@ function map3(opt, f) {
 }
 
 // ../frontman-core/src/tools/FrontmanCore__Tool__ListFiles.res.mjs
+var name4 = ToolNames.listFiles;
 var inputSchema3 = schema2((s2) => ({
   path: s2.m(option2(string2))
 }));
@@ -4594,20 +5026,20 @@ async function execute3(ctx2, input) {
   }
   try {
     let fullPath = err._0.resolvedPath;
-    let entries = await Fs2.promises.readdir(fullPath);
-    let filteredEntriesResult = map3(await getIgnoredEntries(fullPath, entries), (ignored) => entries.filter((name10) => !ignored.includes(name10)));
+    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
       };
     }
-    let entriesWithStats = await Promise.all(filteredEntriesResult._0.map(async (name10) => {
-      let entryPath = Nodepath.join(fullPath, name10);
-      let stats = await Fs2.promises.stat(entryPath);
+    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: name10,
-        path: Nodepath.join(path, name10),
+        name: name11,
+        path: Nodepath.join(path, name11),
         isFile: stats.isFile(),
         isDirectory: stats.isDirectory()
       };
@@ -4625,16 +5057,18 @@ async function execute3(ctx2, input) {
     };
   }
 }
-var name4 = "list_files";
 var description3 = `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) => ({
   path: s2.m(string2),
-  content: s2.m(string2)
+  content: s2.m(option2(string2)),
+  image_ref: s2.m(option2(string2)),
+  encoding: s2.m(option2(literal2("base64")))
 }));
 var pathContextSchema2 = schema2((s2) => ({
   sourceRoot: s2.m(string2),
@@ -4644,7 +5078,35 @@ var pathContextSchema2 = schema2((s2) => ({
 var outputSchema4 = schema2((s2) => ({
   _context: s2.m(option2(pathContextSchema2))
 }));
+function writeContent(resolvedPath, content, encoding) {
+  if (encoding === void 0) {
+    return Fs3.promises.writeFile(resolvedPath, content, "utf8");
+  }
+  let buffer = Nodebuffer.Buffer.from(content, "base64");
+  return Fs3.promises.writeFile(resolvedPath, buffer);
+}
 async function execute4(ctx2, input) {
+  let match = input.content;
+  let match$1 = input.image_ref;
+  if (match === void 0) {
+    if (match$1 !== void 0) {
+      return {
+        TAG: "Error",
+        _0: "image_ref must be resolved to content before execution"
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: "Either content or image_ref must be provided"
+      };
+    }
+  }
+  if (match$1 !== void 0) {
+    return {
+      TAG: "Error",
+      _0: "Provide either content or image_ref, not both"
+    };
+  }
   let err = resolve2(ctx2.sourceRoot, input.path);
   if (err.TAG !== "Ok") {
     return {
@@ -4653,12 +5115,11 @@ async function execute4(ctx2, input) {
     };
   }
   let result = err._0;
-  let dirPath = dirname3(result);
   try {
-    await Fs2.promises.mkdir(dirPath, {
+    await Fs3.promises.mkdir(dirname3(result), {
       recursive: true
     });
-    await Fs2.promises.writeFile(result.resolvedPath, input.content, "utf8");
+    await writeContent(result.resolvedPath, match, input.encoding);
     return {
       TAG: "Ok",
       _0: {
@@ -4678,15 +5139,18 @@ async function execute4(ctx2, input) {
     };
   }
 }
-var name5 = "write_file";
 var description4 = `Writes content to a file.
 
 Parameters:
 - path (required): Path to file - either relative to source root or absolute (must be under source root)
-- content (required): Content to write
+- content: Text content to write (mutually exclusive with image_ref)
+- image_ref: URI of a user-attached image to save (e.g., "attachment://att_abc123/photo.png"). Use this to save images the user has pasted into the chat. Mutually exclusive with content.
+- encoding: Set to "base64" when writing binary data (used internally when image_ref is resolved)
 
+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) => ({
   path: s2.m(string2)
 }));
@@ -4699,7 +5163,7 @@ async function execute5(ctx2, input) {
     };
   }
   try {
-    await Fs2.promises.access(toString(msg._0));
+    await Fs3.promises.access(toString(msg._0));
     return {
       TAG: "Ok",
       _0: true
@@ -4711,7 +5175,6 @@ async function execute5(ctx2, input) {
     };
   }
 }
-var name6 = "file_exists";
 var description5 = `Checks if a file or directory exists.
 
 Parameters:
@@ -4719,13 +5182,294 @@ Parameters:
 
 Returns true if the path exists, false otherwise.`;
 var outputSchema5 = bool2;
+
+// ../bindings/src/Lighthouse.res.mjs
+var run = ((url2, flags2) => import('module').then(({ createRequire }) => {
+  const req = createRequire(import.meta.url);
+  try {
+    const mod = req("lighthouse");
+    const lighthouse = mod.default ?? mod;
+    return lighthouse(url2, flags2);
+  } catch (e) {
+    if (e.code === "MODULE_NOT_FOUND") {
+      throw new Error("lighthouse is not installed. Run: npm install lighthouse");
+    }
+    throw e;
+  }
+}));
+
+// ../bindings/src/ChromeLauncher.res.mjs
+var launch = ((options) => import('module').then(({ createRequire }) => {
+  const req = createRequire(import.meta.url);
+  try {
+    const mod = req("chrome-launcher");
+    return mod.launch(options);
+  } catch (e) {
+    if (e.code === "MODULE_NOT_FOUND") {
+      throw new Error("chrome-launcher is not installed. Run: npm install chrome-launcher");
+    }
+    throw e;
+  }
+}));
+
+// ../frontman-core/src/tools/FrontmanCore__Tool__Lighthouse.res.mjs
+var rewriteUrlForRuntime = ((url2) => {
+  const override = process.env.FRONTMAN_LIGHTHOUSE_DEVPOD_LOCALHOST;
+  const worktreeId = process.env.WORKTREE_ID;
+  const overrideLower = typeof override === "string" ? override.toLowerCase() : "";
+  const devpodMode = overrideLower === "1" || overrideLower === "true" || overrideLower === "yes" || overrideLower === "on" || typeof worktreeId === "string";
+  if (!devpodMode) {
+    return url2;
+  }
+  let parsed;
+  try {
+    parsed = new URL(url2);
+  } catch {
+    return url2;
+  }
+  const host2 = parsed.hostname;
+  const mapToLocalhost = (port2, protocol) => {
+    parsed.protocol = protocol;
+    parsed.hostname = "127.0.0.1";
+    parsed.port = String(port2);
+    return parsed.toString();
+  };
+  if (host2.endsWith(".nextjs.frontman.local")) {
+    return mapToLocalhost(3e3, "http:");
+  }
+  if (host2.endsWith(".vite.frontman.local")) {
+    return mapToLocalhost(5173, "http:");
+  }
+  if (host2.endsWith(".api.frontman.local")) {
+    return mapToLocalhost(4e3, "https:");
+  }
+  return url2;
+});
 var inputSchema6 = schema2((s2) => ({
+  url: s2.m(string2),
+  preset: s2.m(option2(string2))
+}));
+var auditIssueSchema = schema2((s2) => ({
+  id: s2.m(string2),
+  title: s2.m(string2),
+  description: s2.m(string2),
+  score: s2.m(float2),
+  displayValue: s2.m(option2(string2))
+}));
+var categoryResultSchema = schema2((s2) => ({
+  id: s2.m(string2),
+  title: s2.m(string2),
+  score: s2.m(int2),
+  topIssues: s2.m(array2(auditIssueSchema))
+}));
+var outputSchema6 = schema2((s2) => ({
+  url: s2.m(string2),
+  fetchTime: s2.m(string2),
+  categories: s2.m(array2(categoryResultSchema)),
+  overallScore: s2.m(int2),
+  warnings: s2.m(array2(string2))
+}));
+var categoryIds = [
+  "performance",
+  "accessibility",
+  "best-practices",
+  "seo"
+];
+function getErrorMessage(exn) {
+  let jsError = fromException(exn);
+  if (jsError === void 0) {
+    return String(exn);
+  }
+  let jsError$1 = valFromOption(jsError);
+  let message3 = getOr(message2(jsError$1), "Unknown error");
+  let stack2 = jsError$1.stack;
+  if (stack2 !== void 0) {
+    return message3 + `
+` + stack2;
+  } else {
+    return message3;
+  }
+}
+function getTopIssues(category, audits, maxIssues) {
+  return filterMap(category.auditRefs, (ref) => audits[ref.id]).filter((audit) => {
+    let score = audit.score;
+    if (!(score == null) && (audit.scoreDisplayMode === "binary" || audit.scoreDisplayMode === "numeric" || audit.scoreDisplayMode === "metricSavings")) {
+      return score < 1;
+    } else {
+      return false;
+    }
+  }).toSorted((a, b) => {
+    let scoreA = getOr(fromNullable(a.score), 0);
+    let scoreB = getOr(fromNullable(b.score), 0);
+    return scoreA - scoreB;
+  }).slice(0, maxIssues).map((audit) => ({
+    id: audit.id,
+    title: audit.title,
+    description: audit.description,
+    score: getOr(fromNullable(audit.score), 0),
+    displayValue: audit.displayValue
+  }));
+}
+function processLhr(lhr) {
+  let categories = filterMap(categoryIds, (id) => lhr.categories[id]).map((category) => {
+    let s2 = category.score;
+    let score = !(s2 == null) ? Math.round(s2 * 100) | 0 : 0;
+    let topIssues = getTopIssues(category, lhr.audits, 3);
+    return {
+      id: category.id,
+      title: category.title,
+      score,
+      topIssues
+    };
+  });
+  let totalScore = reduce(categories, 0, (acc, cat) => acc + cat.score | 0);
+  let len = categories.length;
+  let overallScore = len !== 0 ? div(totalScore, len) : 0;
+  return {
+    url: lhr.finalDisplayedUrl,
+    fetchTime: lhr.fetchTime,
+    categories,
+    overallScore,
+    warnings: lhr.runWarnings
+  };
+}
+async function killChrome(chrome) {
+  try {
+    return await chrome.kill();
+  } catch (exn) {
+    return;
+  }
+}
+async function runLighthouse(chrome, url2, preset) {
+  let port2 = chrome.port;
+  let flags_port = port2;
+  let flags_output = "json";
+  let flags_logLevel = "error";
+  let flags_onlyCategories = categoryIds;
+  let flags_formFactor = preset;
+  let flags_screenEmulation = {
+    disabled: preset === "desktop"
+  };
+  let flags_throttlingMethod = "simulate";
+  let flags2 = {
+    port: flags_port,
+    output: flags_output,
+    logLevel: flags_logLevel,
+    onlyCategories: flags_onlyCategories,
+    formFactor: flags_formFactor,
+    screenEmulation: flags_screenEmulation,
+    throttlingMethod: flags_throttlingMethod
+  };
+  try {
+    let runnerResult = await run(url2, flags2);
+    await killChrome(chrome);
+    if (runnerResult == null) {
+      return {
+        TAG: "Error",
+        _0: "Lighthouse returned no results. The URL may be unreachable."
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: processLhr(runnerResult.lhr)
+      };
+    }
+  } catch (raw_exn) {
+    let exn = internalToException(raw_exn);
+    await killChrome(chrome);
+    let msg = getErrorMessage(exn);
+    return {
+      TAG: "Error",
+      _0: `Lighthouse audit failed: ` + msg
+    };
+  }
+}
+async function execute6(_ctx, input) {
+  let preset = getOr(input.preset, "desktop");
+  let auditUrl = rewriteUrlForRuntime(input.url);
+  switch (preset) {
+    case "desktop":
+    case "mobile":
+      break;
+    default:
+      return {
+        TAG: "Error",
+        _0: `Invalid preset "` + preset + `". Must be "desktop" or "mobile".`
+      };
+  }
+  try {
+    let chrome = await launch({
+      chromeFlags: [
+        "--headless",
+        "--disable-gpu",
+        "--no-sandbox",
+        "--disable-dev-shm-usage"
+      ]
+    });
+    let result = await runLighthouse(chrome, auditUrl, preset);
+    if (result.TAG !== "Ok") {
+      return result;
+    }
+    let out = result._0;
+    if (auditUrl === input.url) {
+      return {
+        TAG: "Ok",
+        _0: out
+      };
+    }
+    let warning = `DevPod mode: audited local URL ` + auditUrl + ` instead of ` + input.url + `.`;
+    return {
+      TAG: "Ok",
+      _0: {
+        url: input.url,
+        fetchTime: out.fetchTime,
+        categories: out.categories,
+        overallScore: out.overallScore,
+        warnings: concatMany([
+          [warning],
+          out.warnings
+        ])
+      }
+    };
+  } catch (raw_exn) {
+    let exn = internalToException(raw_exn);
+    let msg = getErrorMessage(exn);
+    return {
+      TAG: "Error",
+      _0: `Failed to launch Chrome: ` + msg + `. Make sure Chrome is installed on the system.`
+    };
+  }
+}
+var name7 = "lighthouse";
+var description6 = `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
+- When implementing new UI components to check accessibility
+- Before deploying to verify web best practices
+- To diagnose why a page feels slow
+
+PARAMETERS:
+- url (required): The full URL to audit (e.g., "http://localhost:3000/")
+- preset (optional): "desktop" (default) or "mobile" for mobile emulation
+  IMPORTANT: Check the current_page context for device_emulation - if a mobile device is being emulated (e.g., iPhone, Pixel), use preset: "mobile" to match the user's testing context.
+
+OUTPUT:
+Returns scores (0-100) for each category plus the top 3 issues to fix in each category.
+Higher scores are better. Issues include actionable descriptions.
+
+LIMITATIONS:
+- Requires Chrome to be installed on the system
+- Takes 15-30 seconds to complete
+- Results can vary between runs (\xB15 points is normal)
+- URL must be accessible from the machine running the audit`;
+var name8 = ToolNames.searchFiles;
+var inputSchema7 = schema2((s2) => ({
   pattern: s2.m(string2),
   path: s2.m(option2(string2)),
-  type: s2.m(option2(string2)),
   max_results: s2.m(option2(int2))
 }));
-var outputSchema6 = schema2((s2) => ({
+var outputSchema7 = schema2((s2) => ({
   files: s2.m(array2(string2)),
   totalResults: s2.m(int2),
   truncated: s2.m(bool2)
@@ -4746,56 +5490,38 @@ function buildRipgrepArgs2(searchPath) {
   args.push(searchPath);
   return args;
 }
-function parseRipgrepOutput(output, pattern2, type_, maxResults) {
-  let lines = output.trim().split("\n").filter((line) => line !== "");
-  let patternLower = pattern2.toLowerCase();
-  let matchedFiles = lines.filter((filePath) => {
-    let fileName2 = Nodepath.basename(filePath).toLowerCase();
-    let patternMatches;
-    if (patternLower === "") {
-      patternMatches = true;
-    } else if (patternLower.includes("*")) {
-      let parts = patternLower.split("*");
-      let partsLength = parts.length;
-      patternMatches = reduceWithIndex(parts, true, (matches2, part, idx) => {
-        if (matches2) {
-          if (part === "") {
-            return true;
-          } else if (idx === 0) {
-            return fileName2.startsWith(part);
-          } else if (idx === (partsLength - 1 | 0)) {
-            return fileName2.endsWith(part);
-          } else {
-            return fileName2.includes(part);
-          }
-        } else {
-          return false;
-        }
-      });
-    } else {
-      patternMatches = fileName2.includes(patternLower);
-    }
-    let typeMatches;
-    if (type_ !== void 0) {
-      switch (type_) {
-        case "directory":
-          typeMatches = filePath.endsWith("/");
-          break;
-        case "file":
-          typeMatches = !filePath.endsWith("/");
-          break;
-        default:
-          typeMatches = true;
+function matchesPattern(fileName2, patternLower) {
+  let fileNameLower = fileName2.toLowerCase();
+  if (patternLower === "") {
+    return true;
+  }
+  if (!patternLower.includes("*")) {
+    return fileNameLower.includes(patternLower);
+  }
+  let parts = patternLower.split("*");
+  let partsLength = parts.length;
+  return reduceWithIndex(parts, true, (matches2, part, idx) => {
+    if (matches2) {
+      if (part === "") {
+        return true;
+      } else if (idx === 0) {
+        return fileNameLower.startsWith(part);
+      } else if (idx === (partsLength - 1 | 0)) {
+        return fileNameLower.endsWith(part);
+      } else {
+        return fileNameLower.includes(part);
       }
-    } else {
-      typeMatches = true;
-    }
-    if (patternMatches) {
-      return typeMatches;
     } else {
       return false;
     }
   });
+}
+function filterAndPaginate(lines, pattern2, maxResults) {
+  let patternLower = pattern2.toLowerCase();
+  let matchedFiles = lines.filter((filePath) => {
+    let fileName2 = Nodepath.basename(filePath);
+    return matchesPattern(fileName2, patternLower);
+  });
   let truncated = matchedFiles.length > maxResults;
   let files = matchedFiles.slice(0, maxResults);
   return {
@@ -4804,156 +5530,110 @@ function parseRipgrepOutput(output, pattern2, type_, maxResults) {
     truncated
   };
 }
-function parseGitLsFilesOutput(output, maxResults) {
-  let lines = output.trim().split("\n").filter((line) => line !== "");
-  let truncated = lines.length > maxResults;
-  let files = lines.slice(0, maxResults);
-  return {
-    files,
-    totalResults: lines.length,
-    truncated
-  };
-}
-async function executeRipgrep2(rgPath, pattern2, searchPath, type_, maxResults) {
+async function executeRipgrep2(rgPath, pattern2, searchPath, maxResults) {
   let args = buildRipgrepArgs2(searchPath);
-  let command = rgPath + ` ` + args.join(" ");
-  try {
-    let result = await exec(command);
-    if (result.TAG === "Ok") {
-      return {
-        TAG: "Ok",
-        _0: parseRipgrepOutput(result._0.stdout, pattern2, type_, maxResults)
-      };
-    }
-    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: {
-            files: [],
-            totalResults: 0,
-            truncated: false
-          }
-        };
-      }
-      exit = 1;
-    } else {
-      exit = 1;
-    }
-    if (exit === 1) {
-      return {
-        TAG: "Error",
-        _0: `Ripgrep failed: ` + match.stderr
-      };
-    }
-  } catch (raw_exn) {
-    let exn = internalToException(raw_exn);
-    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
+  let result = await spawnResult(rgPath, args, void 0);
+  if (result.TAG === "Ok") {
+    let lines = result._0.stdout.trim().split("\n").filter((line) => line !== "");
     return {
-      TAG: "Error",
-      _0: `Ripgrep execution failed: ` + msg
+      TAG: "Ok",
+      _0: filterAndPaginate(lines, pattern2, maxResults)
     };
   }
+  let match = result._0;
+  let match$1 = match.code;
+  if (match$1 === 1) {
+    return {
+      TAG: "Ok",
+      _0: {
+        files: [],
+        totalResults: 0,
+        truncated: false
+      }
+    };
+  }
+  return {
+    TAG: "Error",
+    _0: `Ripgrep failed: ` + match.stderr
+  };
 }
 async function executeGitLsFiles(pattern2, searchPath, maxResults) {
-  try {
-    let command = `git ls-files | grep -i "` + pattern2 + `"`;
-    let result = await execWithOptions(command, {
-      cwd: searchPath
-    });
-    if (result.TAG === "Ok") {
-      return {
-        TAG: "Ok",
-        _0: parseGitLsFilesOutput(result._0.stdout, maxResults)
-      };
-    }
-    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: {
-            files: [],
-            totalResults: 0,
-            truncated: false
-          }
-        };
-      }
-      exit = 1;
-    } else {
-      exit = 1;
-    }
-    if (exit === 1) {
-      return {
-        TAG: "Error",
-        _0: `Git ls-files failed: ` + match.stderr
-      };
-    }
-  } catch (raw_exn) {
-    let exn = internalToException(raw_exn);
-    let msg = getOr(flatMap(fromException(exn), message2), "Unknown error");
+  let result = await spawnResult("git", ["ls-files"], searchPath);
+  if (result.TAG === "Ok") {
+    let lines = result._0.stdout.trim().split("\n").filter((line) => line !== "");
     return {
-      TAG: "Error",
-      _0: `Git ls-files execution failed: ` + msg
+      TAG: "Ok",
+      _0: filterAndPaginate(lines, pattern2, maxResults)
+    };
+  }
+  let match = result._0;
+  let match$1 = match.code;
+  if (match$1 === 1) {
+    return {
+      TAG: "Ok",
+      _0: {
+        files: [],
+        totalResults: 0,
+        truncated: false
+      }
     };
   }
+  return {
+    TAG: "Error",
+    _0: `Git ls-files failed: ` + match.stderr
+  };
 }
-async function execute6(ctx2, input) {
+async function execute7(ctx2, input) {
   let searchPath = resolveSearchPath(ctx2.sourceRoot, input.path);
-  let maxResults = getOr(input.max_results, 100);
+  let maxResults = getOr(input.max_results, 20);
   let rgPath = getRipgrepPath2();
   if (rgPath === void 0) {
     return await executeGitLsFiles(input.pattern, searchPath, maxResults);
   }
-  let result = await executeRipgrep2(rgPath, input.pattern, searchPath, input.type, maxResults);
+  let result = await executeRipgrep2(rgPath, input.pattern, searchPath, maxResults);
   if (result.TAG === "Ok") {
     return result;
   } else {
     return await executeGitLsFiles(input.pattern, searchPath, maxResults);
   }
 }
-var name7 = "search_files";
-var description6 = `Fast file and directory name search tool that finds files/directories matching a pattern.
+var description7 = `Fast file name search tool that finds files matching a pattern.
 
 WHEN TO USE THIS TOOL:
-- Use when you need to find files or directories by name pattern
+- 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.
 
 PARAMETERS:
 - pattern (required): The filename pattern to search for (supports glob-like patterns)
 - path (optional): Directory to search in (defaults to source root)
-- type (optional): Filter by type - "file" for files only, "directory" for directories only
 - 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 directories named "components": pattern="components", type="directory"
 - Find files in specific directory: pattern="*.json", path="src/config"
 
 OUTPUT:
-Returns list of matching file/directory paths.
+Returns list of matching file paths.
 Results are 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`;
-var inputSchema7 = schema2((s2) => ({
+- Respects .gitignore when using git ls-files fallback
+- Only finds files, not directories`;
+var name9 = ToolNames.loadAgentInstructions;
+var inputSchema8 = schema2((s2) => ({
   startPath: s2.m(option2(string2))
 }));
 var instructionFileSchema = schema2((s2) => ({
   content: s2.m(string2),
   fullPath: s2.m(string2)
 }));
-var outputSchema7 = array2(instructionFileSchema);
+var outputSchema8 = array2(instructionFileSchema);
 var agentsVariants = [
   "Agents.md",
   ".claude/Agents.md",
@@ -4966,7 +5646,7 @@ var claudeVariants = [
 ];
 async function findFileCaseInsensitive(dir, targetFileName) {
   try {
-    let files = await Fs2.promises.readdir(dir);
+    let files = await Fs3.promises.readdir(dir);
     let targetLower = targetFileName.toLowerCase();
     let found = files.find((file) => file.toLowerCase() === targetLower);
     if (found !== void 0) {
@@ -4986,7 +5666,7 @@ async function loadIfExists(path) {
     return;
   }
   try {
-    let content = await Fs2.promises.readFile(actualPath, "utf8");
+    let content = await Fs3.promises.readFile(actualPath, "utf8");
     return {
       content,
       fullPath: actualPath
@@ -5023,7 +5703,7 @@ async function walkUpDirectories(current, acc) {
   let newAcc = acc.concat(filesAtLevel);
   return await walkUpDirectories(Nodepath.dirname(current), newAcc);
 }
-async function execute7(ctx2, input) {
+async function execute8(ctx2, input) {
   let inputPath = getOr(input.startPath, ".");
   let msg = resolve(ctx2.sourceRoot, inputPath);
   if (msg.TAG !== "Ok") {
@@ -5048,8 +5728,7 @@ async function execute7(ctx2, input) {
     };
   }
 }
-var name8 = "load_agent_instructions";
-var description7 = `Discovers and loads agent instruction files (Agents.md or CLAUDE.md) following Claude Code's discovery algorithm.
+var description8 = `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).
@@ -5099,11 +5778,11 @@ function coreTools() {
         visibleToAgent: true
       },
       {
-        name: name8,
-        description: description7,
-        inputSchema: inputSchema7,
-        outputSchema: outputSchema7,
-        execute: execute7,
+        name: name9,
+        description: description8,
+        inputSchema: inputSchema8,
+        outputSchema: outputSchema8,
+        execute: execute8,
         visibleToAgent: false
       },
       {
@@ -5114,6 +5793,14 @@ function coreTools() {
         execute,
         visibleToAgent: true
       },
+      {
+        name: name8,
+        description: description7,
+        inputSchema: inputSchema7,
+        outputSchema: outputSchema7,
+        execute: execute7,
+        visibleToAgent: true
+      },
       {
         name: name7,
         description: description6,
@@ -5130,8 +5817,8 @@ function addTools(registry, newTools) {
     tools: registry.tools.concat(newTools)
   };
 }
-function getToolByName(registry, name10) {
-  return registry.tools.find((m) => m.name === name10);
+function getToolByName(registry, name11) {
+  return registry.tools.find((m) => m.name === name11);
 }
 function serializeTool(m) {
   return {
@@ -5164,12 +5851,12 @@ var toolCallRequestSchema = schema2((s2) => ({
 var protocolVersion = "1.0";
 
 // ../frontman-core/src/FrontmanCore__Server.res.mjs
-async function executeTool(registry, ctx2, name10, $$arguments) {
-  let toolModule = getToolByName(registry, name10);
+async function executeTool(registry, ctx2, name11, $$arguments) {
+  let toolModule = getToolByName(registry, name11);
   if (toolModule === void 0) {
     return {
       TAG: "ToolNotFound",
-      _0: name10
+      _0: name11
     };
   }
   let toolCtx_projectRoot = ctx2.projectRoot;
@@ -5331,16 +6018,6 @@ async function handleToolCall(registry, config, req) {
     status: 400
   });
 }
-function toRelativePath2(absolutePath, sourceRoot) {
-  let normalizedRoot = sourceRoot.endsWith("/") ? sourceRoot : sourceRoot + "/";
-  if (absolutePath.startsWith(normalizedRoot)) {
-    return absolutePath.slice(normalizedRoot.length, absolutePath.length);
-  } else if (absolutePath.startsWith(sourceRoot)) {
-    return absolutePath.slice(sourceRoot.length, absolutePath.length);
-  } else {
-    return absolutePath;
-  }
-}
 function corsHeaders() {
   return Object.fromEntries([
     [
@@ -5391,7 +6068,7 @@ async function handleResolveSourceLocation(config, req) {
         parent: void 0
       };
       let resolved = await Te(sourceLocation);
-      let relativeFile = toRelativePath2(resolved.file, config.sourceRoot);
+      let relativeFile = toRelativePath(config.sourceRoot, resolved.file);
       let responseJson = Object.fromEntries([
         [
           "componentName",
@@ -5441,41 +6118,35 @@ async function handleResolveSourceLocation(config, req) {
     status: 400
   });
 }
-var inputSchema8 = schema2((s2) => ({
+var dynamicTypeSchema = union2([
+  literal2("static"),
+  literal2("single"),
+  literal2("rest"),
+  literal2("optional")
+]);
+var inputSchema9 = schema2((s2) => ({
   placeholder: s2.m(option2(bool2))
 }));
 var pageSchema = schema2((s2) => ({
   path: s2.m(string2),
   file: s2.m(string2),
   isDynamic: s2.m(bool2),
-  dynamicType: s2.m(string2)
+  dynamicType: s2.m(dynamicTypeSchema)
 }));
-var outputSchema8 = array2(pageSchema);
+var outputSchema9 = array2(pageSchema);
 function analyzeDynamicSegment(segment) {
   if (segment.startsWith("[[") && segment.endsWith("]]")) {
-    return "OptionalParam";
+    return "optional";
   } else if (segment.startsWith("[...") && segment.endsWith("]")) {
-    return "RestParam";
+    return "rest";
   } else if (segment.startsWith("[") && segment.endsWith("]")) {
-    return "SingleParam";
+    return "single";
   } else {
-    return "Static";
-  }
-}
-function dynamicTypeToString(dt) {
-  switch (dt) {
-    case "Static":
-      return "static";
-    case "SingleParam":
-      return "single";
-    case "RestParam":
-      return "rest";
-    case "OptionalParam":
-      return "optional";
+    return "static";
   }
 }
 function isDynamicSegment(segment) {
-  return analyzeDynamicSegment(segment) !== "Static";
+  return analyzeDynamicSegment(segment) !== "static";
 }
 function fileToRoute(filePath) {
   let p2 = filePath.replace(/\.(astro|md|mdx|html)$/, "").replace(/\/index$/, "");
@@ -5486,71 +6157,81 @@ function fileToRoute(filePath) {
   }
 }
 function getMostSignificantDynamicType(segments) {
-  return reduce(segments, "Static", (acc, segment) => {
+  return reduce(segments, "static", (acc, segment) => {
     let segType = analyzeDynamicSegment(segment);
-    if (segType === "RestParam") {
-      return "RestParam";
+    if (segType === "rest") {
+      return "rest";
     }
     switch (acc) {
-      case "Static":
-      case "SingleParam":
+      case "static":
+      case "single":
         break;
-      case "RestParam":
-        return "RestParam";
-      case "OptionalParam":
-        return "OptionalParam";
+      case "rest":
+        return "rest";
+      case "optional":
+        return "optional";
     }
     switch (segType) {
-      case "Static":
-        if (acc === "Static") {
-          return "Static";
+      case "static":
+        if (acc === "static") {
+          return "static";
         } else {
-          return "SingleParam";
+          return "single";
         }
-      case "SingleParam":
-        return "SingleParam";
-      case "OptionalParam":
-        return "OptionalParam";
+      case "single":
+        return "single";
+      case "optional":
+        return "optional";
     }
   });
 }
-async function findPages(baseDir, currentPath, projectRoot) {
+async function findPages(baseDir, currentPath, projectRoot, sourceRoot) {
   let fullPath = Nodepath.join(projectRoot, baseDir, currentPath);
   try {
-    let entries = await Fs2.promises.readdir(fullPath);
+    let entries = await Fs3.promises.readdir(fullPath);
     return (await Promise.all(entries.map(async (entry) => {
       let entryPath = Nodepath.join(fullPath, entry);
-      let stats = await Fs2.promises.stat(entryPath);
+      let stats = await Fs3.promises.lstat(entryPath);
+      if (stats.isSymbolicLink()) {
+        return [];
+      }
       if (stats.isDirectory()) {
         if (entry.startsWith("_") || entry === "api" || entry === "components") {
           return [];
         } else {
-          return await findPages(baseDir, Nodepath.join(currentPath, entry), projectRoot);
+          return await findPages(baseDir, Nodepath.join(currentPath, entry), projectRoot, sourceRoot);
         }
       }
       if (!(entry.endsWith(".astro") || entry.endsWith(".md") || entry.endsWith(".mdx") || entry.endsWith(".html"))) {
         return [];
       }
-      let fileName2 = entry.replace(/\.(astro|md|mdx|html)$/, "");
-      let routePath = fileToRoute(Nodepath.join(currentPath, fileName2));
-      let segments = Nodepath.join(currentPath, fileName2).split("/");
+      let filePath = Nodepath.join(currentPath, entry);
+      let routePath = fileToRoute(filePath);
+      let filePathNoExt = filePath.replace(/\.(astro|md|mdx|html)$/, "");
+      let segments = filePathNoExt.split("/");
       let hasDynamic = segments.some(isDynamicSegment);
       let dynType = getMostSignificantDynamicType(segments);
+      let relativeToSourceRoot = toRelativePath(sourceRoot, entryPath);
       return [{
         path: routePath,
-        file: Nodepath.join(baseDir, currentPath, entry),
+        file: relativeToSourceRoot,
         isDynamic: hasDynamic,
-        dynamicType: dynamicTypeToString(dynType)
+        dynamicType: dynType
       }];
     }))).flat();
-  } catch (exn) {
-    return [];
+  } catch (raw_exn) {
+    let exn = internalToException(raw_exn);
+    let msg = getOr(flatMap(fromException(exn), message2), "");
+    if (msg.includes("ENOENT")) {
+      return [];
+    }
+    throw exn;
   }
 }
-async function execute8(ctx2, _input) {
+async function execute9(ctx2, _input) {
   try {
-    let srcPages = await findPages("src/pages", "", ctx2.projectRoot);
-    let rootPages = await findPages("pages", "", ctx2.projectRoot);
+    let srcPages = await findPages("src/pages", "", ctx2.projectRoot, ctx2.sourceRoot);
+    let rootPages = await findPages("pages", "", ctx2.projectRoot, ctx2.sourceRoot);
     let allPages = srcPages.concat(rootPages);
     return {
       TAG: "Ok",
@@ -5565,8 +6246,8 @@ async function execute8(ctx2, _input) {
     };
   }
 }
-var name9 = "get_client_pages";
-var description8 = `Lists Astro client pages from the pages directory.
+var name10 = "get_client_pages";
+var description9 = `Lists Astro client pages from the pages directory.
 
 Parameters: None
 
@@ -5575,11 +6256,11 @@ Excludes API routes (src/pages/api/) - focuses on renderable pages only.`;
 
 // src/FrontmanAstro__ToolRegistry.res.mjs
 var astroTools = [{
-  name: name9,
-  description: description8,
-  inputSchema: inputSchema8,
-  outputSchema: outputSchema8,
-  execute: execute8,
+  name: name10,
+  description: description9,
+  inputSchema: inputSchema9,
+  outputSchema: outputSchema9,
+  execute: execute9,
   visibleToAgent: true
 }];
 function make2() {
@@ -5677,8 +6358,8 @@ var collectRequestBody = (async function(req) {
   for await (const chunk of req) {
     chunks.push(chunk);
   }
-  const { Buffer: Buffer2 } = await import('buffer');
-  return Buffer2.concat(chunks);
+  const { Buffer: Buffer4 } = await import('buffer');
+  return Buffer4.concat(chunks);
 });
 
 // src/FrontmanAstro__ViteAdapter.res.mjs
@@ -5770,36 +6451,11 @@ 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>`;
 function getToolbarAppPath() {
   return new URL("./toolbar.js", import.meta.url).pathname;
 }
-var annotationCaptureScript = `(function() {
-  function captureAnnotations() {
-    var annotations = new Map();
-    document.querySelectorAll('[data-astro-source-file]').forEach(function(el) {
-      annotations.set(el, {
-        file: el.getAttribute('data-astro-source-file'),
-        loc: el.getAttribute('data-astro-source-loc')
-      });
-    });
-    window.__frontman_annotations__ = {
-      _map: annotations,
-      get: function(el) { return annotations.get(el); },
-      has: function(el) { return annotations.has(el); },
-      size: function() { return annotations.size; }
-    };
-  }
-  // Capture once on initial DOM parse
-  document.addEventListener('DOMContentLoaded', captureAnnotations);
-  // Re-capture on View Transitions (SPA navigations) \u2014 skips the initial
-  // page-load event since DOMContentLoaded already captured
-  var initialLoad = true;
-  document.addEventListener('astro:page-load', function() {
-    if (initialLoad) { initialLoad = false; return; }
-    captureAnnotations();
-  });
-})();`;
 function make3(configInput) {
   let config = makeFromObject(configInput);
   return {
@@ -5810,13 +6466,18 @@ function make3(configInput) {
           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()
           });
-          return ctx2.injectScript("head-inline", annotationCaptureScript);
+          return ctx2.injectScript("head-inline", annotationCaptureScript2);
         }
       },
       "astro:server:setup": (param) => {
@@ -5831,4 +6492,7 @@ function make3(configInput) {
 // src/FrontmanAstro.res.mjs
 var frontmanIntegration = make3;
 
-export { frontmanIntegration as default, frontmanIntegration };
+// index.mjs
+var index_default = frontmanIntegration;
+
+export { index_default as default, frontmanIntegration };