@frontman-ai/astro 0.1.6 → 0.1.7

package/dist/integration.js

@@ -4,6 +4,8 @@ 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";
@@ -2003,6 +2008,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 +2248,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
@@ -2253,9 +2261,11 @@ var bool2 = bool;
 var int2 = int;
 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;
@@ -4010,69 +4020,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);
@@ -4220,14 +4321,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 +4345,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 +4354,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,119 +4404,152 @@ 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
-          }
-        };
-      }
-      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");
+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: "Error",
-      _0: `Ripgrep execution failed: ` + msg
+      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
+      }
     };
   }
+  let stderr = match.stderr;
+  let detail = stderr === "" ? match.message : stderr;
+  return {
+    TAG: "Error",
+    _0: `Ripgrep failed: ` + 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
-          }
-        };
+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: "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
       }
-      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");
+    };
+  }
+  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
+  };
+}
+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";
@@ -4722,7 +4866,6 @@ var outputSchema5 = bool2;
 var inputSchema6 = 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) => ({
@@ -4746,56 +4889,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,113 +4929,67 @@ 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) {
   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 {
@@ -4918,34 +4997,34 @@ async function execute6(ctx2, input) {
   }
 }
 var name7 = "search_files";
-var description6 = `Fast file and directory name search tool that finds files/directories matching a pattern.
+var description6 = `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`;
+- Respects .gitignore when using git ls-files fallback
+- Only finds files, not directories`;
 var inputSchema7 = schema2((s2) => ({
   startPath: s2.m(option2(string2))
 }));
@@ -5331,16 +5410,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 +5460,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,6 +5510,12 @@ async function handleResolveSourceLocation(config, req) {
     status: 400
   });
 }
+var dynamicTypeSchema = union2([
+  literal2("static"),
+  literal2("single"),
+  literal2("rest"),
+  literal2("optional")
+]);
 var inputSchema8 = schema2((s2) => ({
   placeholder: s2.m(option2(bool2))
 }));
@@ -5448,34 +5523,22 @@ 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);
 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 +5549,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);
     return (await Promise.all(entries.map(async (entry) => {
       let entryPath = Nodepath.join(fullPath, entry);
-      let stats = await Fs2.promises.stat(entryPath);
+      let stats = await Fs2.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) {
   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",
@@ -5677,8 +5750,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: Buffer3 } = await import('buffer');
+  return Buffer3.concat(chunks);
 });
 
 // src/FrontmanAstro__ViteAdapter.res.mjs