@qwen-code/arena-agent 0.0.10-dev.3 → 0.0.10-dev.5

package/dist/code-tools.js

@@ -12,6 +12,7 @@ import iconv from "iconv-lite";
 import mime from "mime/lite";
 import { executeBraveWebSearch } from "./brave-search.js";
 import { FetchPageReader } from "./fetch-page.js";
+import { replaceUniqueText } from "./file-edit.js";
 import { generatedImageBytesForExtension } from "./image.js";
 import { generateImageWithModelRouter, } from "./model-router-media.js";
 import { executeRoutifyWebFetch, routifyWebFetchEnabled, } from "./routify-web-fetch.js";
@@ -638,6 +639,57 @@ function interleaveMedia(left, right) {
 function normalizeMediaQuery(value) {
     return value.trim().replace(/\s+/g, " ").toLowerCase();
 }
+// Captured sessions call apply_patch even though no recorded request ever
+// advertised it: six react calls (s05/s17/s33) and 260+ html calls executed
+// successfully against the untouched 13-tool/7-tool contracts, while one h19
+// call was rejected by a turn whose runtime lacked it. The canonical schemas
+// stay untouched; the executor accepts the call the way the recording
+// environment's runtime did.
+const APPLY_PATCH_PARAMETERS = {
+    type: "object",
+    properties: {
+        input: { type: "string" },
+    },
+    required: ["input"],
+    additionalProperties: false,
+};
+const APPLY_PATCH_DESCRIPTION = "Apply a patch to files in the project. The patch uses the codex patch format: " +
+    "'*** Begin Patch' ... '*** End Patch', with '*** Add File: <path>' (content as " +
+    "'+'-prefixed lines), '*** Update File: <path>' ('@@'-separated hunks with ' ' " +
+    "context, '-' removed and '+' added lines), and '*** Delete File: <path>'.";
+// CODE_HARNESS_APPLY_PATCH_TOOL opts into advertising the tool to the model.
+// It stays out of the tool list by default while the executor still accepts
+// the call, matching the recorded runtime.
+function applyPatchToolAdvertised() {
+    const value = process.env.CODE_HARNESS_APPLY_PATCH_TOOL;
+    return (value !== undefined && !["0", "false", "no"].includes(value.toLowerCase()));
+}
+function locateHunkContext(lines, findLines, fromIndex) {
+    const limit = lines.length - findLines.length;
+    for (let start = Math.max(0, fromIndex); start <= limit; start += 1) {
+        let matched = true;
+        for (let offset = 0; offset < findLines.length; offset += 1) {
+            if (lines[start + offset] !== findLines[offset]) {
+                matched = false;
+                break;
+            }
+        }
+        if (matched)
+            return start;
+    }
+    for (let start = Math.max(0, fromIndex); start <= limit; start += 1) {
+        let matched = true;
+        for (let offset = 0; offset < findLines.length; offset += 1) {
+            if (lines[start + offset].trim() !== findLines[offset].trim()) {
+                matched = false;
+                break;
+            }
+        }
+        if (matched)
+            return start;
+    }
+    return undefined;
+}
 export class CodeToolExecutor {
     config;
     workspace;
@@ -671,12 +723,30 @@ export class CodeToolExecutor {
         this.workspaceContext = options.workspaceContext;
         this.pageReader = new FetchPageReader({ signal: options.signal });
         const disallowed = new Set(config.disallowedTools || []);
-        this.definitions = toolDefinitions(this.workspaceContext, config.mode).filter((definition) => !disallowed.has(definition.function.name));
+        const canonical = toolDefinitions(this.workspaceContext, config.mode).filter((definition) => !disallowed.has(definition.function.name));
+        const advertiseApplyPatch = applyPatchToolAdvertised() && !disallowed.has("apply_patch");
+        this.definitions = advertiseApplyPatch
+            ? [
+                ...canonical,
+                {
+                    type: "function",
+                    function: {
+                        name: "apply_patch",
+                        description: APPLY_PATCH_DESCRIPTION,
+                        parameters: APPLY_PATCH_PARAMETERS,
+                    },
+                },
+            ]
+            : canonical;
         this.seedFileRank = capturedSeedFileRank(config.mode);
         addFormats(this.ajv);
         for (const definition of this.definitions) {
             this.validators.set(definition.function.name, this.ajv.compile(definition.function.parameters));
         }
+        // Hidden mode: advertise nothing, but keep the call executable.
+        if (!advertiseApplyPatch && !disallowed.has("apply_patch")) {
+            this.validators.set("apply_patch", this.ajv.compile(APPLY_PATCH_PARAMETERS));
+        }
     }
     // The tool schemas offered to the model for this session. Identical to the
     // canonical trace set, adjusted for the selected workspace runtime.
@@ -706,6 +776,9 @@ export class CodeToolExecutor {
                 argumentsValue.offset ??= 1;
                 argumentsValue.limit ??= 2000;
             }
+            else if (name === "list_files" || name === "glob_files") {
+                argumentsValue.path ??= "";
+            }
             else if (name === "grep_files") {
                 argumentsValue.path ??= "";
                 argumentsValue.glob ??= "";
@@ -777,6 +850,8 @@ export class CodeToolExecutor {
                 return this.createCodeFile(String(values.path), String(values.content));
             case "edit_file":
                 return this.editCodeFile(String(values.path), String(values.context), String(values.replacement));
+            case "apply_patch":
+                return this.applyCodePatch(String(values.input));
             case "delete_file":
                 return this.deleteCodeFile(String(values.path));
             case "list_files":
@@ -806,8 +881,9 @@ export class CodeToolExecutor {
         }
     }
     lexicalPath(raw) {
-        if (!raw)
-            throw new Error("path must not be empty");
+        if (!raw || path.isAbsolute(raw) || raw.includes("..")) {
+            throw new Error("Path cannot be empty, start with '/', or contain '..'");
+        }
         let candidate;
         if (!this.workspaceContext && (raw === "/home/user" || raw === "~")) {
             candidate = this.workspace;
@@ -852,8 +928,7 @@ export class CodeToolExecutor {
         return path.relative(this.workspaceReal, target).split(path.sep).join("/");
     }
     rememberListedFile(filePath) {
-        if (this.seedFileRank.has(filePath) ||
-            this.listedFileOrder.has(filePath)) {
+        if (this.seedFileRank.has(filePath) || this.listedFileOrder.has(filePath)) {
             return;
         }
         this.listedFileOrder.set(filePath, this.nextListedFileOrder);
@@ -888,7 +963,7 @@ export class CodeToolExecutor {
                 return -1;
             if (rightSeedRank !== undefined)
                 return 1;
-            return (this.listedFileOrder.get(left) - this.listedFileOrder.get(right));
+            return this.listedFileOrder.get(left) - this.listedFileOrder.get(right);
         });
     }
     async existsWithExactCase(rawPath) {
@@ -966,14 +1041,23 @@ export class CodeToolExecutor {
         }
         const lines = decodeText(data).split("\n");
         const start = Math.max(1, Math.trunc(offset));
+        if (start > lines.length) {
+            return {
+                status: "success",
+                file: {
+                    path: this.relativePath(target),
+                    content: `Offset ${start} is out of range for this file (${lines.length} lines)`,
+                    contentType: contentTypeForFile(target),
+                },
+                totalLines: lines.length,
+            };
+        }
         const end = Math.min(lines.length, start + Math.max(1, Math.trunc(limit)) - 1);
-        const numbered = start > lines.length
-            ? ""
-            : lines
-                .slice(start - 1, end)
-                .map((line, index) => `${start + index}: ${line}`)
-                .join("\n");
-        const footer = start === 1 && end === lines.length
+        const numbered = lines
+            .slice(start - 1, end)
+            .map((line, index) => `${start + index}: ${line}`)
+            .join("\n");
+        const footer = end === lines.length
             ? `(End of file - ${lines.length} lines)`
             : `(Showing lines ${start}-${end} of ${lines.length}. Use offset=${end + 1} to continue.)`;
         return {
@@ -1063,15 +1147,165 @@ export class CodeToolExecutor {
                 message: `File "${rawPath}" does not exist`,
             };
         }
-        if (!source.includes(context)) {
+        const edited = replaceUniqueText(source, context, replacement, {
+            whitespaceInsensitiveMultiline: true,
+        });
+        if (edited === undefined) {
+            // Captured sessions re-issue an edit after compaction or a retry. The
+            // provider reports success without touching the file when the context
+            // is already gone and the replacement is in place (f39 re-issues four
+            // dashboard edits this way).
+            if (replacement && source.includes(replacement)) {
+                return this.mutationResult("Edited", rawPath);
+            }
             return {
                 status: "error",
                 message: "Context not found. Read the file to verify the text exists.",
             };
         }
-        await writeFile(target, source.replace(context, replacement), "utf8");
+        await writeFile(target, edited, "utf8");
         return this.mutationResult("Edited", rawPath);
     }
+    // Some recorded sessions exposed a codex-style apply_patch tool (*** Begin
+    // Patch / Add|Update|Delete File / @@ hunks) that the provider executed
+    // without ever advertising it. Its observable contract: "Patch applied[.
+    // Type errors found.]" on success, "Invalid Context <anchor>:\n<context>"
+    // when a hunk context cannot be located — the anchor is the line where the
+    // previous hunk's match ended and the failed search started (h17 reports
+    // 666 after a four-line context hunk matching lines 663-666).
+    async applyCodePatch(patchText) {
+        const kindByMarker = {
+            Add: "add",
+            Update: "update",
+            Delete: "delete",
+        };
+        const operations = [];
+        let current;
+        for (const line of patchText.split("\n")) {
+            const marker = /^\*\*\* (Add|Update|Delete) File: (.+)$/.exec(line);
+            if (marker) {
+                current = {
+                    kind: kindByMarker[marker[1]],
+                    path: marker[2].trim(),
+                    lines: [],
+                };
+                operations.push(current);
+                continue;
+            }
+            if (line.startsWith("*** ")) {
+                current = undefined;
+                continue;
+            }
+            current?.lines.push(line);
+        }
+        for (const operation of operations) {
+            const target = await this.confinedPath(operation.path);
+            if (operation.kind === "add") {
+                if (await this.existsWithExactCase(operation.path)) {
+                    return {
+                        status: "error",
+                        message: `Add File Error: Duplicate Path: ${operation.path}`,
+                    };
+                }
+                // The recorded provider writes exactly the "+" lines joined by
+                // newlines without appending a trailing one (h17's 27-line
+                // manifest.json reads back as totalLines 27, not 28).
+                const content = operation.lines
+                    .filter((line) => line.startsWith("+"))
+                    .map((line) => line.slice(1))
+                    .join("\n");
+                mkdirSync(path.dirname(target), { recursive: true });
+                await writeFile(target, content, "utf8");
+                this.rememberListedFile(this.relativePath(target));
+                continue;
+            }
+            if (operation.kind === "delete") {
+                if (!(await this.existsWithExactCase(operation.path))) {
+                    return {
+                        status: "error",
+                        message: `Delete File Error: File Not Found: ${operation.path}`,
+                    };
+                }
+                await rm(target, { force: true });
+                this.forgetListedPath(this.relativePath(target));
+                continue;
+            }
+            let source;
+            try {
+                if (!(await this.existsWithExactCase(operation.path)))
+                    throw new Error("missing");
+                source = await readFile(target, "utf8");
+            }
+            catch {
+                return {
+                    status: "error",
+                    message: `Update File Error: File Not Found: ${operation.path}`,
+                };
+            }
+            // Hunks are separated by @@ lines; within a hunk, " " context and "-"
+            // removed lines form the find pattern, " " context and "+" added lines
+            // form the replacement. Hunks stream over the original file: each
+            // context is searched forward from where the previous hunk ended, and a
+            // miss reports the search anchor over the find text the way the
+            // recorded provider does (h17: "Invalid Context 666:"). Whitespace
+            // drifted contexts match by trimmed lines.
+            const hunks = [];
+            let hunk = [];
+            for (const line of operation.lines) {
+                if (line.startsWith("@@")) {
+                    if (hunk.length)
+                        hunks.push(hunk);
+                    hunk = [];
+                    continue;
+                }
+                hunk.push(line);
+            }
+            if (hunk.length)
+                hunks.push(hunk);
+            const originalLines = source.split("\n");
+            const output = [];
+            let position = 0;
+            for (const hunkLines of hunks) {
+                const findLines = [];
+                const replaceLines = [];
+                for (const line of hunkLines) {
+                    if (line.startsWith("-")) {
+                        findLines.push(line.slice(1));
+                    }
+                    else if (line.startsWith("+")) {
+                        replaceLines.push(line.slice(1));
+                    }
+                    else {
+                        findLines.push(line.slice(1));
+                        replaceLines.push(line.slice(1));
+                    }
+                }
+                if (!findLines.length)
+                    continue;
+                const start = locateHunkContext(originalLines, findLines, position);
+                if (start === undefined) {
+                    return {
+                        status: "error",
+                        message: `Invalid Context ${position}:\n${findLines.join("\n")}`,
+                    };
+                }
+                output.push(...originalLines.slice(position, start));
+                output.push(...replaceLines);
+                position = start + findLines.length;
+            }
+            output.push(...originalLines.slice(position));
+            await writeFile(target, output.join("\n"), "utf8");
+        }
+        const lintError = await this.typeErrors();
+        if (lintError) {
+            return {
+                status: "success",
+                message: "Patch applied. Type errors found.",
+                lint_error: lintError,
+            };
+        }
+        return { status: "success", message: "Patch applied." };
+    }
     async deleteCodeFile(rawPath) {
         const target = await this.confinedPath(rawPath);
         await rm(target, { force: true, recursive: true });
@@ -1091,21 +1325,61 @@ export class CodeToolExecutor {
         };
     }
     async grepCodeFiles(values) {
+        const pattern = String(values.pattern);
+        if (pattern.length > 200) {
+            return {
+                status: "error",
+                message: "Pattern too long (max 200 characters)",
+            };
+        }
         const target = await this.confinedPath(String(values.path || "."));
-        const targetInfo = await stat(target);
-        const files = await this.walkFiles(target);
         const glob = String(values.glob || "");
+        const mode = String(values.output_mode || "content");
         const flags = Boolean(values["-i"]) ? "i" : "";
         let expression;
         try {
-            expression = new RegExp(String(values.pattern), flags);
+            expression = new RegExp(pattern, flags);
         }
         catch (error) {
             throw new Error(`Invalid regular expression: ${errorMessage(error)}`);
         }
-        const symmetric = Math.max(Number(values.context || 0), Number(values["-C"] || 0));
+        let targetInfo;
+        try {
+            targetInfo = await stat(target);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            if (mode === "files_with_matches") {
+                return { status: "success", mode, files: [], truncated: false };
+            }
+            if (mode === "count") {
+                return {
+                    status: "success",
+                    mode,
+                    counts: [],
+                    totalMatches: 0,
+                    truncated: false,
+                };
+            }
+            return {
+                status: "success",
+                mode: "content",
+                matches: [],
+                truncated: false,
+            };
+        }
+        const files = await this.walkFiles(target);
+        // Full Stack captures expose a different context-grouping adapter from
+        // HTML/React: -C/context are ignored, the trailing group spans B+A lines,
+        // and a later match reuses the prior trailing group as contextBefore.
+        const groupedContext = this.config.mode === "full-stack";
+        const symmetric = groupedContext
+            ? 0
+            : Math.max(Number(values.context || 0), Number(values["-C"] || 0));
         const before = symmetric || Number(values["-B"] || 0);
         const after = symmetric || Number(values["-A"] || 0);
+        const contextSpan = groupedContext ? before + after : after;
         const matches = [];
         const matchedFiles = [];
         const counts = [];
@@ -1115,6 +1389,11 @@ export class CodeToolExecutor {
             const relativeToSearch = targetInfo.isFile()
                 ? path.basename(filePath)
                 : path.relative(target, filePath).split(path.sep).join("/");
+            if (relativeToSearch
+                .split("/")
+                .some((component) => component.startsWith("."))) {
+                continue;
+            }
             if (glob && !matchesGlob(relativeToSearch, glob))
                 continue;
             let content;
@@ -1129,11 +1408,15 @@ export class CodeToolExecutor {
                 continue;
             }
             const lines = content.split("\n");
-            let fileCount = 0;
+            const matchingLines = [];
             for (let index = 0; index < lines.length; index += 1) {
-                if (!expression.test(lines[index]))
-                    continue;
-                fileCount += 1;
+                if (expression.test(lines[index]))
+                    matchingLines.push(index);
+            }
+            const fileCount = matchingLines.length;
+            let previousAfter = [];
+            for (let position = 0; position < matchingLines.length; position += 1) {
+                const index = matchingLines[position];
                 totalMatches += 1;
                 if (matches.length < maximumSearchResults) {
                     const match = {
@@ -1141,11 +1424,29 @@ export class CodeToolExecutor {
                         lineNumber: index + 1,
                         lineContent: lines[index],
                     };
-                    if (before > 0) {
-                        match.contextBefore = lines.slice(Math.max(0, index - before), index);
+                    if (groupedContext) {
+                        const contextBefore = position === 0
+                            ? lines.slice(Math.max(0, index - before), index)
+                            : previousAfter;
+                        if (contextBefore.length > 0)
+                            match.contextBefore = contextBefore;
+                        const nextMatch = matchingLines[position + 1] ?? lines.length;
+                        previousAfter = lines.slice(index + 1, Math.min(index + 1 + contextSpan, nextMatch));
+                        if (nextMatch === lines.length &&
+                            previousAfter.at(-1) === "" &&
+                            index + 1 + contextSpan >= lines.length) {
+                            previousAfter = previousAfter.slice(0, -1);
+                        }
+                        if (previousAfter.length > 0)
+                            match.contextAfter = previousAfter;
                     }
-                    if (after > 0) {
-                        match.contextAfter = lines.slice(index + 1, index + 1 + after);
+                    else {
+                        if (before > 0) {
+                            match.contextBefore = lines.slice(Math.max(0, index - before), index);
+                        }
+                        if (after > 0) {
+                            match.contextAfter = lines.slice(index + 1, index + 1 + after);
+                        }
                     }
                     matches.push(match);
                 }
@@ -1158,7 +1459,6 @@ export class CodeToolExecutor {
                 }
             }
         }
-        const mode = String(values.output_mode || "content");
         if (mode === "files_with_matches") {
             return {
                 status: "success",
@@ -1185,7 +1485,15 @@ export class CodeToolExecutor {
     }
     async globCodeFiles(pattern, rawPath) {
         const target = await this.confinedPath(rawPath || ".");
-        const files = await this.walkFiles(target);
+        let files;
+        try {
+            files = await this.walkFiles(target);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            return { status: "success", paths: [], truncated: false };
+        }
         const allPaths = files
             .filter((filePath) => matchesGlob(path.relative(target, filePath).split(path.sep).join("/"), pattern))
             .map((filePath) => this.relativePath(filePath));
@@ -1302,18 +1610,6 @@ export class CodeToolExecutor {
             stderr: this.virtualizeCodeOutput(result.stderr),
         };
     }
-    virtualizeBashOutput(value) {
-        if (this.workspaceContext || this.config.mode === "full-stack")
-            return value;
-        let virtualized = value;
-        const workspaceRoots = [...new Set([this.workspace, this.workspaceReal])]
-            .filter((root) => root !== path.parse(root).root)
-            .sort((left, right) => right.length - left.length);
-        for (const root of workspaceRoots) {
-            virtualized = virtualized.replaceAll(root, "/home/user");
-        }
-        return virtualized;
-    }
     async fullStackBash(command, workdir) {
         const configuredTimeout = Number(process.env.CODE_HARNESS_BASH_TIMEOUT_SECONDS || 300);
         const timeoutSeconds = Number.isFinite(configuredTimeout) && configuredTimeout > 0
@@ -1454,12 +1750,6 @@ export class CodeToolExecutor {
         if (!(await stat(workdir)).isDirectory()) {
             throw new Error(`cwd is not a directory: ${cwd}`);
         }
-        // Runtime-aware callers execute commands exactly as written and report
-        // real local paths. The legacy /home/user translation is limited to the
-        // older non-Full-Stack replay contract.
-        const translatedCommand = this.workspaceContext || this.config.mode === "full-stack"
-            ? command
-            : command.replaceAll("/home/user", '"$ARENA_WORKSPACE"');
         return new Promise((resolve, reject) => {
             const env = {
                 ...process.env,
@@ -1477,7 +1767,7 @@ export class CodeToolExecutor {
             // detached：管道成员（npm、tail…）与 bash 同进程组。只杀 bash 会留下
             // 孤儿持有 stdout/stderr 管道，close 永不触发，整个 turn 挂死；
             // 必须杀整组，并在宽限期后强制结算兜底。
-            const child = spawn("/bin/bash", ["-c", translatedCommand], {
+            const child = spawn("/bin/bash", ["-c", command], {
                 cwd: workdir,
                 env,
                 stdio: ["ignore", "pipe", "pipe"],
@@ -1531,8 +1821,8 @@ export class CodeToolExecutor {
                     stderr +=
                         (stderr ? "\n" : "") + `command exceeded ${timeoutSeconds}s`;
                 }
-                const out = capBashOutput(this.virtualizeBashOutput(stdout));
-                const err = capBashOutput(this.virtualizeBashOutput(stderr));
+                const out = capBashOutput(stdout);
+                const err = capBashOutput(stderr);
                 resolve({
                     status: "completed",
                     stderr: err.text,