salmon-loop 0.4.1 → 0.5.0

package/dist/core/tools/builtin/ast.js

@@ -3,8 +3,13 @@ import { z } from 'zod';
 import { text } from '../../../locales/index.js';
 import { readFile } from '../../adapters/fs/node-fs.js';
 import { AstParser } from '../../ast/parser.js';
+import { extractImportSpecifiers } from '../../context/ast/import-extractor.js';
+import { resolveImportCandidates } from '../../context/ast/module-resolver.js';
+import { getLogger } from '../../observability/logger.js';
 import { tryGetPluginRegistry } from '../../plugin/registry.js';
+import { spawnCommand } from '../../runtime/process-runner.js';
 import { Phase } from '../../types/runtime.js';
+import { normalizePath } from '../../utils/path.js';
 import { pathPrefixResource } from '../parallel/resource-helpers.js';
 export const astDefsRefsSpec = {
     name: 'code.ast',
@@ -59,4 +64,143 @@ export async function executeAstDefsRefs(input, ctx) {
         // Tree deletion is handled by AstParser's cache cleanup logic or explicit delete if needed
     }
 }
+// ── code.find_references ──────────────────────────────────────────────
+const MAX_SCAN_FILES = 30;
+const RG_TIMEOUT_MS = 10_000;
+export const codeFindReferencesSpec = {
+    name: 'code.find_references',
+    source: 'builtin',
+    intent: 'SEARCH',
+    description: text.tools.codeFindReferencesDescription,
+    riskLevel: 'low',
+    sideEffects: ['fs_read'],
+    concurrency: 'parallel_ok',
+    computeResources: (input, ctx) => [pathPrefixResource(ctx, input.file)],
+    inputSchema: z.object({
+        file: z.string().describe('Relative path to the file where the symbol is defined'),
+        symbol: z.string().describe('The symbol name to find references for'),
+    }),
+    outputSchema: z.object({
+        definition: z
+            .object({
+            file: z.string(),
+            name: z.string(),
+            location: z.any(),
+        })
+            .nullable(),
+        references: z.array(z.object({
+            file: z.string(),
+            name: z.string(),
+            location: z.any(),
+        })),
+        filesScanned: z.number(),
+    }),
+    allowedPhases: [Phase.CONTEXT, Phase.EXPLORE, Phase.PLAN, Phase.AUTOPILOT],
+};
+export async function executeCodeFindReferences(input, ctx) {
+    const repoRoot = ctx.worktreeRoot || ctx.repoRoot;
+    const registry = ctx.languagePlugins ?? tryGetPluginRegistry();
+    // 1. Parse the target file to find the definition
+    const targetPath = join(repoRoot, input.file);
+    const targetCode = await readFile(targetPath, 'utf-8');
+    const targetLang = registry?.getByExtension(input.file)?.meta.id;
+    let definition = null;
+    if (targetLang) {
+        const tree = await AstParser.parse(targetCode, targetLang);
+        const defs = await AstParser.identifyDefinitions(tree, targetLang);
+        const match = defs.find((d) => d.name === input.symbol);
+        if (match) {
+            definition = { file: input.file, name: match.name, location: match.location };
+        }
+    }
+    // 2. Collect candidate files via ripgrep (fast pre-filter)
+    const candidates = await rgFindCandidates(repoRoot, input.symbol, input.file);
+    // 3. Also collect import neighbors of the target file
+    const importNeighbors = await resolveImportNeighbors(input.file, targetCode, repoRoot);
+    for (const neighbor of importNeighbors) {
+        if (!candidates.includes(neighbor) && neighbor !== input.file) {
+            candidates.push(neighbor);
+        }
+    }
+    // 4. Cap the number of files to scan
+    const toScan = candidates.slice(0, MAX_SCAN_FILES);
+    // 5. Parse each candidate and find references
+    const references = [];
+    for (const file of toScan) {
+        try {
+            const lang = registry?.getByExtension(file)?.meta.id;
+            if (!lang)
+                continue;
+            const fullPath = join(repoRoot, file);
+            const code = await readFile(fullPath, 'utf-8');
+            const tree = await AstParser.parse(code, lang);
+            const refs = await AstParser.identifyReferences(tree, lang);
+            for (const ref of refs) {
+                if (ref.name === input.symbol) {
+                    references.push({ file, name: ref.name, location: ref.location });
+                }
+            }
+        }
+        catch (error) {
+            // Skip files that can't be parsed
+            getLogger().debug(`[CodeAst] Failed to parse file ${file}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return {
+        definition,
+        references,
+        filesScanned: toScan.length,
+    };
+}
+/**
+ * Use ripgrep to find files that mention the symbol (fast pre-filter).
+ * Returns repo-relative paths, excluding the target file itself.
+ */
+async function rgFindCandidates(repoRoot, symbol, excludeFile) {
+    let stdout = '';
+    try {
+        const result = await spawnCommand({
+            command: 'rg',
+            args: ['--files-with-matches', '--fixed-strings', '--max-count', '1', symbol, '.'],
+            cwd: repoRoot,
+            env: process.env,
+            timeoutMs: RG_TIMEOUT_MS,
+            onStdoutChunk: (chunk) => {
+                stdout += Buffer.from(chunk).toString();
+            },
+            onStderrChunk: () => { },
+        });
+        if (result.error || result.timedOut || (result.code !== 0 && result.code !== 1)) {
+            return [];
+        }
+        const normalizedExclude = normalizePath(excludeFile).replace(/^(\.\/|\/)+/, '');
+        return stdout
+            .split('\n')
+            .map((line) => normalizePath(line.trim()).replace(/^(\.\/|\/)+/, ''))
+            .filter((f) => f && f !== normalizedExclude);
+    }
+    catch (error) {
+        getLogger().debug(`[CodeAst] rg candidate search failed: ${error instanceof Error ? error.message : String(error)}`);
+        return [];
+    }
+}
+/**
+ * Resolve import neighbors of a file — files that the target imports.
+ */
+async function resolveImportNeighbors(targetFile, targetCode, _repoRoot) {
+    const specifiers = extractImportSpecifiers(targetCode);
+    const neighbors = [];
+    for (const spec of specifiers) {
+        if (!spec.startsWith('.'))
+            continue;
+        const candidates = resolveImportCandidates({ currentFile: targetFile, specifier: spec });
+        for (const candidate of candidates) {
+            const normalized = normalizePath(candidate).replace(/^(\.\/|\/)+/, '');
+            if (normalized && !neighbors.includes(normalized)) {
+                neighbors.push(normalized);
+            }
+        }
+    }
+    return neighbors;
+}
 //# sourceMappingURL=ast.js.map

package/dist/core/tools/builtin/code-search/backends/powershell.js

@@ -1,4 +1,5 @@
 import { LIMITS } from '../../../../config/limits.js';
+import { getLogger } from '../../../../observability/logger.js';
 import { parsePlainMatches } from '../parse/plain-grep.js';
 export const psBackend = {
     id: 'powershell',
@@ -12,7 +13,8 @@ export const psBackend = {
             });
             return res.exitCode === 0;
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[CodeSearch] PowerShell compatibility check failed: ${error instanceof Error ? error.message : String(error)}`);
             return false;
         }
     },

package/dist/core/tools/builtin/code-search/backends/rg.js

@@ -1,5 +1,6 @@
 import { resolve } from 'path';
 import { LIMITS } from '../../../../config/limits.js';
+import { getLogger } from '../../../../observability/logger.js';
 import { parseRgJson } from '../parse/rg-json.js';
 export const rgBackend = {
     id: 'rg',
@@ -9,7 +10,8 @@ export const rgBackend = {
             const res = await ctx.runner.execFile('rg', ['--version'], { timeoutMs: 1500 });
             return res.exitCode === 0;
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[CodeSearch] rg compatibility check failed: ${error instanceof Error ? error.message : String(error)}`);
             return false;
         }
     },

package/dist/core/tools/builtin/code-search/parse/plain-grep.js

@@ -1,3 +1,4 @@
+import { getLogger } from '../../../../observability/logger.js';
 /**
  * A versatile parser for non-JSON-native search tools.
  * Supports PowerShell JSON objects and traditional line-based formats.
@@ -29,8 +30,9 @@ function parsePsJson(stdout, maxMatches) {
             }
         }
     }
-    catch {
+    catch (error) {
         // If JSON parsing fails, fallback to empty
+        getLogger().debug(`[CodeSearch] Failed to parse PowerShell JSON output: ${error instanceof Error ? error.message : String(error)}`);
     }
     return { matches, truncated };
 }

package/dist/core/tools/builtin/code-search/parse/rg-json.js

@@ -1,3 +1,4 @@
+import { getLogger } from '../../../../observability/logger.js';
 /**
  * Parses the newline-delimited JSON output from ripgrep (--json).
  */
@@ -22,8 +23,9 @@ export function parseRgJson(stdout, opts) {
                 });
             }
         }
-        catch {
+        catch (error) {
             // Ignore malformed JSON lines
+            getLogger().debug(`[CodeSearch] Failed to parse rg JSON line: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     return { matches, truncated };

package/dist/core/tools/builtin/fs.js

@@ -5,6 +5,7 @@ import { z } from 'zod';
 import { text } from '../../../locales/index.js';
 import { AtomicFileWriter } from '../../adapters/fs/atomic-file-writer.js';
 import { mkdir, readFile, readdir, stat } from '../../adapters/fs/node-fs.js';
+import { getLogger } from '../../observability/logger.js';
 import { Phase } from '../../types/runtime.js';
 import { normalizeRepoRelativePath } from '../../utils/path.js';
 import { isRecord } from '../../utils/serialize.js';
@@ -219,7 +220,8 @@ function shouldIncludeListedEntry(dir, entryName, includeHidden) {
         assertNotReservedRepoPrefix(childPath);
         return true;
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[Fs] Reserved path check failed for "${childPath}": ${error instanceof Error ? error.message : String(error)}`);
         return false;
     }
 }
@@ -366,6 +368,79 @@ export async function executeFsWriteFile(input, ctx) {
         bytesWritten: contentBytes.length,
     };
 }
+// ── fs.edit_file ──────────────────────────────────────────────────────
+const fsEditFileInputSchema = z.preprocess((raw) => {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return raw;
+    const input = raw;
+    if (typeof input.file === 'string')
+        return input;
+    const alias = input.path ?? input.file_path ?? input.filePath;
+    if (typeof alias !== 'string')
+        return input;
+    return {
+        ...input,
+        file: alias,
+    };
+}, z.object({
+    file: z.string().describe('Relative path to the file from the repository root'),
+    old_string: z.string().min(1).describe('The exact text to find in the file'),
+    new_string: z.string().describe('The replacement text'),
+    replace_all: z
+        .boolean()
+        .optional()
+        .describe('Replace all occurrences instead of just the first one'),
+}));
+export const fsEditFileSpec = {
+    name: 'fs.edit_file',
+    source: 'builtin',
+    intent: 'WRITE',
+    description: text.tools.fsEditFileDescription,
+    riskLevel: 'high',
+    sideEffects: ['fs_write'],
+    concurrency: 'serial_only',
+    computeResources: (input, ctx) => [pathPrefixResource(ctx, input.file)],
+    allowedPhases: [Phase.SLASH, Phase.AUTOPILOT],
+    inputSchema: fsEditFileInputSchema,
+    outputSchema: z.object({
+        ok: z.boolean(),
+        path: z.string(),
+        replacements: z.number().int().nonnegative(),
+    }),
+    summarizeArgsForAuthorization: async (args) => {
+        const a = isRecord(args) ? args : {};
+        return JSON.stringify({
+            file: typeof a.file === 'string' ? a.file : undefined,
+            oldString: String(a.old_string ?? '').slice(0, 80),
+            newString: String(a.new_string ?? '').slice(0, 80),
+            replaceAll: Boolean(a.replace_all),
+        });
+    },
+};
+export async function executeFsEditFile(input, ctx) {
+    if (ctx.dryRun) {
+        return { ok: true, path: input.file, replacements: 0 };
+    }
+    const { absolutePath } = resolveRepoRelativePath(ctx.repoRoot, input.file);
+    const content = await readFile(absolutePath, 'utf-8');
+    const count = input.old_string ? content.split(input.old_string).length - 1 : 0;
+    if (count === 0) {
+        throw new Error(`old_string not found in file "${input.file}". Ensure the string matches exactly, including whitespace and indentation.`);
+    }
+    if (count > 1 && !input.replace_all) {
+        throw new Error(`old_string found ${count} times in "${input.file}", expected exactly 1. Use replace_all: true to replace all occurrences, or provide more surrounding context to uniquely identify the location.`);
+    }
+    const updated = input.replace_all
+        ? content.replaceAll(input.old_string, input.new_string)
+        : content.replace(input.old_string, input.new_string);
+    const writer = new AtomicFileWriter();
+    await writer.writeAtomic(absolutePath, Buffer.from(updated, 'utf8'));
+    return {
+        ok: true,
+        path: input.file,
+        replacements: count,
+    };
+}
 const fsCreateDirectoryInputSchema = z.preprocess((raw) => {
     if (typeof raw === 'string')
         return { path: raw };

package/dist/core/tools/builtin/git.js

@@ -115,4 +115,246 @@ export async function executeGitStatus(input, ctx) {
         status: res.stdout.toString('utf8'),
     };
 }
+// ── git.blame ─────────────────────────────────────────────────────────
+export const gitBlameSpec = {
+    name: 'git.blame',
+    source: 'builtin',
+    intent: 'READ',
+    description: text.tools.gitBlameDescription,
+    riskLevel: 'low',
+    sideEffects: ['git_read'],
+    concurrency: 'parallel_ok',
+    computeResources: (_input, ctx) => [repoResource(ctx)],
+    inputSchema: z.object({
+        file: z.string().describe('Relative path to the file'),
+        ref: z.string().optional().describe('Git reference (default: HEAD)'),
+        range: z
+            .object({
+            start: z.number().int().min(1).describe('Start line number'),
+            end: z.number().int().min(1).describe('End line number'),
+        })
+            .optional()
+            .describe('Line range to blame'),
+    }),
+    outputSchema: z.object({
+        file: z.string(),
+        lines: z.array(z.object({
+            line: z.number(),
+            content: z.string(),
+            commit: z.string(),
+            author: z.string(),
+            authorTime: z.number(),
+        })),
+    }),
+    allowedPhases: [Phase.SLASH, Phase.CONTEXT, Phase.EXPLORE, Phase.PLAN, Phase.AUTOPILOT],
+};
+export async function executeGitBlame(input, ctx) {
+    const { file, ref, range } = input;
+    if (file.includes('..') || file.startsWith('/') || /^[a-zA-Z]:/.test(file)) {
+        throw new Error(text.tools.invalidRelativePath(file));
+    }
+    const args = ['blame', '--porcelain'];
+    if (range)
+        args.push('-L', `${range.start},${range.end}`);
+    if (ref)
+        args.push(ref);
+    args.push('--', file);
+    const repoRoot = ctx.worktreeRoot || ctx.repoRoot;
+    const git = new GitAdapter(repoRoot);
+    const res = await git.execMeta(args, {
+        cwd: repoRoot,
+        env: ctx.env,
+        limits: { maxStdoutBytes: LIMITS.maxToolOutputBytes, maxStderrChars: 16_384 },
+        timeoutMs: LIMITS.gitTimeoutMs,
+    });
+    if (!res.ok) {
+        if (res.error?.message)
+            throw new Error(text.git.processError(res.error.message));
+        throw new Error(text.git.commandFailedDetailed(res.code, res.stderr.trim()));
+    }
+    if (res.stdoutTruncated)
+        throw new Error(text.git.outputTruncated(LIMITS.maxToolOutputBytes));
+    const lines = parseBlamePorcelain(res.stdout.toString('utf8'));
+    return { file, lines };
+}
+function parseBlamePorcelain(raw) {
+    const result = [];
+    const commitMeta = new Map();
+    let currentCommit = '';
+    let currentAuthor = '';
+    let currentAuthorTime = 0;
+    for (const line of raw.split('\n')) {
+        if (!line)
+            continue;
+        // Header line: "hash origLine finalLine [numLines]"
+        const headerMatch = /^([0-9a-f]{40})\s+\d+\s+(\d+)/.exec(line);
+        if (headerMatch) {
+            currentCommit = headerMatch[1];
+            if (!commitMeta.has(currentCommit)) {
+                const meta = commitMeta.get(currentCommit);
+                if (meta) {
+                    currentAuthor = meta.author;
+                    currentAuthorTime = meta.authorTime;
+                }
+            }
+            continue;
+        }
+        if (line.startsWith('author ')) {
+            currentAuthor = line.slice(7);
+            commitMeta.set(currentCommit, { author: currentAuthor, authorTime: currentAuthorTime });
+            continue;
+        }
+        if (line.startsWith('author-time ')) {
+            currentAuthorTime = Number(line.slice(12));
+            const existing = commitMeta.get(currentCommit);
+            if (existing)
+                existing.authorTime = currentAuthorTime;
+            else
+                commitMeta.set(currentCommit, { author: currentAuthor, authorTime: currentAuthorTime });
+            continue;
+        }
+        // Content line starts with tab
+        if (line.startsWith('\t')) {
+            const meta = commitMeta.get(currentCommit) || {
+                author: currentAuthor,
+                authorTime: currentAuthorTime,
+            };
+            result.push({
+                line: result.length + 1,
+                content: line.slice(1),
+                commit: currentCommit,
+                author: meta.author,
+                authorTime: meta.authorTime,
+            });
+        }
+    }
+    return result;
+}
+// ── git.log ───────────────────────────────────────────────────────────
+export const gitLogSpec = {
+    name: 'git.log',
+    source: 'builtin',
+    intent: 'READ',
+    description: text.tools.gitLogDescription,
+    riskLevel: 'low',
+    sideEffects: ['git_read'],
+    concurrency: 'parallel_ok',
+    computeResources: (_input, ctx) => [repoResource(ctx)],
+    inputSchema: z.object({
+        ref: z.string().optional().describe('Starting ref (default: HEAD)'),
+        maxCount: z.number().int().min(1).max(200).default(20).describe('Max commits to return'),
+        file: z.string().optional().describe('Limit to commits touching this file'),
+        diffStat: z.boolean().default(false).describe('Include diffstat for each commit'),
+    }),
+    outputSchema: z.object({
+        commits: z.array(z.object({
+            hash: z.string(),
+            subject: z.string(),
+            author: z.string(),
+            date: z.string(),
+            parentHashes: z.string(),
+            stat: z.string().optional(),
+        })),
+    }),
+    allowedPhases: [Phase.SLASH, Phase.CONTEXT, Phase.EXPLORE, Phase.PLAN, Phase.AUTOPILOT],
+};
+export async function executeGitLog(input, ctx) {
+    const { ref, maxCount, file, diffStat } = input;
+    const args = ['log', `--format=%H%x00%s%x00%an%x00%aI%x00%P`, '-z', `-n${maxCount}`];
+    if (diffStat)
+        args.push('--stat');
+    if (ref)
+        args.push(ref);
+    if (file)
+        args.push('--', file);
+    const repoRoot = ctx.worktreeRoot || ctx.repoRoot;
+    const git = new GitAdapter(repoRoot);
+    const res = await git.execMeta(args, {
+        cwd: repoRoot,
+        env: ctx.env,
+        limits: { maxStdoutBytes: LIMITS.maxToolOutputBytes, maxStderrChars: 16_384 },
+        timeoutMs: LIMITS.gitTimeoutMs,
+    });
+    if (!res.ok) {
+        if (res.error?.message)
+            throw new Error(text.git.processError(res.error.message));
+        throw new Error(text.git.commandFailedDetailed(res.code, res.stderr.trim()));
+    }
+    if (res.stdoutTruncated)
+        throw new Error(text.git.outputTruncated(LIMITS.maxToolOutputBytes));
+    const commits = parseLogOutput(res.stdout.toString('utf8'), diffStat);
+    return { commits };
+}
+function parseLogOutput(raw, includeStat) {
+    // With -z, records are NUL-separated. Each record is: hash\0subject\0author\0date\0parents[\0stat...]
+    const records = raw.split('\0');
+    const commits = [];
+    // Each commit has 5 core fields; stat is optional extra
+    const fieldsPerCommit = 5;
+    let i = 0;
+    while (i + fieldsPerCommit - 1 < records.length) {
+        const hash = records[i].replace(/^\n/, '');
+        const subject = records[i + 1];
+        const author = records[i + 2];
+        const date = records[i + 3];
+        const parentHashes = records[i + 4];
+        i += fieldsPerCommit;
+        let stat;
+        if (includeStat && i < records.length) {
+            // The stat portion may contain newlines; collect until next commit header or end
+            const nextCommitIdx = records.findIndex((r, idx) => idx >= i && /^[0-9a-f]{40}/.test(r.replace(/^\n/, '')));
+            const endIdx = nextCommitIdx > i ? nextCommitIdx : records.length;
+            stat = records.slice(i, endIdx).join('\0').trim() || undefined;
+            i = endIdx;
+        }
+        commits.push({ hash, subject, author, date, parentHashes, stat });
+    }
+    return commits;
+}
+// ── git.show ──────────────────────────────────────────────────────────
+export const gitShowSpec = {
+    name: 'git.show',
+    source: 'builtin',
+    intent: 'READ',
+    description: text.tools.gitShowDescription,
+    riskLevel: 'low',
+    sideEffects: ['git_read'],
+    concurrency: 'parallel_ok',
+    computeResources: (_input, ctx) => [repoResource(ctx)],
+    inputSchema: z.object({
+        ref: z.string().describe('Git reference (commit hash, branch, tag)'),
+        stat: z.boolean().default(true).describe('Include diffstat'),
+    }),
+    outputSchema: z.object({
+        ref: z.string(),
+        content: z.string(),
+    }),
+    allowedPhases: [Phase.SLASH, Phase.CONTEXT, Phase.EXPLORE, Phase.PLAN, Phase.AUTOPILOT],
+};
+export async function executeGitShow(input, ctx) {
+    const { ref, stat } = input;
+    const args = ['show'];
+    if (stat)
+        args.push('--stat');
+    args.push(ref);
+    const repoRoot = ctx.worktreeRoot || ctx.repoRoot;
+    const git = new GitAdapter(repoRoot);
+    const res = await git.execMeta(args, {
+        cwd: repoRoot,
+        env: ctx.env,
+        limits: { maxStdoutBytes: LIMITS.maxToolOutputBytes, maxStderrChars: 16_384 },
+        timeoutMs: LIMITS.gitTimeoutMs,
+    });
+    if (!res.ok) {
+        if (res.error?.message)
+            throw new Error(text.git.processError(res.error.message));
+        throw new Error(text.git.commandFailedDetailed(res.code, res.stderr.trim()));
+    }
+    if (res.stdoutTruncated)
+        throw new Error(text.git.outputTruncated(LIMITS.maxToolOutputBytes));
+    return {
+        ref,
+        content: res.stdout.toString('utf8'),
+    };
+}
 //# sourceMappingURL=git.js.map

package/dist/core/tools/builtin/glob.js

@@ -0,0 +1,79 @@
+import { join } from 'path';
+import { z } from 'zod';
+import { text } from '../../../locales/index.js';
+import { spawnCommand } from '../../runtime/process-runner.js';
+import { Phase } from '../../types/runtime.js';
+import { normalizePath } from '../../utils/path.js';
+import { pathPrefixResource } from '../parallel/resource-helpers.js';
+const RG_TIMEOUT_MS = 10_000;
+export const globFindSpec = {
+    name: 'glob.find',
+    source: 'builtin',
+    intent: 'SEARCH',
+    description: text.tools.globFindDescription,
+    riskLevel: 'low',
+    sideEffects: ['fs_read'],
+    concurrency: 'parallel_ok',
+    computeResources: (_input, ctx) => [pathPrefixResource(ctx, '.')],
+    inputSchema: z.object({
+        pattern: z.string().describe('Glob pattern (e.g. "**/*.ts", "src/**/*.test.*")'),
+        directory: z.string().optional().describe('Directory to search in (relative, default: ".")'),
+        maxMatches: z
+            .number()
+            .int()
+            .min(1)
+            .max(5000)
+            .default(200)
+            .describe('Maximum number of files to return'),
+        respectGitignore: z.boolean().default(true).describe('Respect .gitignore (default: true)'),
+        includeHidden: z.boolean().default(false).describe('Include hidden files (starting with ".")'),
+    }),
+    outputSchema: z.object({
+        files: z.array(z.string()),
+        truncated: z.boolean(),
+        totalFound: z.number(),
+    }),
+    allowedPhases: [
+        Phase.SLASH,
+        Phase.CONTEXT,
+        Phase.EXPLORE,
+        Phase.PLAN,
+        Phase.AUTOPILOT,
+        Phase.VERIFY,
+    ],
+};
+export async function executeGlobFind(input, ctx) {
+    const repoRoot = ctx.worktreeRoot || ctx.repoRoot;
+    const cwd = input.directory ? join(repoRoot, input.directory) : repoRoot;
+    const args = ['--files'];
+    if (!input.respectGitignore)
+        args.push('--no-ignore');
+    if (input.includeHidden)
+        args.push('--hidden');
+    args.push('--glob', input.pattern);
+    args.push(cwd);
+    let stdout = '';
+    const result = await spawnCommand({
+        command: 'rg',
+        args,
+        cwd: repoRoot,
+        env: ctx.env ?? process.env,
+        timeoutMs: RG_TIMEOUT_MS,
+        onStdoutChunk: (chunk) => {
+            stdout += Buffer.from(chunk).toString();
+        },
+        onStderrChunk: () => { },
+    });
+    if (result.error || result.timedOut || (result.code !== 0 && result.code !== 1)) {
+        return { files: [], truncated: false, totalFound: 0 };
+    }
+    const allFiles = stdout
+        .split('\n')
+        .map((line) => normalizePath(line.trim()).replace(/^(\.\/|\/)+/, ''))
+        .filter(Boolean);
+    const totalFound = allFiles.length;
+    const truncated = totalFound > input.maxMatches;
+    const files = allFiles.slice(0, input.maxMatches);
+    return { files, truncated, totalFound };
+}
+//# sourceMappingURL=glob.js.map