praxis-agent 0.55.2 → 0.56.0

package/dist/tools/local-tools.js

@@ -12,6 +12,8 @@ import { countLineChanges } from './line-changes.js';
 import { editNotebook, formatNotebookForRead } from './notebook.js';
 import { openPdf } from './pdf.js';
 import { validateBashPathSafety } from '../permissions/bash-path-safety.js';
+import { APPLY_PATCH_DEFINITION, APPLY_PATCH_MAX_FILES, parseApplyPatchInput, planApplyPatch, } from './apply-patch.js';
+import { writeFileAtomically } from '../platform/atomic-write.js';
 import { protectedWritePathReason } from '../permissions/bypass-immune-paths.js';
 import { effectiveAdditionalDirectories, shellInputIsReadOnly, } from '../permissions/permission-updates.js';
 const REPORT_FINDINGS_DEFINITION = {
@@ -160,6 +162,7 @@ const TOOL_DEFINITIONS = [
             additionalProperties: false,
         },
     },
+    APPLY_PATCH_DEFINITION,
     {
         name: 'NotebookEdit',
         description: 'Replace, insert, or delete one cell in a Jupyter notebook after reading it.',
@@ -627,7 +630,15 @@ export class LocalToolRegistry {
             this.additionalReadDirectories.length === 0) {
             return definitions;
         }
-        return definitions.map((definition) => ['Read', 'Write', 'Edit', 'NotebookEdit', 'Glob', 'Grep'].includes(definition.name)
+        return definitions.map((definition) => [
+            'Read',
+            'Write',
+            'Edit',
+            'ApplyPatch',
+            'NotebookEdit',
+            'Glob',
+            'Grep',
+        ].includes(definition.name)
             ? {
                 ...definition,
                 description: `${definition.description}${this.additionalDirectories.length === 0
@@ -731,6 +742,26 @@ export class LocalToolRegistry {
                 this.mutationTargetExisted.set(prepared, targetExisted);
                 return prepared;
             }
+            case 'ApplyPatch': {
+                const edits = parseApplyPatchInput(call.input);
+                const preparedEdits = [];
+                for (const edit of edits) {
+                    const filePath = await this.filePath(edit.file_path, false, false, context);
+                    this.assertProtectedWritePath(filePath);
+                    if (!(await this.wasSuccessfullyRead(filePath, context.messages ?? [], context))) {
+                        throw new Error('<tool_use_error>File has not been read yet. Read it first before writing to it.</tool_use_error>');
+                    }
+                    preparedEdits.push({
+                        file_path: filePath,
+                        old_string: edit.old_string,
+                        new_string: edit.new_string,
+                    });
+                }
+                if (new Set(preparedEdits.map((edit) => edit.file_path)).size >
+                    APPLY_PATCH_MAX_FILES)
+                    throw new Error('ApplyPatch may touch at most 8 files');
+                return { ...call, input: { edits: preparedEdits } };
+            }
             case 'NotebookEdit': {
                 const requestedPath = stringInput(call.input, 'notebook_path');
                 if (!isAbsolute(requestedPath)) {
@@ -839,6 +870,8 @@ export class LocalToolRegistry {
                 return this.write(prepared, context, targetExisted);
             case 'Edit':
                 return this.edit(prepared, targetExisted);
+            case 'ApplyPatch':
+                return this.applyPatch(prepared, context);
             case 'NotebookEdit':
                 return this.notebookEdit(prepared);
             case 'Glob':
@@ -1222,6 +1255,74 @@ export class LocalToolRegistry {
             await handle.close();
         }
     }
+    async applyPatch(call, context) {
+        const edits = parseApplyPatchInput(call.input);
+        const sources = new Map();
+        const modes = new Map();
+        const identities = new Map();
+        const paths = [];
+        for (const edit of edits) {
+            const filePath = edit.file_path;
+            if (sources.has(filePath))
+                continue;
+            paths.push(filePath);
+            const handle = await open(filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+            try {
+                await this.assertStablePath(filePath);
+                const metadata = await handle.stat();
+                if (!metadata.isFile())
+                    throw new Error(`Not a file: ${filePath}`);
+                if (metadata.size > this.maxFileBytes)
+                    throw new Error(`File exceeds ${this.maxFileBytes} byte edit limit`);
+                sources.set(filePath, await handle.readFile('utf8'));
+                identities.set(filePath, { dev: metadata.dev, ino: metadata.ino });
+                modes.set(filePath, metadata.mode & 0o7777);
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        const plan = planApplyPatch(edits, sources, this.maxFileBytes);
+        for (const file of plan.files) {
+            if (context.signal?.aborted)
+                throw abortError();
+            const mode = modes.get(file.filePath);
+            const committed = await writeFileAtomically(file.filePath, file.after, {
+                ...(mode === undefined ? {} : { mode }),
+                beforeCommit: async () => {
+                    let handle;
+                    try {
+                        handle = await open(file.filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+                        await this.assertStablePath(file.filePath);
+                        const metadata = await handle.stat();
+                        if (!metadata.isFile())
+                            return false;
+                        const identity = identities.get(file.filePath);
+                        if (!identity ||
+                            metadata.dev !== identity.dev ||
+                            metadata.ino !== identity.ino)
+                            return false;
+                        return (await handle.readFile('utf8')) === file.before;
+                    }
+                    catch {
+                        return false;
+                    }
+                    finally {
+                        await handle?.close();
+                    }
+                },
+            });
+            if (!committed)
+                throw new Error('Tool input changed after permission approval');
+        }
+        return {
+            content: `Applied ${edits.length} replacement(s) to ${paths.length} file(s)`,
+            isError: false,
+            linesAdded: plan.linesAdded,
+            linesRemoved: plan.linesRemoved,
+            accessedPaths: paths,
+        };
+    }
     async edit(call, preparedTargetExisted) {
         const filePath = stringInput(call.input, 'file_path');
         this.assertProtectedWritePath(filePath);

package/dist/tools/team-member-tools.js

@@ -5,8 +5,9 @@ import { analyzeBashStructure, normalizeBashWrapperArgv, } from '../permissions/
 import { validateBashPathSafety } from '../permissions/bash-path-safety.js';
 import { shellInputIsReadOnly } from '../permissions/permission-updates.js';
 import { isPathWithin } from '../platform/path-containment.js';
+import { parseApplyPatchInput } from './apply-patch.js';
 const READ_ONLY_TOOLS = new Set(['Read', 'Glob', 'Grep', 'Bash']);
-const WRITE_TOOLS = new Set([...READ_ONLY_TOOLS, 'Write', 'Edit']);
+const WRITE_TOOLS = new Set([...READ_ONLY_TOOLS, 'Write', 'Edit', 'ApplyPatch']);
 const SAFE_GIT_COMMANDS = new Set([
     'status',
     'diff',
@@ -88,6 +89,9 @@ function within(root, candidate) {
 function toolInputPaths(call) {
     if (call.name === 'Read' || call.name === 'Write' || call.name === 'Edit')
         return [call.input.file_path];
+    if (call.name === 'ApplyPatch') {
+        return parseApplyPatchInput(call.input).map((edit) => edit.file_path);
+    }
     if (call.name === 'Glob' || call.name === 'Grep')
         return call.input.path === undefined ? [] : [call.input.path];
     return [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.55.2",
+  "version": "0.56.0",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",
@@ -62,7 +62,7 @@
     "verify:ci-coverage": "node scripts/verify-ci-coverage.mjs",
     "verify:fixture-contracts": "node scripts/verify-fixture-contracts.mjs",
     "test:fixtures": "node scripts/run-fixture-contracts.mjs",
-    "test:eval:baseline": "vitest run src/evals/coding-baseline.test.ts src/evals/project-eval-comparison.test.ts"
+    "test:eval:baseline": "vitest run src/evals/coding-baseline.test.ts src/evals/project-eval-comparison.test.ts src/evals/apply-patch-admission.test.ts"
   },
   "engines": {
     "node": ">=24"