agen-vektor 0.3.12 → 0.3.13

package/dist/tools/search.js

@@ -36,8 +36,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSearchTools = createSearchTools;
 /**
  * Search tools — search files by name or content.
- * Implementation uses ripgrep (rg) when available, else a pure-Node
+ * Implementation uses ripgrep when available, else a pure-Node
  * recursive walk with string matching (slow but dependency-free).
+ *
+ * Ripgrep resolution order:
+ *   1. @vscode/ripgrep bundled binary (optionalDependency — ships the rg
+ *      binary in the npm tarball via per-platform optionalDependencies, so
+ *      `npm i -g agen-vektor` auto-installs it with NO install scripts,
+ *      safe under npm 12's allowScripts=off default; skipped silently on
+ *      exotic platforms, where the fallback below takes over)
+ *   2. `rg` found on PATH
+ *   3. pure-Node fallback (always works)
  */
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -45,17 +54,40 @@ const node_child_process_1 = require("node:child_process");
 const node_util_1 = require("node:util");
 const execFileP = (0, node_util_1.promisify)(node_child_process_1.execFile);
 const IGNORE = new Set(['.git', 'node_modules', 'vendor', 'dist', 'build', '.cache', '.env', '.next', 'target', 'coverage']);
-function hasRg() {
+/** Bundled ripgrep from @vscode/ripgrep, when the optional dep installed. */
+function bundledRgPath() {
     try {
-        execFileSyncCheck('rg', ['--version']);
-        return true;
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { rgPath } = require('@vscode/ripgrep');
+        if (rgPath && fs.existsSync(rgPath))
+            return rgPath;
     }
     catch {
-        return false;
+        /* optional dep not installed (npm 12 script-skip / exotic platform) */
     }
+    return null;
+}
+/** Probe a candidate rg binary (bundled path or PATH lookup). */
+function probeRg(cmd) {
+    const res = (0, node_child_process_1.spawnSync)(cmd, ['--version'], { stdio: 'ignore' });
+    return !res.error;
+}
+function hasRg() {
+    // NOTE: spawnSync does NOT throw when the binary is missing — it returns
+    // { error: ENOENT }. A try/catch here never fired, so the old check
+    // wrongly returned true on machines without ripgrep and every search
+    // died with "spawn rg ENOENT" instead of using the pure-Node fallback.
+    const bundled = bundledRgPath();
+    if (bundled && probeRg(bundled))
+        return true;
+    return probeRg('rg');
 }
-function execFileSyncCheck(cmd, args) {
-    (0, node_child_process_1.spawnSync)(cmd, args, { stdio: 'ignore' });
+/** Which rg binary to actually spawn (bundled first, then PATH). */
+function rgCommand() {
+    const bundled = bundledRgPath();
+    if (bundled && probeRg(bundled))
+        return bundled;
+    return 'rg';
 }
 function walkFiles(dir, out, max) {
     let entries;
@@ -114,9 +146,16 @@ function createSearchTools() {
 }
 async function runRg(base, query, filename, max) {
     try {
-        const args = ['--no-ignore', '-m', '1', '--max-count', '3'];
+        // NOTE: --max-count must appear exactly once. Passing both "-m 1" and
+        // "--max-count 3" makes ripgrep exit with code 2 ("The argument
+        // '--max-count' was provided more than once") — a bug that silently
+        // broke every search when rg was installed.
+        const args = ['--no-ignore', '--line-number', '--max-count', '3'];
+        // "**/<dir>/**" so exclusion works even when the search base is an
+        // absolute path outside the rg process cwd (plain "!dir/**" only
+        // matches relative to cwd — bit us with tmpdir-based tests).
         for (const ig of IGNORE)
-            args.push('-g', `!${ig}/**`);
+            args.push('-g', `!**/${ig}/**`);
         if (filename) {
             args.push('-g', filename.includes('*') ? filename : `*${filename}*`);
         }
@@ -124,9 +163,12 @@ async function runRg(base, query, filename, max) {
             args.push('--', query, base);
         }
         else {
-            args.push('-l', '--', '', base);
+            // Filename-only search: --files lists matching paths. (The previous
+            // empty-pattern hack "rg -l -- '' <dir>" matched nothing, so
+            // filename search never returned results.)
+            args.push('--files', base);
         }
-        const { stdout } = await execFileP('rg', args, { maxBuffer: 10 * 1024 * 1024 });
+        const { stdout } = await execFileP(rgCommand(), args, { maxBuffer: 10 * 1024 * 1024 });
         const lines = stdout.split('\n').filter(Boolean).slice(0, max);
         if (lines.length === 0) {
             return { output: 'no matches found', summary: 'search: no matches' };
@@ -167,7 +209,15 @@ function fallbackSearch(base, query, filename, max, cwd) {
             try {
                 const content = fs.readFileSync(f, 'utf8');
                 if (content.includes(query)) {
-                    results.push(rel);
+                    // Include line numbers like ripgrep does — the tool description
+                    // promises "line numbers for text search".
+                    const lines = content.split('\n');
+                    const hits = [];
+                    for (let i = 0; i < lines.length && hits.length < 3; i++) {
+                        if (lines[i].includes(query))
+                            hits.push(`${rel}:${i + 1}`);
+                    }
+                    results.push(hits.length > 0 ? hits.join('\n') : rel);
                 }
             }
             catch {