praxis-agent 0.55.3 → 0.57.0

package/dist/tools/apply-patch.js

@@ -0,0 +1,128 @@
+import { countLineChanges } from './line-changes.js';
+export const APPLY_PATCH_MAX_EDITS = 32;
+export const APPLY_PATCH_MAX_FILES = 8;
+export const APPLY_PATCH_MAX_INPUT_BYTES = 256 * 1024;
+export const APPLY_PATCH_DEFINITION = {
+    name: 'ApplyPatch',
+    description: 'Applies a bounded batch of exact, unique string replacements to existing files.',
+    inputSchema: {
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        type: 'object',
+        properties: {
+            edits: {
+                type: 'array',
+                minItems: 1,
+                maxItems: APPLY_PATCH_MAX_EDITS,
+                items: {
+                    type: 'object',
+                    properties: {
+                        file_path: { type: 'string', minLength: 1 },
+                        old_string: { type: 'string', minLength: 1 },
+                        new_string: { type: 'string' },
+                    },
+                    required: ['file_path', 'old_string', 'new_string'],
+                    additionalProperties: false,
+                },
+            },
+        },
+        required: ['edits'],
+        additionalProperties: false,
+    },
+};
+function objectInput(input, label) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        throw new Error(`${label} must be an object`);
+    return input;
+}
+function exactKeys(input, keys) {
+    const unexpected = Object.keys(input).find((key) => !keys.includes(key));
+    if (unexpected)
+        throw new Error(`Unexpected ApplyPatch field: ${unexpected}`);
+}
+function stringInput(input, key, nonEmpty = false) {
+    const value = input[key];
+    if (typeof value !== 'string' || (nonEmpty && value.length === 0))
+        throw new Error(`${key} must be ${nonEmpty ? 'a non-empty ' : 'a '}string`);
+    return value;
+}
+export function parseApplyPatchInput(input) {
+    let encoded;
+    try {
+        encoded = JSON.stringify(input);
+    }
+    catch {
+        throw new Error('ApplyPatch input must be JSON-serializable');
+    }
+    if (encoded === undefined)
+        throw new Error('ApplyPatch input must be JSON-serializable');
+    if (Buffer.byteLength(encoded, 'utf8') > APPLY_PATCH_MAX_INPUT_BYTES)
+        throw new Error('ApplyPatch input exceeds 256 KiB');
+    const object = objectInput(input, 'ApplyPatch input');
+    exactKeys(object, ['edits']);
+    const rawEdits = object.edits;
+    if (!Array.isArray(rawEdits) ||
+        rawEdits.length < 1 ||
+        rawEdits.length > APPLY_PATCH_MAX_EDITS)
+        throw new Error('ApplyPatch edits must contain 1 to 32 operations');
+    return rawEdits.map((raw, index) => {
+        const item = objectInput(raw, `ApplyPatch edits[${index}]`);
+        exactKeys(item, ['file_path', 'old_string', 'new_string']);
+        const edit = {
+            file_path: stringInput(item, 'file_path', true),
+            old_string: stringInput(item, 'old_string', true),
+            new_string: stringInput(item, 'new_string'),
+        };
+        if (edit.old_string === edit.new_string)
+            throw new Error('new_string must differ from old_string');
+        return edit;
+    });
+}
+export function planApplyPatch(edits, sources, maxFileBytes) {
+    if (edits.length < 1 || edits.length > APPLY_PATCH_MAX_EDITS)
+        throw new Error('ApplyPatch edits must contain 1 to 32 operations');
+    if (new Set(edits.map((edit) => edit.file_path)).size > APPLY_PATCH_MAX_FILES)
+        throw new Error('ApplyPatch may touch at most 8 files');
+    const snapshots = new Map();
+    for (const edit of edits) {
+        if (!edit.old_string)
+            throw new Error('old_string must be non-empty');
+        if (edit.old_string === edit.new_string)
+            throw new Error('new_string must differ from old_string');
+        if (!snapshots.has(edit.file_path)) {
+            const source = sources.get(edit.file_path);
+            if (source === undefined)
+                throw new Error(`ApplyPatch source is missing: ${edit.file_path}`);
+            snapshots.set(edit.file_path, source);
+        }
+    }
+    for (const edit of edits) {
+        const source = snapshots.get(edit.file_path);
+        if (source === undefined)
+            throw new Error(`ApplyPatch source is missing: ${edit.file_path}`);
+        const first = source.indexOf(edit.old_string);
+        if (first < 0)
+            throw new Error('old_string was not found');
+        const second = source.indexOf(edit.old_string, first + edit.old_string.length);
+        if (second >= 0)
+            throw new Error('old_string must match exactly once');
+        const after = source.slice(0, first) +
+            edit.new_string +
+            source.slice(first + edit.old_string.length);
+        if (Buffer.byteLength(after, 'utf8') > maxFileBytes)
+            throw new Error(`Edited content exceeds ${maxFileBytes} bytes`);
+        snapshots.set(edit.file_path, after);
+    }
+    const files = [...snapshots].map(([filePath, after]) => {
+        const before = sources.get(filePath);
+        if (before === undefined)
+            throw new Error(`ApplyPatch source is missing: ${filePath}`);
+        const changes = countLineChanges(before, after);
+        return { filePath, before, after, ...changes };
+    });
+    return {
+        files,
+        linesAdded: files.reduce((total, file) => total + file.linesAdded, 0),
+        linesRemoved: files.reduce((total, file) => total + file.linesRemoved, 0),
+    };
+}
+//# sourceMappingURL=apply-patch.js.map

package/dist/tools/claude-interactive-tools.js

@@ -1,6 +1,7 @@
 import { mkdir, readFile, realpath } from 'node:fs/promises';
 import { basename, dirname, join, resolve } from 'node:path';
 import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
+import { parseApplyPatchInput } from './apply-patch.js';
 const ASK_USER_QUESTION = {
     name: 'AskUserQuestion',
     description: "Use this tool only when you are blocked on a decision that is genuinely the user's to make: one you cannot resolve from the request, the code, or sensible defaults. Users can always provide custom text. Use multiSelect for non-exclusive choices. In plan mode, use this tool to clarify requirements before ExitPlanMode; do not use it to request plan approval.",
@@ -354,6 +355,13 @@ Use AskUserQuestion for decisions that genuinely require the user. Write a compl
             typeof call.input.file_path === 'string') {
             return this.resolvePlanFile(state, call, context);
         }
+        if (state.mode === 'plan' && call.name === 'ApplyPatch') {
+            const edits = parseApplyPatchInput(call.input);
+            if ((await Promise.all(edits.map((edit) => this.isPlanFileForState(state, edit.file_path)))).every(Boolean)) {
+                return { behavior: 'allow' };
+            }
+            return this.resolver(state.mode).resolve(call, context);
+        }
         const decision = await this.resolver(this.planPermissionMode(sessionId)).resolve(call, context);
         return this.applyRetainedPrompts(state, call, decision);
     }

package/dist/tools/claude-lsp-tool.d.ts

@@ -12,11 +12,14 @@ export declare class ClaudeLspToolManager {
         environment?: Readonly<Record<string, string | undefined>>;
     });
     registry(base: ToolRegistry): ToolRegistry;
+    private discardConnectionsOutside;
+    private runtimeCwd;
     private validatedFile;
     private candidates;
     private languageId;
     private connection;
     execute(call: ModelToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
+    enrichMutationResult(call: ModelToolCall, context: ToolExecutionContext, result: ToolExecutionResult): Promise<ToolExecutionResult>;
     close(): Promise<void>;
 }
 //# sourceMappingURL=claude-lsp-tool.d.ts.map

package/dist/tools/claude-lsp-tool.js

@@ -1,16 +1,18 @@
 import { execFile, spawn, } from 'node:child_process';
 import { readFile, realpath, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { extname, resolve, sep } from 'node:path';
+import { extname, isAbsolute, relative, resolve, sep } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { promisify } from 'node:util';
 import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
 import { redactSensitiveText, sanitizeChildEnvironment, sensitiveEnvironmentValues, } from '../platform/sensitive-data.js';
 import { formatClaudeLspResult } from './claude-lsp-formatters.js';
+import { formatDiagnostics, parsePublishDiagnostics, } from './lsp-diagnostics.js';
 const MAX_MESSAGE_BYTES = 8 * 1024 * 1024;
 const MAX_RESULT_CHARS = 512 * 1024;
 const MAX_FILE_BYTES = 10_000_000;
 const REQUEST_TIMEOUT_MS = 15_000;
+const DIAGNOSTICS_TIMEOUT_MS = 1_000;
 const execFileAsync = promisify(execFile);
 const NO_CALL_HIERARCHY = Symbol('no-call-hierarchy');
 function lspSensitiveValues(definition) {
@@ -224,6 +226,9 @@ class LspConnection {
     buffer = Buffer.alloc(0);
     pending = new Map();
     documents = new Map();
+    diagnosticSnapshots = new Map();
+    diagnosticWaiters = new Set();
+    diagnosticGeneration = 0;
     stderr = '';
     exited = false;
     initialized = false;
@@ -253,6 +258,20 @@ class LspConnection {
             this.cleanupPending(id, pending);
             pending.reject(error);
         }
+        for (const waiter of [...this.diagnosticWaiters])
+            this.settleDiagnosticWaiter(waiter, undefined, error);
+        this.diagnosticSnapshots.clear();
+    }
+    settleDiagnosticWaiter(waiter, diagnostics, error) {
+        if (!this.diagnosticWaiters.delete(waiter))
+            return;
+        clearTimeout(waiter.timer);
+        if (waiter.signal && waiter.abort)
+            waiter.signal.removeEventListener('abort', waiter.abort);
+        if (error)
+            waiter.reject(error);
+        else
+            waiter.resolve(diagnostics ?? []);
     }
     cleanupPending(id, pending) {
         clearTimeout(pending.timer);
@@ -306,6 +325,29 @@ class LspConnection {
         if (!message || typeof message !== 'object' || Array.isArray(message))
             return;
         const value = message;
+        const publication = parsePublishDiagnostics(message);
+        if (publication) {
+            const document = [...this.documents.values()].find((candidate) => candidate.uri === publication.uri);
+            if (!document)
+                return;
+            if (publication.version !== undefined &&
+                publication.version !== document.version)
+                return;
+            const generation = ++this.diagnosticGeneration;
+            this.diagnosticSnapshots.set(publication.uri, {
+                generation,
+                diagnostics: publication.diagnostics,
+            });
+            const snapshot = this.diagnosticSnapshots.get(publication.uri);
+            for (const waiter of [...this.diagnosticWaiters]) {
+                if (waiter.uri !== publication.uri ||
+                    !snapshot ||
+                    snapshot.generation <= waiter.afterGeneration)
+                    continue;
+                this.settleDiagnosticWaiter(waiter, snapshot.diagnostics);
+            }
+            return;
+        }
         if (value.id !== undefined && typeof value.method === 'string') {
             const result = value.method === 'workspace/configuration' &&
                 value.params &&
@@ -444,7 +486,7 @@ class LspConnection {
                     publishDiagnostics: {
                         relatedInformation: true,
                         tagSupport: { valueSet: [1, 2] },
-                        versionSupport: false,
+                        versionSupport: true,
                         codeDescriptionSupport: true,
                         dataSupport: false,
                     },
@@ -472,25 +514,82 @@ class LspConnection {
         }
         this.initialized = true;
     }
-    async openDocument(filePath, languageId) {
-        const text = await readFile(filePath, 'utf8');
+    synchronizeDocument(filePath, languageId, text) {
         const current = this.documents.get(filePath);
         const uri = pathToFileURL(filePath).href;
+        if (current?.text === text)
+            return false;
         if (!current) {
-            this.documents.set(filePath, { text, version: 1 });
+            this.documents.set(filePath, { text, version: 1, uri });
             this.notify('textDocument/didOpen', {
                 textDocument: { uri, languageId, version: 1, text },
             });
-            return;
         }
-        if (current.text === text)
-            return;
-        const version = current.version + 1;
-        this.documents.set(filePath, { text, version });
-        this.notify('textDocument/didChange', {
-            textDocument: { uri, version },
-            contentChanges: [{ text }],
+        else {
+            const version = current.version + 1;
+            this.documents.set(filePath, { text, version, uri });
+            this.notify('textDocument/didChange', {
+                textDocument: { uri, version },
+                contentChanges: [{ text }],
+            });
+        }
+        return true;
+    }
+    async openDocument(filePath, languageId) {
+        const text = await readFile(filePath, 'utf8');
+        this.synchronizeDocument(filePath, languageId, text);
+    }
+    async refreshDiagnostics(filePath, languageId, signal) {
+        if (signal?.aborted)
+            return [];
+        const text = await readFile(filePath, 'utf8');
+        if (signal?.aborted)
+            return [];
+        const uri = pathToFileURL(filePath).href;
+        const current = this.documents.get(filePath);
+        if (current && current.text === text)
+            return [];
+        const afterGeneration = this.diagnosticSnapshots.get(uri)?.generation ?? 0;
+        let waiter;
+        const result = new Promise((resolveResult, rejectResult) => {
+            const entry = {
+                uri,
+                afterGeneration,
+                resolve: resolveResult,
+                reject: rejectResult,
+                timer: setTimeout(() => {
+                    this.settleDiagnosticWaiter(entry);
+                }, 1_000),
+                ...(signal ? { signal } : {}),
+            };
+            waiter = entry;
+            if (signal) {
+                entry.abort = () => {
+                    this.settleDiagnosticWaiter(entry, undefined, new Error('LSP diagnostics refresh cancelled'));
+                };
+                if (signal.aborted) {
+                    clearTimeout(entry.timer);
+                    resolveResult([]);
+                    return;
+                }
+                signal.addEventListener('abort', entry.abort, { once: true });
+            }
+            this.diagnosticWaiters.add(entry);
         });
+        if (signal?.aborted)
+            return result;
+        try {
+            this.synchronizeDocument(filePath, languageId, text);
+        }
+        catch (error) {
+            if (waiter) {
+                // The method throws the send failure directly. Resolve the detached
+                // waiter while cleaning it so it cannot become an unhandled rejection.
+                this.settleDiagnosticWaiter(waiter);
+            }
+            throw error;
+        }
+        return result.catch(() => []);
     }
     async execute(input, filePath, signal) {
         const uri = pathToFileURL(filePath).href;
@@ -527,6 +626,7 @@ class LspConnection {
     async close() {
         if (this.exited)
             return;
+        this.fail(new Error(`LSP server ${this.definition.name} is closing`));
         const exited = new Promise((resolveExit) => {
             this.child.once('close', () => resolveExit());
         });
@@ -567,6 +667,33 @@ export class ClaudeLspToolManager {
     registry(base) {
         return new ClaudeLspToolRegistry(base, this);
     }
+    async discardConnectionsOutside(runtimeCwd) {
+        const prefix = runtimeCwd === undefined ? undefined : `${runtimeCwd}\0`;
+        const staleKeys = new Set([
+            ...this.connections.keys(),
+            ...this.initializing.keys(),
+            ...this.restartCounts.keys(),
+        ].filter((key) => prefix === undefined || !key.startsWith(prefix)));
+        const staleConnections = [];
+        for (const key of staleKeys) {
+            const connection = this.connections.get(key);
+            if (connection)
+                staleConnections.push(connection);
+            this.connections.delete(key);
+            this.initializing.delete(key);
+            this.restartCounts.delete(key);
+        }
+        await Promise.allSettled(staleConnections.map((connection) => connection.close()));
+    }
+    async runtimeCwd() {
+        try {
+            return await realpath(this.options.cwdProvider());
+        }
+        catch (error) {
+            await this.discardConnectionsOutside();
+            throw error;
+        }
+    }
     async validatedFile(inputPath) {
         const cwd = this.options.cwdProvider();
         const expanded = inputPath === '~'
@@ -601,16 +728,23 @@ export class ClaudeLspToolManager {
         const extension = extname(filePath).toLowerCase();
         return (Object.entries(definition.extensionToLanguage).find(([candidate]) => candidate.toLowerCase() === extension)?.[1] ?? '');
     }
-    async connection(definition, signal) {
-        const runtimeCwd = await realpath(this.options.cwdProvider());
+    async connection(definition, signal, expectedCwd) {
+        const runtimeCwd = await this.runtimeCwd();
+        if (expectedCwd !== undefined && runtimeCwd !== expectedCwd) {
+            await this.discardConnectionsOutside(runtimeCwd);
+            throw new Error('LSP diagnostics cwd changed during collection');
+        }
+        if (signal?.aborted)
+            throw new Error('LSP connection cancelled');
         const serverCwd = await realpath(definition.workspaceFolder ?? runtimeCwd);
         const key = `${runtimeCwd}\0${definition.pluginName}\0${definition.name}`;
-        const stale = [...this.connections.entries()].filter(([candidate]) => !candidate.startsWith(`${runtimeCwd}\0`));
-        for (const [candidate, connection] of stale) {
-            this.connections.delete(candidate);
-            this.initializing.delete(candidate);
-            this.restartCounts.delete(candidate);
-            await connection.close();
+        await this.discardConnectionsOutside(runtimeCwd);
+        if (signal?.aborted)
+            throw new Error('LSP connection cancelled');
+        const confirmedCwd = await this.runtimeCwd();
+        if (expectedCwd !== undefined && confirmedCwd !== expectedCwd) {
+            await this.discardConnectionsOutside(confirmedCwd);
+            throw new Error('LSP diagnostics cwd changed during collection');
         }
         const initializing = this.initializing.get(key);
         if (initializing)
@@ -657,7 +791,7 @@ export class ClaudeLspToolManager {
     async execute(call, context) {
         try {
             const input = inputFrom(call.input);
-            const cwd = await realpath(this.options.cwdProvider());
+            const cwd = await this.runtimeCwd();
             const { filePath, canonicalPath, size } = await this.validatedFile(input.filePath);
             if (size > MAX_FILE_BYTES) {
                 return {
@@ -710,6 +844,96 @@ export class ClaudeLspToolManager {
             };
         }
     }
+    async enrichMutationResult(call, context, result) {
+        if (result.isError || (call.name !== 'Edit' && call.name !== 'ApplyPatch'))
+            return result;
+        if (context.signal?.aborted)
+            return result;
+        const deadline = new AbortController();
+        let resolveInterrupted;
+        const interrupted = new Promise((resolveResult) => {
+            resolveInterrupted = resolveResult;
+        });
+        const abort = () => {
+            deadline.abort();
+            resolveInterrupted?.(result);
+        };
+        context.signal?.addEventListener('abort', abort, { once: true });
+        const timer = setTimeout(() => abort(), DIAGNOSTICS_TIMEOUT_MS);
+        const attempt = (async () => {
+            const cwd = await this.runtimeCwd();
+            await this.discardConnectionsOutside(cwd);
+            const sameCwd = async () => {
+                try {
+                    const runtimeCwd = await this.runtimeCwd();
+                    if (runtimeCwd === cwd)
+                        return true;
+                    await this.discardConnectionsOutside(runtimeCwd);
+                }
+                catch {
+                    // runtimeCwd() already discarded connection-local state.
+                }
+                return false;
+            };
+            if (deadline.signal.aborted || !(await sameCwd()))
+                return result;
+            const requested = call.name === 'Edit'
+                ? [call.input.file_path]
+                : Array.isArray(call.input.edits)
+                    ? call.input.edits.map((edit) => edit?.file_path)
+                    : [];
+            const targets = new Set();
+            for (const value of requested) {
+                if (typeof value !== 'string' || deadline.signal.aborted)
+                    continue;
+                try {
+                    const canonical = await realpath(resolve(cwd, value));
+                    if (deadline.signal.aborted || !(await sameCwd()))
+                        continue;
+                    const relativePath = relative(cwd, canonical);
+                    if (relativePath === '..' ||
+                        relativePath.startsWith(`..${sep}`) ||
+                        isAbsolute(relativePath) ||
+                        !(await stat(canonical)).isFile())
+                        continue;
+                    targets.add(canonical);
+                }
+                catch {
+                    // Successful mutations must remain successful when enrichment cannot inspect a target.
+                }
+            }
+            const records = [];
+            await Promise.all([...targets].flatMap((filePath) => this.candidates(filePath).map(async (definition) => {
+                if (deadline.signal.aborted)
+                    return;
+                try {
+                    const connection = await this.connection(definition, deadline.signal, cwd);
+                    if (deadline.signal.aborted || !(await sameCwd()))
+                        return;
+                    const current = await connection.refreshDiagnostics(filePath, this.languageId(definition, filePath), deadline.signal);
+                    if (deadline.signal.aborted || !(await sameCwd()))
+                        return;
+                    records.push(...current);
+                }
+                catch {
+                    // Diagnostics are best effort and never change mutation semantics.
+                }
+            })));
+            if (records.length === 0 || deadline.signal.aborted || !(await sameCwd()))
+                return result;
+            const block = formatDiagnostics(records, cwd, this.options.servers.flatMap((definition) => lspSensitiveValues(definition)));
+            return block
+                ? { ...result, content: `${result.content}\n${block}` }
+                : result;
+        })().catch(() => result);
+        try {
+            return await Promise.race([attempt, interrupted]);
+        }
+        finally {
+            clearTimeout(timer);
+            context.signal?.removeEventListener('abort', abort);
+        }
+    }
     async close() {
         const connections = [...this.connections.values()];
         this.connections.clear();
@@ -742,10 +966,11 @@ class ClaudeLspToolRegistry {
             ? Promise.resolve(call)
             : this.base.prepare(call, context);
     }
-    execute(call, context) {
-        return call.name === 'LSP'
-            ? this.manager.execute(call, context)
-            : this.base.execute(call, context);
+    async execute(call, context) {
+        if (call.name === 'LSP')
+            return this.manager.execute(call, context);
+        const result = await this.base.execute(call, context);
+        return this.manager.enrichMutationResult(call, context, result);
     }
 }
 //# sourceMappingURL=claude-lsp-tool.js.map

package/dist/tools/local-tools.d.ts

@@ -92,6 +92,7 @@ export declare class LocalToolRegistry implements ToolRegistry {
     private readPdf;
     private createPdfOutputDirectory;
     private write;
+    private applyPatch;
     private edit;
     private notebookEdit;
     private glob;