salmon-loop 0.2.3

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

@@ -0,0 +1,85 @@
+import { LIMITS } from '../../../../config/limits.js';
+import { parseRgJson } from '../parse/rg-json.js';
+export const rgBackend = {
+    id: 'rg',
+    async isCompatible(ctx) {
+        try {
+            // Check if rg is available and working
+            const res = await ctx.runner.execFile('rg', ['--version'], { timeoutMs: 1500 });
+            return res.exitCode === 0;
+        }
+        catch {
+            return false;
+        }
+    },
+    normalizeInput(input) {
+        // Ensure maxMatches is within reasonable limits
+        return {
+            ...input,
+            maxMatches: Math.min(input.maxMatches ?? LIMITS.defaultSearchMatches, LIMITS.maxSearchMatches),
+        };
+    },
+    async run(input, ctx) {
+        const cwd = input.cwd ?? ctx.repoRoot;
+        const args = [
+            '--json',
+            '--line-number',
+            '--column',
+            '--max-count',
+            String(input.maxMatches),
+            input.pattern,
+            '.',
+        ];
+        if (!input.isRegex) {
+            args.unshift('--fixed-strings');
+        }
+        if (input.glob) {
+            args.unshift('--glob', input.glob);
+        }
+        const res = await ctx.runner.execFile('rg', args, {
+            cwd,
+            timeoutMs: ctx.limits.timeoutMs,
+            maxStdoutBytes: ctx.limits.maxOutputBytes,
+        });
+        if (res.timedOut) {
+            return {
+                ok: false,
+                code: 'TIMEOUT',
+                message: 'ripgrep execution timed out',
+                retryable: true,
+            };
+        }
+        // rg exit code 1 means "no matches found", which is a success in terms of execution
+        if (res.exitCode !== 0 && res.exitCode !== 1) {
+            return {
+                ok: false,
+                code: 'NONZERO_EXIT',
+                message: `ripgrep exited with code ${res.exitCode}: ${res.stderr}`,
+                retryable: true,
+            };
+        }
+        try {
+            const { matches, truncated } = parseRgJson(res.stdout, {
+                maxMatches: input.maxMatches ?? LIMITS.defaultSearchMatches,
+            });
+            return {
+                ok: true,
+                output: {
+                    matches,
+                    truncated,
+                    backend: 'rg',
+                    stats: { hits: matches.length },
+                },
+            };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                code: 'RUNTIME_ERROR',
+                message: `Failed to parse ripgrep output: ${err instanceof Error ? err.message : String(err)}`,
+                retryable: true,
+            };
+        }
+    },
+};
+//# sourceMappingURL=rg.js.map

package/dist/core/tools/builtin/code-search/executor.js

@@ -0,0 +1,87 @@
+import { LIMITS } from '../../../config/limits.js';
+import { getLogger } from '../../../observability/logger.js';
+import { spawnCommand } from '../../../runtime/process-runner.js';
+import { runWithFallback } from '../../capability/executor.js';
+import { psBackend } from './backends/powershell.js';
+import { rgBackend } from './backends/rg.js';
+/**
+ * The main executor for code.search.
+ * It transforms the general ToolRuntimeCtx into a specialized CapabilityCtx
+ * and executes with backend fallback logic.
+ */
+export async function codeSearchExecutor(input, ctx) {
+    getLogger().debug(`Searching for pattern: ${input.pattern}`);
+    // Construct CapabilityCtx for the underlying backends
+    const capCtx = {
+        repoRoot: ctx.repoRoot,
+        worktreeRoot: ctx.worktreeRoot,
+        phase: ctx.phase,
+        attemptId: ctx.attemptId,
+        dryRun: ctx.dryRun,
+        // Allow tests (and callers) to override platform; default to host platform.
+        platform: ctx.platform ?? process.platform,
+        runner: ctx.runner ?? {
+            execFile: async (file, args, opts) => {
+                const maxStdoutBytes = opts?.maxStdoutBytes ?? Number.POSITIVE_INFINITY;
+                let stdout = '';
+                let stderr = '';
+                let stdoutBytes = 0;
+                const result = await spawnCommand({
+                    command: file,
+                    args,
+                    cwd: opts?.cwd ?? ctx.repoRoot,
+                    timeoutMs: opts?.timeoutMs,
+                    signal: ctx.signal,
+                    env: { ...process.env, ...ctx.env, ...opts?.env },
+                    onStdoutChunk: (chunk) => {
+                        if (stdoutBytes >= maxStdoutBytes)
+                            return;
+                        const buffer = Buffer.from(chunk);
+                        const remaining = maxStdoutBytes - stdoutBytes;
+                        if (buffer.length <= remaining) {
+                            stdout += buffer.toString();
+                            stdoutBytes += buffer.length;
+                            return;
+                        }
+                        stdout += buffer.subarray(0, remaining).toString();
+                        stdoutBytes += remaining;
+                    },
+                    onStderrChunk: (chunk) => {
+                        stderr += Buffer.from(chunk).toString();
+                    },
+                });
+                if (result.error) {
+                    return {
+                        stdout,
+                        stderr: stderr || result.error.message,
+                        exitCode: 1,
+                        timedOut: false,
+                    };
+                }
+                return {
+                    stdout,
+                    stderr,
+                    exitCode: result.code ?? 1,
+                    timedOut: result.timedOut,
+                };
+            },
+        },
+        limits: {
+            timeoutMs: LIMITS.defaultToolTimeoutMs,
+            maxOutputBytes: LIMITS.maxToolOutputBytes,
+        },
+        audit: {
+            event: (e) => getLogger().audit('code.search.backend', e, { source: 'tool', severity: 'low' }),
+        },
+    };
+    const backends = capCtx.platform === 'win32' ? [rgBackend, psBackend] : [rgBackend];
+    const { output, meta } = await runWithFallback(backends, input, capCtx, {
+        fallbackOn: new Set(['UNAVAILABLE', 'TIMEOUT', 'RUNTIME_ERROR', 'NONZERO_EXIT']),
+        maxBackendTries: backends.length,
+    });
+    return {
+        ...output,
+        backend: meta.chosenBackend ?? 'unknown',
+    };
+}
+//# sourceMappingURL=executor.js.map

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

@@ -0,0 +1,59 @@
+/**
+ * A versatile parser for non-JSON-native search tools.
+ * Supports PowerShell JSON objects and traditional line-based formats.
+ */
+export function parsePlainMatches(stdout, opts) {
+    if (opts.format === 'ps-json') {
+        return parsePsJson(stdout, opts.maxMatches);
+    }
+    return parseLineBased(stdout, opts.maxMatches);
+}
+function parsePsJson(stdout, maxMatches) {
+    const matches = [];
+    let truncated = false;
+    try {
+        // PowerShell's ConvertTo-Json might return a single object or an array
+        const raw = JSON.parse(stdout);
+        const items = Array.isArray(raw) ? raw : [raw];
+        for (const item of items) {
+            if (matches.length >= maxMatches) {
+                truncated = true;
+                break;
+            }
+            if (item.Path && item.LineNumber) {
+                matches.push({
+                    file: item.Path,
+                    line: item.LineNumber,
+                    snippet: (item.Line || '').trimEnd(),
+                });
+            }
+        }
+    }
+    catch {
+        // If JSON parsing fails, fallback to empty
+    }
+    return { matches, truncated };
+}
+function parseLineBased(stdout, maxMatches) {
+    const lines = stdout.split('\n').filter((l) => l.trim());
+    const matches = [];
+    let truncated = false;
+    for (const line of lines) {
+        if (matches.length >= maxMatches) {
+            truncated = true;
+            break;
+        }
+        // Typical format: "path/to/file:line:content"
+        const parts = line.split(':');
+        if (parts.length >= 3) {
+            const file = parts[0].trim();
+            const lineNum = parseInt(parts[1], 10);
+            const snippet = parts.slice(2).join(':').trimEnd();
+            if (!isNaN(lineNum)) {
+                matches.push({ file, line: lineNum, snippet });
+            }
+        }
+    }
+    return { matches, truncated };
+}
+//# sourceMappingURL=plain-grep.js.map

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

@@ -0,0 +1,31 @@
+/**
+ * Parses the newline-delimited JSON output from ripgrep (--json).
+ */
+export function parseRgJson(stdout, opts) {
+    const lines = stdout.split('\n').filter((l) => l.trim());
+    const matches = [];
+    let truncated = false;
+    for (const line of lines) {
+        if (matches.length >= opts.maxMatches) {
+            truncated = true;
+            break;
+        }
+        try {
+            const data = JSON.parse(line);
+            if (data.type === 'match') {
+                matches.push({
+                    file: data.data.path.text,
+                    line: data.data.line_number,
+                    // rg column is 0-indexed in JSON, we convert to 1-indexed for the spec
+                    column: (data.data.submatches[0]?.start ?? 0) + 1,
+                    snippet: data.data.lines.text.trimEnd(),
+                });
+            }
+        }
+        catch {
+            // Ignore malformed JSON lines
+        }
+    }
+    return { matches, truncated };
+}
+//# sourceMappingURL=rg-json.js.map

package/dist/core/tools/builtin/code-search/spec.js

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import { Phase } from '../../../types/runtime.js';
+import { repoResource } from '../../parallel/resource-helpers.js';
+const CoercedBoolean = z.preprocess((value) => {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number')
+        return value !== 0;
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === 'true' || normalized === '1')
+            return true;
+        if (normalized === 'false' || normalized === '0')
+            return false;
+    }
+    return value;
+}, z.boolean());
+export const CodeSearchInput = z.object({
+    pattern: z.string().min(1).describe('The regular expression pattern to search for'),
+    glob: z.string().optional().describe('Optional glob pattern to filter files (e.g. "*.ts")'),
+    maxMatches: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(500)
+        .default(100)
+        .describe('Maximum number of matches to return'),
+    cwd: z.string().optional().describe('Directory to search in (defaults to repo root)'),
+    isRegex: CoercedBoolean.default(false).describe('Whether to treat the pattern as a regular expression'),
+});
+export const CodeSearchMatch = z.object({
+    file: z.string().describe('Relative path to the file'),
+    line: z.number().int().describe('Line number (1-indexed)'),
+    column: z.number().int().optional().describe('Column number (1-indexed)'),
+    snippet: z.string().describe('The matching line content'),
+});
+export const CodeSearchOutput = z.object({
+    matches: z.array(CodeSearchMatch).describe('List of matches found'),
+    truncated: z
+        .boolean()
+        .default(false)
+        .describe('Whether the results were truncated due to limits'),
+    backend: z.string().describe('The implementation backend used (for auditing)'),
+    stats: z
+        .object({
+        files: z.number().int().optional().describe('Number of files searched'),
+        hits: z.number().int().optional().describe('Total number of hits found'),
+    })
+        .partial(),
+});
+/**
+ * Specification for the code search tool.
+ * The executor will be bound during tool registration.
+ */
+export const CodeSearchSpec = {
+    name: 'code.search',
+    source: 'builtin',
+    intent: 'SEARCH',
+    description: 'Fast file pattern matching tool that works with any codebase size',
+    riskLevel: 'low',
+    sideEffects: ['fs_read'],
+    concurrency: 'parallel_ok',
+    computeResources: (_input, ctx) => [repoResource(ctx)],
+    allowedPhases: [Phase.SLASH, Phase.CONTEXT, Phase.EXPLORE, Phase.PLAN, Phase.PATCH, Phase.VERIFY],
+    inputSchema: CodeSearchInput,
+    outputSchema: CodeSearchOutput,
+    examples: [
+        {
+            description: 'Search for a function name',
+            input: { pattern: 'function main' },
+        },
+        {
+            description: 'Search with file filter',
+            input: { pattern: 'console.log', glob: '*.ts' },
+        },
+        {
+            description: 'Regex search',
+            input: { pattern: 'export\\s+default', isRegex: true },
+        },
+    ],
+};
+//# sourceMappingURL=spec.js.map

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

@@ -0,0 +1,243 @@
+import { isAbsolute, relative, resolve } from 'path';
+import { z } from 'zod';
+import { text } from '../../../locales/index.js';
+import { readFile, readdir, stat } from '../../adapters/fs/node-fs.js';
+import { Phase } from '../../types/runtime.js';
+import { pathPrefixResource } from '../parallel/resource-helpers.js';
+const FsListEntryType = z.enum(['file', 'dir', 'symlink', 'other']);
+const fsListInputSchema = z.preprocess((raw) => {
+    if (typeof raw === 'string') {
+        return { path: raw };
+    }
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return raw;
+    const input = raw;
+    const includeHidden = input.includeHidden;
+    if (typeof includeHidden === 'string') {
+        const normalized = includeHidden.trim().toLowerCase();
+        if (normalized === 'true')
+            input.includeHidden = true;
+        if (normalized === 'false')
+            input.includeHidden = false;
+        if (normalized === '1')
+            input.includeHidden = true;
+        if (normalized === '0')
+            input.includeHidden = false;
+    }
+    if (typeof includeHidden === 'number') {
+        if (includeHidden === 1)
+            input.includeHidden = true;
+        if (includeHidden === 0)
+            input.includeHidden = false;
+    }
+    if (typeof input.path === 'string')
+        return input;
+    const alias = input.dir ?? input.directory ?? input.folder ?? input.cwd;
+    if (typeof alias !== 'string')
+        return input;
+    return {
+        ...input,
+        path: alias,
+    };
+}, z.object({
+    path: z
+        .string()
+        .default('.')
+        .describe('Relative directory path to list from the repository root (default: ".")'),
+    includeHidden: z
+        .boolean()
+        .default(false)
+        .describe('Whether to include entries that start with "." (hidden files)'),
+    maxEntries: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(1000)
+        .default(200)
+        .describe('Maximum number of entries to return'),
+}));
+const fsReadInputSchema = z.preprocess((raw) => {
+    if (typeof raw === 'string') {
+        return { file: 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'),
+}));
+/**
+ * Spec for the fs.read tool.
+ */
+export const fsReadFileSpec = {
+    name: 'fs.read',
+    source: 'builtin',
+    intent: 'READ',
+    description: `${text.tools.fsReadDescription} IMPORTANT: The file parameter must be a relative path (e.g., "src/main.ts"). Do NOT use absolute paths or paths with "..".`,
+    riskLevel: 'low',
+    sideEffects: ['fs_read'],
+    concurrency: 'parallel_ok',
+    computeResources: (input, ctx) => [pathPrefixResource(ctx, input.file)],
+    inputSchema: fsReadInputSchema,
+    outputSchema: z.object({ content: z.string(), size: z.number() }),
+    allowedPhases: [
+        Phase.SLASH,
+        Phase.CONTEXT,
+        Phase.EXPLORE,
+        Phase.PLAN,
+        Phase.PATCH,
+        Phase.VERIFY,
+        Phase.SHRINK,
+    ],
+    examples: [
+        {
+            description: 'Read a source file',
+            input: { file: 'src/main.ts' },
+            output: { content: '<file content>', size: 1234 },
+        },
+        {
+            description: 'Read configuration file',
+            input: { file: 'package.json' },
+            output: { content: '<file content>', size: 1234 },
+        },
+        {
+            description: 'Read README documentation',
+            input: { file: 'README.md' },
+            output: { content: '<file content>', size: 6789 },
+        },
+    ],
+};
+/**
+ * Spec for the code.read tool (alias of fs.read).
+ */
+export const codeReadSpec = {
+    ...fsReadFileSpec,
+    name: 'code.read',
+    description: text.tools.codeReadDescription,
+};
+/**
+ * Spec for the fs.list tool.
+ */
+export const fsListSpec = {
+    name: 'fs.list',
+    source: 'builtin',
+    intent: 'LIST',
+    description: text.tools.fsListDescription,
+    riskLevel: 'low',
+    sideEffects: ['fs_read'],
+    concurrency: 'parallel_ok',
+    computeResources: (input, ctx) => {
+        const prefix = input.path === '.' || input.path === '' ? '.' : `${input.path.replace(/\/+$/, '')}/`;
+        return [pathPrefixResource(ctx, prefix)];
+    },
+    inputSchema: fsListInputSchema,
+    outputSchema: z.object({
+        entries: z.array(z.object({
+            name: z.string(),
+            path: z.string(),
+            type: FsListEntryType,
+        })),
+        truncated: z.boolean(),
+        totalEntries: z.number().int(),
+    }),
+    allowedPhases: [
+        Phase.SLASH,
+        Phase.CONTEXT,
+        Phase.EXPLORE,
+        Phase.PLAN,
+        Phase.PATCH,
+        Phase.VERIFY,
+        Phase.SHRINK,
+    ],
+};
+function toRepoRelativeChildPath(dir, name) {
+    const normalizedDir = String(dir || '.')
+        .replace(/\\/g, '/')
+        .trim();
+    const base = normalizedDir === '.' ? '' : normalizedDir.replace(/^\.\/+/, '').replace(/\/+$/, '');
+    return base ? `${base}/${name}` : name;
+}
+/**
+ * Implementation of the fs.list tool.
+ */
+export async function executeFsList(input, ctx) {
+    const { path: dir, includeHidden, maxEntries } = input;
+    if (isAbsolute(dir)) {
+        throw new Error('Access denied: Path is outside of repository root.');
+    }
+    const absoluteRoot = resolve(ctx.repoRoot);
+    const absolutePath = resolve(absoluteRoot, dir);
+    const relPath = relative(absoluteRoot, absolutePath);
+    if (relPath.startsWith('..') || isAbsolute(relPath)) {
+        throw new Error('Access denied: Path is outside of repository root.');
+    }
+    try {
+        const dirents = await readdir(absolutePath, { withFileTypes: true });
+        const visible = includeHidden ? dirents : dirents.filter((d) => !d.name.startsWith('.'));
+        const entries = visible
+            .map((d) => {
+            const type = d.isDirectory()
+                ? 'dir'
+                : d.isFile()
+                    ? 'file'
+                    : d.isSymbolicLink()
+                        ? 'symlink'
+                        : 'other';
+            return {
+                name: d.name,
+                path: toRepoRelativeChildPath(dir, d.name),
+                type,
+            };
+        })
+            .sort((a, b) => a.path.localeCompare(b.path));
+        const totalEntries = entries.length;
+        const sliced = entries.slice(0, maxEntries);
+        return {
+            entries: sliced,
+            truncated: sliced.length < totalEntries,
+            totalEntries,
+        };
+    }
+    catch (e) {
+        throw new Error(`Failed to list directory ${dir}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+/**
+ * Implementation of the fs.read tool.
+ */
+export async function executeFsReadFile(input, ctx) {
+    const { file } = input;
+    if (isAbsolute(file)) {
+        throw new Error('Access denied: Path is outside of repository root.');
+    }
+    // CRITICAL SAFETY: Path traversal check using relative path resolution
+    // We resolve to absolute paths to handle '.' and '..' correctly
+    const absoluteRoot = resolve(ctx.repoRoot);
+    // use resolve instead of join to handle absolute paths in input correctly
+    const absolutePath = resolve(absoluteRoot, file);
+    const relPath = relative(absoluteRoot, absolutePath);
+    if (relPath.startsWith('..') || isAbsolute(relPath)) {
+        throw new Error('Access denied: Path is outside of repository root.');
+    }
+    try {
+        const fileStat = await stat(absolutePath);
+        const content = await readFile(absolutePath, 'utf-8');
+        return {
+            content,
+            size: fileStat.size,
+        };
+    }
+    catch (e) {
+        throw new Error(`Failed to read file ${file}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+//# sourceMappingURL=fs.js.map