salmon-loop 0.2.13 → 0.2.16

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

@@ -0,0 +1,360 @@
+import { createHash } from 'crypto';
+import path from 'path';
+import { z } from 'zod';
+import { FileAdapter } from '../../adapters/fs/file-adapter.js';
+import { GitAdapter } from '../../adapters/git/git-adapter.js';
+import { buildBenchmarkPatchArtifact, } from '../../benchmark/patch-artifact.js';
+import { buildSweBenchPrediction, encodeSweBenchPredictionJsonl, parseSweBenchInstance, } from '../../benchmark/swe-bench.js';
+import { normalizeDiff, validateDiff } from '../../patch/diff.js';
+import { Phase } from '../../types/runtime.js';
+import { isCanonicalPathWithinDirectory, isPathWithinDirectory, normalizeRepoRelativePath, } from '../../utils/path.js';
+import { repoResource } from '../parallel/resource-helpers.js';
+const patchInputSchema = z.object({
+    patch: z
+        .string()
+        .optional()
+        .describe('Unified diff to check. Defaults to current workspace diff.'),
+});
+const patchCheckOutputSchema = z.object({
+    ok: z.boolean(),
+    changedFiles: z.array(z.string()),
+    fileCount: z.number(),
+    lineCount: z.number(),
+    error: z.string().optional(),
+});
+export const gitDiffCheckSpec = {
+    name: 'git.diff_check',
+    source: 'builtin',
+    intent: 'INFRA',
+    description: 'Validate that a unified diff is structurally valid and within patch limits.',
+    riskLevel: 'low',
+    sideEffects: ['git_read'],
+    concurrency: 'parallel_ok',
+    computeResources: (_input, ctx) => [repoResource(ctx)],
+    inputSchema: patchInputSchema,
+    outputSchema: patchCheckOutputSchema,
+    allowedPhases: [Phase.VERIFY],
+};
+export const gitApplyCheckSpec = {
+    name: 'git.apply_check',
+    source: 'builtin',
+    intent: 'INFRA',
+    description: 'Run git apply --check against a unified diff without mutating the workspace.',
+    riskLevel: 'low',
+    sideEffects: ['git_read'],
+    concurrency: 'parallel_ok',
+    computeResources: (_input, ctx) => [repoResource(ctx)],
+    inputSchema: patchInputSchema.extend({
+        ignoreWhitespace: z.boolean().default(false),
+    }),
+    outputSchema: z.object({
+        ok: z.boolean(),
+        exitCode: z.number().nullable(),
+        output: z.string(),
+    }),
+    allowedPhases: [Phase.VERIFY],
+};
+const benchmarkReportInputSchema = z.object({
+    patch: z
+        .string()
+        .optional()
+        .describe('Unified diff to summarize. Defaults to current workspace diff.'),
+});
+const benchmarkReportOutputSchema = z.object({
+    provider: z.literal('local'),
+    patch: z.object({
+        sha256: z.string(),
+        bytes: z.number(),
+        changedFiles: z.array(z.string()),
+        isEmpty: z.boolean(),
+    }),
+});
+export const benchmarkReportSpec = {
+    name: 'benchmark.report',
+    source: 'builtin',
+    intent: 'REPORT',
+    description: 'Create a local benchmark report for the current workspace patch.',
+    riskLevel: 'low',
+    sideEffects: ['git_read'],
+    concurrency: 'parallel_ok',
+    computeResources: (_input, ctx) => [repoResource(ctx)],
+    inputSchema: benchmarkReportInputSchema,
+    outputSchema: benchmarkReportOutputSchema,
+    allowedPhases: [Phase.VERIFY],
+};
+export const sweBenchLoadInstanceSpec = {
+    name: 'swebench.load_instance',
+    source: 'builtin',
+    intent: 'READ',
+    description: 'Load a local SWE-bench instance JSON file without network access.',
+    riskLevel: 'low',
+    sideEffects: ['fs_read'],
+    concurrency: 'parallel_ok',
+    inputSchema: z.object({
+        file: z.string().describe('Repo-relative path to a SWE-bench instance JSON file'),
+    }),
+    outputSchema: z
+        .object({
+        instance_id: z.string(),
+        repo: z.string().optional(),
+        base_commit: z.string().optional(),
+        problem_statement: z.string().optional(),
+    })
+        .passthrough(),
+    allowedPhases: [Phase.VERIFY],
+};
+const swePredictionInputSchema = z.object({
+    instanceId: z.string().min(1).describe('SWE-bench instance_id'),
+    modelNameOrPath: z.string().min(1).describe('SWE-bench model_name_or_path'),
+    patch: z
+        .string()
+        .optional()
+        .describe('Unified diff to encode. Defaults to current workspace diff.'),
+});
+const swePredictionOutputSchema = z.object({
+    prediction: z.object({
+        instance_id: z.string(),
+        model_name_or_path: z.string(),
+        model_patch: z.string(),
+    }),
+    jsonl: z.string(),
+});
+export const sweBenchWritePredictionSpec = {
+    name: 'swebench.write_prediction',
+    source: 'builtin',
+    intent: 'REPORT',
+    description: 'Encode a SWE-bench prediction JSONL record without writing to disk.',
+    riskLevel: 'low',
+    sideEffects: ['git_read'],
+    concurrency: 'parallel_ok',
+    computeResources: (_input, ctx) => [repoResource(ctx)],
+    inputSchema: swePredictionInputSchema,
+    outputSchema: swePredictionOutputSchema,
+    allowedPhases: [Phase.VERIFY],
+};
+export const sweBenchSubmitPredictionsSpec = {
+    name: 'swebench.submit_predictions',
+    source: 'builtin',
+    intent: 'REPORT',
+    description: 'Append a SWE-bench prediction JSONL record to a local repo-contained file.',
+    riskLevel: 'medium',
+    sideEffects: ['fs_write', 'git_read'],
+    concurrency: 'serial_only',
+    computeResources: (_input, ctx) => [repoResource(ctx)],
+    inputSchema: swePredictionInputSchema.extend({
+        predictionsFile: z
+            .string()
+            .default('predictions.jsonl')
+            .describe('Repo-relative JSONL file to append the prediction to'),
+    }),
+    outputSchema: z.object({
+        predictionsFile: z.string(),
+        appended: z.boolean(),
+        prediction: swePredictionOutputSchema.shape.prediction,
+    }),
+    allowedPhases: [Phase.VERIFY],
+};
+export const sweBenchGetReportSpec = {
+    name: 'swebench.get_report',
+    source: 'builtin',
+    intent: 'READ',
+    description: 'Read a local SWE-bench report JSON file without network access.',
+    riskLevel: 'low',
+    sideEffects: ['fs_read'],
+    concurrency: 'parallel_ok',
+    inputSchema: z.object({
+        file: z.string().describe('Repo-relative path to a SWE-bench report JSON file'),
+    }),
+    outputSchema: z.object({
+        report: z.record(z.string(), z.unknown()),
+    }),
+    allowedPhases: [Phase.VERIFY],
+};
+async function resolvePatch(ctx, patch, options = {}) {
+    if (patch !== undefined) {
+        if (patch.trim().length === 0) {
+            return {
+                patch: '',
+                bytes: 0,
+                sha256: createHash('sha256').update('', 'utf8').digest('hex'),
+                changedFiles: [],
+                isEmpty: true,
+            };
+        }
+        const normalizedPatch = normalizeDiff(patch);
+        const meta = validateDiff(normalizedPatch);
+        const bytes = Buffer.byteLength(normalizedPatch, 'utf8');
+        const sha256 = createHash('sha256').update(normalizedPatch, 'utf8').digest('hex');
+        return {
+            patch: normalizedPatch,
+            bytes,
+            sha256,
+            changedFiles: meta.changedFiles,
+            isEmpty: normalizedPatch.length === 0,
+        };
+    }
+    return buildBenchmarkPatchArtifact({
+        repoPath: ctx.worktreeRoot || ctx.repoRoot,
+        excludePaths: options.excludePaths,
+    });
+}
+function resolveRepoFile(ctx, file) {
+    const root = ctx.worktreeRoot || ctx.repoRoot;
+    if (path.isAbsolute(file)) {
+        throw new Error(`Expected a repo-relative path: ${file}`);
+    }
+    assertNotReservedRepoPrefix(file);
+    const absolutePath = path.resolve(root, file);
+    if (!isPathWithinDirectory(root, absolutePath, { allowEqual: false })) {
+        throw new Error(`Refusing to access path outside repository: ${file}`);
+    }
+    const relativePath = path.relative(root, absolutePath).replace(/\\/g, '/');
+    assertNotReservedRepoPrefix(relativePath);
+    return { absolutePath, relativePath };
+}
+function assertNotReservedRepoPrefix(file) {
+    const normalized = normalizeRepoRelativePath(file);
+    if (normalized === '.git' || normalized.startsWith('.git/')) {
+        throw new Error('Access denied: Reserved path prefix: .git/');
+    }
+    if (normalized === '.salmonloop' || normalized.startsWith('.salmonloop/')) {
+        throw new Error('Access denied: Reserved path prefix: .salmonloop/');
+    }
+}
+function isMissingPathError(error) {
+    return Boolean(error && typeof error === 'object' && error.code === 'ENOENT');
+}
+async function assertNoSymlinkPathComponents(root, absolutePath) {
+    const adapter = new FileAdapter();
+    const resolvedRoot = path.resolve(root);
+    let cursor = absolutePath;
+    while (isPathWithinDirectory(resolvedRoot, cursor, { allowEqual: false })) {
+        try {
+            const stats = await adapter.lstat(cursor);
+            if (stats.isSymbolicLink()) {
+                throw new Error(`Refusing to follow symlink path component: ${path.relative(resolvedRoot, cursor)}`);
+            }
+        }
+        catch (error) {
+            if (!isMissingPathError(error))
+                throw error;
+        }
+        cursor = path.dirname(cursor);
+    }
+}
+async function assertCanonicalRepoContainment(root, absolutePath) {
+    const adapter = new FileAdapter();
+    const realRoot = await adapter.realpath(root);
+    let cursor = absolutePath;
+    while (true) {
+        try {
+            const realCursor = await adapter.realpath(cursor);
+            if (!isCanonicalPathWithinDirectory(realRoot, realCursor, { allowEqual: true })) {
+                throw new Error(`Refusing to access path outside repository: ${path.relative(root, absolutePath)}`);
+            }
+            return;
+        }
+        catch (error) {
+            if (!isMissingPathError(error))
+                throw error;
+            const parent = path.dirname(cursor);
+            if (parent === cursor)
+                throw error;
+            cursor = parent;
+        }
+    }
+}
+async function resolveSafeRepoFile(ctx, file) {
+    const resolved = resolveRepoFile(ctx, file);
+    const root = ctx.worktreeRoot || ctx.repoRoot;
+    await assertNoSymlinkPathComponents(root, resolved.absolutePath);
+    await assertCanonicalRepoContainment(root, resolved.absolutePath);
+    return resolved;
+}
+export async function executeGitDiffCheck(input, ctx) {
+    try {
+        const artifact = await resolvePatch(ctx, input.patch);
+        if (artifact.isEmpty) {
+            return { ok: false, changedFiles: [], fileCount: 0, lineCount: 0, error: 'Patch is empty.' };
+        }
+        const meta = validateDiff(artifact.patch);
+        return {
+            ok: true,
+            changedFiles: meta.changedFiles,
+            fileCount: meta.fileCount,
+            lineCount: meta.lineCount,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            changedFiles: [],
+            fileCount: 0,
+            lineCount: 0,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export async function executeGitApplyCheck(input, ctx) {
+    const artifact = await resolvePatch(ctx, input.patch);
+    if (artifact.isEmpty) {
+        return { ok: false, exitCode: null, output: 'Patch is empty.' };
+    }
+    const git = new GitAdapter(ctx.worktreeRoot || ctx.repoRoot);
+    return git.checkPatchApplyability(artifact.patch, {
+        ignoreWhitespace: input.ignoreWhitespace,
+        env: ctx.env,
+    });
+}
+export async function executeBenchmarkReport(input, ctx) {
+    const artifact = await resolvePatch(ctx, input.patch);
+    return {
+        provider: 'local',
+        patch: {
+            sha256: artifact.sha256,
+            bytes: artifact.bytes,
+            changedFiles: artifact.changedFiles,
+            isEmpty: artifact.isEmpty,
+        },
+    };
+}
+export async function executeSweBenchLoadInstance(input, ctx) {
+    const { absolutePath } = await resolveSafeRepoFile(ctx, input.file);
+    return parseSweBenchInstance(await new FileAdapter().readFile(absolutePath, 'utf8'));
+}
+export async function executeSweBenchWritePrediction(input, ctx) {
+    return buildSweBenchPredictionOutput(input, ctx);
+}
+async function buildSweBenchPredictionOutput(input, ctx, options = {}) {
+    const artifact = await resolvePatch(ctx, input.patch, options);
+    const predictionInput = {
+        instanceId: input.instanceId,
+        modelNameOrPath: input.modelNameOrPath,
+        modelPatch: artifact.patch,
+    };
+    return {
+        prediction: buildSweBenchPrediction(predictionInput),
+        jsonl: encodeSweBenchPredictionJsonl(predictionInput),
+    };
+}
+export async function executeSweBenchSubmitPredictions(input, ctx) {
+    const { absolutePath, relativePath } = await resolveSafeRepoFile(ctx, input.predictionsFile);
+    const output = await buildSweBenchPredictionOutput(input, ctx, {
+        excludePaths: [relativePath],
+    });
+    await new FileAdapter().appendFile(absolutePath, output.jsonl);
+    return {
+        predictionsFile: relativePath,
+        appended: true,
+        prediction: output.prediction,
+    };
+}
+export async function executeSweBenchGetReport(input, ctx) {
+    const { absolutePath } = await resolveSafeRepoFile(ctx, input.file);
+    const parsed = JSON.parse(await new FileAdapter().readFile(absolutePath, 'utf8'));
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('SWE-bench report must be a JSON object.');
+    }
+    return { report: parsed };
+}
+//# sourceMappingURL=benchmark.js.map

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

@@ -1,3 +1,4 @@
+import { resolve } from 'path';
 import { LIMITS } from '../../../../config/limits.js';
 import { parseRgJson } from '../parse/rg-json.js';
 export const rgBackend = {
@@ -20,7 +21,7 @@ export const rgBackend = {
         };
     },
     async run(input, ctx) {
-        const cwd = input.cwd ?? ctx.repoRoot;
+        const cwd = input.cwd ?? resolve(ctx.repoRoot);
         const args = [
             '--json',
             '--line-number',

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

@@ -4,6 +4,7 @@ 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';
+import { resolveCodeSearchCwd } from './spec.js';
 /**
  * The main executor for code.search.
  * It transforms the general ToolRuntimeCtx into a specialized CapabilityCtx
@@ -11,6 +12,10 @@ import { rgBackend } from './backends/rg.js';
  */
 export async function codeSearchExecutor(input, ctx) {
     getLogger().debug(`Searching for pattern: ${input.pattern}`);
+    const normalizedInput = {
+        ...input,
+        cwd: resolveCodeSearchCwd(ctx.repoRoot, input.cwd),
+    };
     // Construct CapabilityCtx for the underlying backends
     const capCtx = {
         repoRoot: ctx.repoRoot,
@@ -75,7 +80,7 @@ export async function codeSearchExecutor(input, ctx) {
         },
     };
     const backends = capCtx.platform === 'win32' ? [rgBackend, psBackend] : [rgBackend];
-    const { output, meta } = await runWithFallback(backends, input, capCtx, {
+    const { output, meta } = await runWithFallback(backends, normalizedInput, capCtx, {
         fallbackOn: new Set(['UNAVAILABLE', 'TIMEOUT', 'RUNTIME_ERROR', 'NONZERO_EXIT']),
         maxBackendTries: backends.length,
     });

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

@@ -1,4 +1,6 @@
+import { isAbsolute, relative, resolve } from 'path';
 import { z } from 'zod';
+import { text } from '../../../../locales/index.js';
 import { Phase } from '../../../types/runtime.js';
 import { repoResource } from '../../parallel/resource-helpers.js';
 const CoercedBoolean = z.preprocess((value) => {
@@ -25,7 +27,10 @@ export const CodeSearchInput = z.object({
         .max(500)
         .default(100)
         .describe('Maximum number of matches to return'),
-    cwd: z.string().optional().describe('Directory to search in (defaults to repo root)'),
+    cwd: z
+        .string()
+        .optional()
+        .describe('Directory to search in, relative to the repo root or an absolute path inside it'),
     isRegex: CoercedBoolean.default(false).describe('Whether to treat the pattern as a regular expression'),
 });
 export const CodeSearchMatch = z.object({
@@ -48,6 +53,17 @@ export const CodeSearchOutput = z.object({
     })
         .partial(),
 });
+export function resolveCodeSearchCwd(repoRoot, inputCwd) {
+    const absoluteRoot = resolve(repoRoot);
+    const absolutePath = isAbsolute(inputCwd ?? '')
+        ? resolve(inputCwd ?? absoluteRoot)
+        : resolve(absoluteRoot, inputCwd ?? '.');
+    const relativePath = relative(absoluteRoot, absolutePath);
+    if (relativePath.startsWith('..') || isAbsolute(relativePath)) {
+        throw new Error(text.errors.pathOutsideRepo);
+    }
+    return absolutePath;
+}
 /**
  * Specification for the code search tool.
  * The executor will be bound during tool registration.
@@ -61,7 +77,15 @@ export const CodeSearchSpec = {
     sideEffects: ['fs_read'],
     concurrency: 'parallel_ok',
     computeResources: (_input, ctx) => [repoResource(ctx)],
-    allowedPhases: [Phase.SLASH, Phase.CONTEXT, Phase.EXPLORE, Phase.PLAN, Phase.PATCH, Phase.VERIFY],
+    allowedPhases: [
+        Phase.SLASH,
+        Phase.CONTEXT,
+        Phase.EXPLORE,
+        Phase.PLAN,
+        Phase.AUTOPILOT,
+        Phase.PATCH,
+        Phase.VERIFY,
+    ],
     inputSchema: CodeSearchInput,
     outputSchema: CodeSearchOutput,
     examples: [