salmon-loop 0.3.2 → 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/executor.js

@@ -1,6 +1,7 @@
 import { LIMITS } from '../../../config/limits.js';
 import { getLogger } from '../../../observability/logger.js';
 import { spawnCommand } from '../../../runtime/process-runner.js';
+import { isRecord } from '../../../utils/serialize.js';
 import { runWithFallback } from '../../capability/executor.js';
 import { psBackend } from './backends/powershell.js';
 import { rgBackend } from './backends/rg.js';
@@ -24,53 +25,55 @@ export async function codeSearchExecutor(input, ctx) {
         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) {
+        platform: isRecord(ctx) && typeof ctx.platform === 'string' ? ctx.platform : process.platform,
+        runner: isRecord(ctx) && typeof ctx.runner === 'object' && ctx.runner !== null
+            ? 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: stderr || result.error.message,
-                        exitCode: 1,
-                        timedOut: false,
+                        stderr,
+                        exitCode: result.code ?? 1,
+                        timedOut: result.timedOut,
                     };
-                }
-                return {
-                    stdout,
-                    stderr,
-                    exitCode: result.code ?? 1,
-                    timedOut: result.timedOut,
-                };
+                },
             },
-        },
         limits: {
             timeoutMs: LIMITS.defaultToolTimeoutMs,
             maxOutputBytes: LIMITS.maxToolOutputBytes,

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,8 +5,10 @@ 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';
 import { pathPrefixResource } from '../parallel/resource-helpers.js';
 const FsListEntryType = z.enum(['file', 'dir', 'symlink', 'other']);
 const fsListInputSchema = z.preprocess((raw) => {
@@ -218,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;
     }
 }
@@ -338,12 +341,13 @@ export const fsWriteFileSpec = {
         bytesWritten: z.number().int().nonnegative(),
     }),
     summarizeArgsForAuthorization: async (args) => {
-        const encoding = args?.encoding || 'utf-8';
-        const content = String(args?.content ?? '');
+        const a = isRecord(args) ? args : {};
+        const encoding = typeof a.encoding === 'string' ? a.encoding : 'utf-8';
+        const content = String(a.content ?? '');
         const bytes = Buffer.byteLength(content, 'utf8');
         const sha256 = createHash('sha256').update(content, 'utf8').digest('hex');
         return JSON.stringify({
-            file: args?.file,
+            file: typeof a.file === 'string' ? a.file : undefined,
             encoding,
             bytes,
             sha256,
@@ -364,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 };
@@ -390,7 +467,10 @@ export const fsCreateDirectorySpec = {
         ok: z.boolean(),
         path: z.string(),
     }),
-    summarizeArgsForAuthorization: async (args) => JSON.stringify({ path: args?.path, recursive: args?.recursive }),
+    summarizeArgsForAuthorization: async (args) => {
+        const a = isRecord(args) ? args : {};
+        return JSON.stringify({ path: a.path, recursive: a.recursive });
+    },
 };
 export async function executeFsCreateDirectory(input, ctx) {
     if (ctx.dryRun) {
@@ -427,7 +507,10 @@ export const fsDeleteFileSpec = {
         path: z.string(),
         deleted: z.boolean(),
     }),
-    summarizeArgsForAuthorization: async (args) => JSON.stringify({ file: args?.file, missingOk: args?.missingOk }),
+    summarizeArgsForAuthorization: async (args) => {
+        const a = isRecord(args) ? args : {};
+        return JSON.stringify({ file: a.file, missingOk: a.missingOk });
+    },
 };
 export async function executeFsDeleteFile(input, ctx) {
     if (ctx.dryRun) {
@@ -439,7 +522,7 @@ export async function executeFsDeleteFile(input, ctx) {
         await stat(absolutePath);
     }
     catch (e) {
-        const code = e && typeof e === 'object' && 'code' in e ? e.code : undefined;
+        const code = isRecord(e) && typeof e.code === 'string' ? e.code : undefined;
         if (code === 'ENOENT')
             exists = false;
         else