minimal-agent 0.13.0 → 0.14.0

package/src/tools/agent/agentTypes.ts

@@ -14,6 +14,8 @@
  * ============================================================
  */
 
+import { DEFAULT_SUBAGENTS_CONFIG } from '../../config/configDefaults.js';
+
 export type AgentTypeName = 'explore' | 'general';
 
 export interface AgentTypeDef {
@@ -37,7 +39,13 @@ export interface AgentTypeDef {
  */
 export const SUBAGENT_EXCLUDED_TOOLS: readonly string[] = [
   'Agent',
+  'AgentMessage',
+  'AgentList',
+  'AgentWait',
+  'AgentInterrupt',
+  'AgentFollowup',
   'Advisor',
+  'AdvisorDecision',
   // 子任务只向主 Agent 汇报；正式用户交付由主 Agent 统一收口，避免重复结果卡。
   'PresentResult',
   'RememberMemory',
@@ -59,6 +67,8 @@ export const EXPLORE_ALLOWED_TOOLS: readonly string[] = [
   'WebSearch',
   'WebFetch',
   'WebBrowser',
+  'BrowserBatch',
+  'BrowserCDP',
   'RecallMemory',
   'ListMemories',
   'ReviewMemories',
@@ -74,17 +84,20 @@ const EXPLORE_APPENDIX = `# 本次子任务类型：只读调研（explore）
 const GENERAL_APPENDIX = `# 本次子任务类型：读写执行（general）
 只做任务书范围内的修改；报告列出改动文件和验证结果。`;
 
+// 轮数上限的**唯一真值**在 configDefaults.ts。这里只是「没有 subagentConfig 时」的
+// 兜底取值，必须与那份一致 —— 曾经两边各写一份字面量（都是 200/100），
+// 改一处漏一处就会出现「有配置时 200、没配置时 50」这种只在缺省路径显形的分裂。
 const EXPLORE_DEF: AgentTypeDef = {
   type: 'explore',
   resolveAllowedTools: (all) => all.filter((n) => EXPLORE_ALLOWED_TOOLS.includes(n)),
-  maxTurns: 50,
+  maxTurns: DEFAULT_SUBAGENTS_CONFIG.exploreMaxTurns,
   promptAppendix: EXPLORE_APPENDIX,
 };
 
 const GENERAL_DEF: AgentTypeDef = {
   type: 'general',
   resolveAllowedTools: (all) => all.filter((n) => !SUBAGENT_EXCLUDED_TOOLS.includes(n)),
-  maxTurns: 100,
+  maxTurns: DEFAULT_SUBAGENTS_CONFIG.generalMaxTurns,
   promptAppendix: GENERAL_APPENDIX,
 };
 

package/src/tools/applypatch/applyPatch.js

@@ -0,0 +1,362 @@
+import { existsSync } from 'node:fs';
+import { realpath, rm } from 'node:fs/promises';
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { z } from 'zod';
+import { getWorkingDir } from '../../bootstrap/workingDir.js';
+import { buildPatchSummary } from '../shared/diffSummary.js';
+import { fileActivityMetadata } from '../shared/fileActivity.js';
+import { emitFileMutation } from '../shared/fileMutationBus.js';
+import { hashFileBytes, recordRead } from '../shared/fileState.js';
+import { applyLineEnding, atomicWriteFile, encodeTextFile, hasBinaryExtension, readTextFile, } from '../shared/fileUtils.js';
+import { DEFAULT_MAX_RESULT_SIZE_CHARS } from '../types.js';
+const schema = z.object({
+    patch: z.string().min(1).max(10_000_000),
+});
+function fail(message) {
+    throw new Error(message);
+}
+/** Parse the Codex apply_patch envelope without invoking a platform patch binary. */
+export function parseApplyPatch(input) {
+    const lines = input.replaceAll('\r\n', '\n').split('\n');
+    if (lines[0] !== '*** Begin Patch')
+        fail('补丁必须以 *** Begin Patch 开始');
+    const operations = [];
+    let index = 1;
+    while (index < lines.length) {
+        const line = lines[index];
+        if (line === '*** End Patch') {
+            if (lines.slice(index + 1).some((item) => item.trim()))
+                fail('*** End Patch 后不能再有内容');
+            if (!operations.length)
+                fail('补丁中没有文件操作');
+            return operations;
+        }
+        if (line.startsWith('*** Add File: ')) {
+            const path = line.slice('*** Add File: '.length);
+            index += 1;
+            const added = [];
+            while (index < lines.length && !lines[index].startsWith('*** ')) {
+                const contentLine = lines[index];
+                if (!contentLine.startsWith('+'))
+                    fail(`Add File ${path} 的内容行必须以 + 开头（第 ${index + 1} 行）`);
+                added.push(contentLine.slice(1));
+                index += 1;
+            }
+            operations.push({
+                kind: 'add',
+                path,
+                content: added.length ? `${added.join('\n')}\n` : '',
+            });
+            continue;
+        }
+        if (line.startsWith('*** Delete File: ')) {
+            operations.push({
+                kind: 'delete',
+                path: line.slice('*** Delete File: '.length),
+            });
+            index += 1;
+            continue;
+        }
+        if (line.startsWith('*** Update File: ')) {
+            const path = line.slice('*** Update File: '.length);
+            index += 1;
+            let moveTo;
+            if (lines[index]?.startsWith('*** Move to: ')) {
+                moveTo = lines[index].slice('*** Move to: '.length);
+                index += 1;
+            }
+            const hunks = [];
+            while (index < lines.length && !lines[index].startsWith('*** ')) {
+                const headerLine = lines[index];
+                if (!headerLine.startsWith('@@'))
+                    fail(`Update File ${path} 缺少 @@ hunk 头（第 ${index + 1} 行）`);
+                const match = /^@@(?: -(\d+)(?:,\d+)? \+\d+(?:,\d+)?)? @@\s*(.*)$/.exec(headerLine);
+                const header = match
+                    ? match[2]
+                    : headerLine.slice(2).replace(/^\s+|\s+$/g, '');
+                const oldStart = match?.[1] ? Number(match[1]) : undefined;
+                index += 1;
+                const hunkLines = [];
+                while (index < lines.length &&
+                    !lines[index].startsWith('@@') &&
+                    (!lines[index].startsWith('*** ') ||
+                        lines[index] === '*** End of File')) {
+                    const hunkLine = lines[index];
+                    if (hunkLine === '*** End of File') {
+                        index += 1;
+                        continue;
+                    }
+                    const prefix = hunkLine[0];
+                    if (prefix !== ' ' && prefix !== '+' && prefix !== '-')
+                        fail(`hunk 内容行必须以空格、+ 或 - 开头（第 ${index + 1} 行）`);
+                    hunkLines.push({
+                        kind: prefix === ' ' ? 'context' : prefix === '+' ? 'add' : 'delete',
+                        text: hunkLine.slice(1),
+                    });
+                    index += 1;
+                }
+                if (!hunkLines.length)
+                    fail(`Update File ${path} 包含空 hunk`);
+                hunks.push({ header, oldStart, lines: hunkLines });
+            }
+            if (!hunks.length && !moveTo)
+                fail(`Update File ${path} 没有 hunk`);
+            operations.push({
+                kind: 'update',
+                path,
+                ...(moveTo ? { moveTo } : {}),
+                hunks,
+            });
+            continue;
+        }
+        fail(`无法识别补丁指令（第 ${index + 1} 行）：${line}`);
+    }
+    fail('补丁缺少 *** End Patch');
+}
+function within(root, candidate) {
+    const rel = relative(root, candidate);
+    return (rel === '' ||
+        (!isAbsolute(rel) && rel !== '..' && !rel.startsWith(`..${sep}`)));
+}
+async function nearestExistingAncestor(path) {
+    let current = path;
+    while (!existsSync(current)) {
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return realpath(current);
+}
+async function workspacePath(raw, cwd) {
+    if (!raw || isAbsolute(raw) || raw.includes('\0'))
+        fail(`补丁路径必须是非空的工作区相对路径：${raw}`);
+    const absolute = resolve(cwd, raw);
+    const rel = relative(resolve(cwd), absolute);
+    if (rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+        fail(`补丁路径越过工作区边界：${raw}`);
+    const physicalRoot = await realpath(resolve(cwd)).catch(() => resolve(cwd));
+    const physicalBoundary = existsSync(absolute)
+        ? await realpath(absolute)
+        : await nearestExistingAncestor(dirname(absolute));
+    if (!within(physicalRoot, physicalBoundary))
+        fail(`补丁路径通过符号链接越过工作区边界：${raw}`);
+    if (hasBinaryExtension(absolute))
+        fail(`ApplyPatch 不支持二进制文件：${raw}`);
+    return absolute;
+}
+export function applyHunks(original, hunks) {
+    const normalized = original.replaceAll('\r\n', '\n');
+    const trailingNewline = normalized.endsWith('\n');
+    const lines = normalized.split('\n');
+    if (trailingNewline)
+        lines.pop();
+    let cursor = 0;
+    for (const hunk of hunks) {
+        if (hunk.header) {
+            const anchor = lines.findIndex((line, index) => index >= cursor && line.includes(hunk.header));
+            if (anchor < 0)
+                fail(`找不到 hunk 锚点：${hunk.header}`);
+            cursor = anchor;
+        }
+        const before = hunk.lines
+            .filter((line) => line.kind !== 'add')
+            .map((line) => line.text);
+        const after = hunk.lines
+            .filter((line) => line.kind !== 'delete')
+            .map((line) => line.text);
+        const matchesAt = (start) => before.every((line, offset) => lines[start + offset] === line);
+        let at = -1;
+        if (!before.length) {
+            at =
+                hunk.oldStart === undefined
+                    ? cursor
+                    : Math.max(cursor, Math.min(lines.length, hunk.oldStart - 1));
+        }
+        else {
+            for (let index = cursor; index <= lines.length - before.length; index += 1) {
+                if (matchesAt(index)) {
+                    at = index;
+                    break;
+                }
+            }
+            if (at < 0 && cursor > 0) {
+                const matches = [];
+                for (let index = 0; index <= lines.length - before.length; index += 1)
+                    if (matchesAt(index))
+                        matches.push(index);
+                if (matches.length === 1)
+                    at = matches[0];
+            }
+        }
+        if (at < 0)
+            fail(`hunk 上下文与当前文件不匹配：${before.join('\n').slice(0, 240)}`);
+        lines.splice(at, before.length, ...after);
+        cursor = at + after.length;
+    }
+    return `${lines.join('\n')}${trailingNewline ? '\n' : ''}`;
+}
+async function stagePatch(operations, cwd) {
+    const staged = [];
+    const touched = new Set();
+    const claim = (path) => {
+        if (touched.has(path))
+            fail(`同一补丁不能重复操作同一路径：${path}`);
+        touched.add(path);
+    };
+    for (const operation of operations) {
+        const path = await workspacePath(operation.path, cwd);
+        claim(path);
+        if (operation.kind === 'add') {
+            if (existsSync(path))
+                fail(`Add File 目标已存在：${operation.path}`);
+            staged.push({
+                path,
+                label: operation.path,
+                beforeText: '',
+                after: operation.content,
+                encoding: 'utf8',
+                activity: 'created',
+            });
+            continue;
+        }
+        if (!existsSync(path))
+            fail(`${operation.kind === 'delete' ? 'Delete' : 'Update'} File 不存在：${operation.path}`);
+        const snapshot = await readTextFile(path);
+        if (operation.kind === 'delete') {
+            staged.push({
+                path,
+                label: operation.path,
+                before: snapshot.bytes,
+                beforeText: snapshot.content,
+                encoding: snapshot.encoding,
+                activity: 'deleted',
+            });
+            continue;
+        }
+        const updated = applyLineEnding(applyHunks(snapshot.content, operation.hunks), snapshot.lineEnding);
+        if (operation.moveTo) {
+            const target = await workspacePath(operation.moveTo, cwd);
+            claim(target);
+            if (existsSync(target))
+                fail(`Move to 目标已存在：${operation.moveTo}`);
+            staged.push({
+                path,
+                label: operation.path,
+                before: snapshot.bytes,
+                beforeText: snapshot.content,
+                encoding: snapshot.encoding,
+                activity: 'deleted',
+            });
+            staged.push({
+                path: target,
+                label: operation.moveTo,
+                beforeText: '',
+                after: updated,
+                encoding: snapshot.encoding,
+                activity: 'created',
+            });
+        }
+        else {
+            staged.push({
+                path,
+                label: operation.path,
+                before: snapshot.bytes,
+                beforeText: snapshot.content,
+                after: updated,
+                encoding: snapshot.encoding,
+                activity: 'modified',
+            });
+        }
+    }
+    return staged;
+}
+async function commit(staged) {
+    const committed = [];
+    try {
+        for (const file of staged) {
+            if (file.after === undefined)
+                await rm(file.path);
+            else
+                await atomicWriteFile(file.path, file.after, file.encoding);
+            committed.push(file);
+        }
+    }
+    catch (error) {
+        const rollbackErrors = [];
+        for (const file of committed.reverse()) {
+            try {
+                if (file.before)
+                    await atomicWriteFile(file.path, file.before);
+                else
+                    await rm(file.path, { force: true });
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(`${file.label}: ${rollbackError.message}`);
+            }
+        }
+        const suffix = rollbackErrors.length
+            ? `；回滚也有失败：${rollbackErrors.join('；')}`
+            : '；已回滚本次已落盘文件';
+        throw new Error(`${error.message}${suffix}`);
+    }
+}
+async function call(input, context) {
+    const cwd = context?.cwd ?? getWorkingDir();
+    let operations;
+    let staged;
+    try {
+        operations = parseApplyPatch(input.patch);
+        staged = await stagePatch(operations, cwd);
+        await commit(staged);
+    }
+    catch (error) {
+        return { ok: false, error: `ApplyPatch 失败：${error.message}` };
+    }
+    const files = [];
+    const summaries = [];
+    for (const file of staged) {
+        const afterText = file.after ?? '';
+        const patch = buildPatchSummary(file.beforeText, afterText, file.label);
+        const metadata = await fileActivityMetadata(file.path, file.activity, 'not_run', 'support', cwd, patch);
+        if (metadata)
+            files.push(...metadata.files);
+        if (file.after === undefined)
+            context?.sessionState?.fileReads.entries.delete(file.path);
+        else
+            recordRead(file.path, {
+                contentHash: hashFileBytes(encodeTextFile(file.after, file.encoding)),
+            }, context?.sessionState?.fileReads);
+        emitFileMutation(file.path);
+        summaries.push(`${file.activity}: ${file.label} (+${patch.additions} -${patch.deletions})`);
+    }
+    return {
+        ok: true,
+        content: `已应用补丁：\n${summaries.map((line) => `- ${line}`).join('\n')}`,
+        ...(files.length
+            ? { metadata: { kind: 'file_activity', files } }
+            : {}),
+    };
+}
+export const applyPatchTool = {
+    name: 'ApplyPatch',
+    description: 'Applies one Codex-style *** Begin Patch / *** End Patch transaction across text files. ' +
+        'Supports Add File, Update File, Delete File and Move to. All operations are parsed and validated before writing; runtime failures roll back files already changed by this call. Paths must stay inside the workspace.',
+    inputSchema: schema,
+    parameters: {
+        type: 'object',
+        properties: {
+            patch: {
+                type: 'string',
+                description: 'Complete Codex-style patch envelope',
+            },
+        },
+        required: ['patch'],
+    },
+    isReadOnly: false,
+    isConcurrencySafe: false,
+    maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+    interruptBehavior: () => 'block',
+    call: (input) => call(input),
+    callWithContext: (input, _signal, context) => call(input, context),
+};