dsh-patch-edit-plus 0.1.0

package/lib/apply/engine.js

@@ -0,0 +1,160 @@
+/**
+ * Two-phase atomic application engine.
+ *
+ * Phase 1 (verify) reads every target and computes the full in-memory result;
+ * ANY failure aborts the whole patch with zero bytes written. Phase 2 (apply)
+ * only writes what verify already validated.
+ * @module dsh-patch-edit-plus/apply/engine
+ */
+import { PatchError, addExistsError, mismatchMessage, missingFileError } from '../errors.js';
+import { readFile, statFile, writeFile } from '../fsops.js';
+import { moveFile, removeFile, assertShellReady } from '../shellops.js';
+import { consumedLines, findSequence } from './seek.js';
+import { needsShell } from './plan.js';
+/**
+ * Verify the whole patch: read every file, locate every hunk, compute every
+ * result. Throws on the first failure — nothing has been written.
+ */
+export async function verifyPatch(ctx, exec, plan, cfg) {
+    if (plan.entries.some(entry => needsShell(entry.op))) {
+        assertShellReady(ctx, cfg);
+    }
+    const changes = [];
+    for (const entry of plan.entries) {
+        const { op } = entry;
+        if (op.kind === 'add') {
+            const existing = await statFile(ctx, exec, entry.target);
+            if (existing !== undefined)
+                throw addExistsError(op.path);
+            changes.push({ entry, before: null, after: joinContent(op.lines, op.trailingNewline, false) });
+            continue;
+        }
+        if (op.kind === 'delete') {
+            const existing = await statFile(ctx, exec, entry.target);
+            if (existing === undefined)
+                throw missingFileError(op.path, 'delete');
+            const before = await readFile(ctx, exec, entry.target);
+            changes.push({ entry, before, after: null });
+            continue;
+        }
+        // update
+        const before = await readFile(ctx, exec, entry.target);
+        const after = op.hunks.length === 0 ? before : applyHunksToContent(op.path, before, op.hunks);
+        changes.push({ entry, before, after });
+    }
+    return changes;
+}
+/** Apply phase: writes only — verify already settled every decision. */
+export async function applyPatch(ctx, exec, changes, cfg, sandboxPolicy) {
+    for (const change of changes) {
+        const { op } = change.entry;
+        if (op.kind === 'delete') {
+            await removeFile(ctx, exec, cfg, change.entry.target, sandboxPolicy);
+            continue;
+        }
+        if (op.kind === 'add') {
+            await writeFile(ctx, exec, change.entry.target, change.after ?? '', sandboxPolicy);
+            continue;
+        }
+        if (change.after !== null && change.after !== change.before) {
+            await writeFile(ctx, exec, change.entry.target, change.after, sandboxPolicy);
+        }
+        if (change.entry.moveToTarget !== undefined && op.kind === 'update') {
+            await moveFile(ctx, exec, cfg, change.entry.target, change.entry.moveToTarget, sandboxPolicy);
+        }
+    }
+}
+/** Pure-move entries (update with moveTo and no hunks) skip the write. */
+export function isPureMove(change) {
+    return change.entry.op.kind === 'update'
+        && change.entry.op.hunks.length === 0
+        && change.entry.moveToTarget !== undefined;
+}
+function joinContent(lines, trailingNewline, crlf) {
+    const text = lines.join('\n') + (trailingNewline && lines.length > 0 ? '\n' : '');
+    return crlf ? text.replaceAll('\n', '\r\n') : text;
+}
+/**
+ * Apply hunks to raw file content with newline fidelity: CRLF files are
+ * normalized for matching and written back in their original style; the
+ * trailing-newline state of the file tail is preserved exactly.
+ */
+export function applyHunksToContent(path, before, hunks) {
+    const crlf = before.includes('\r\n');
+    const beforeEndsWithNewline = before.endsWith('\n');
+    const workLines = splitLines(before);
+    const output = [];
+    let cursor = 0;
+    let lastMatchEnd = -1;
+    for (let h = 0; h < hunks.length; h += 1) {
+        const hunk = hunks[h];
+        const match = locate(workLines, hunk, cursor, path, h + 1);
+        output.push(...workLines.slice(cursor, match));
+        let pos = match;
+        for (const line of hunk.lines) {
+            if (line.kind === 'context') {
+                output.push(workLines[pos] ?? '');
+                pos += 1;
+            }
+            else if (line.kind === 'delete') {
+                pos += 1;
+            }
+            else {
+                output.push(line.text);
+            }
+        }
+        cursor = pos;
+        lastMatchEnd = pos;
+    }
+    output.push(...workLines.slice(cursor));
+    const reachesEnd = lastMatchEnd === workLines.length;
+    const afterEndsWithNewline = resolveTrailingNewline(hunks.at(-1), reachesEnd, beforeEndsWithNewline);
+    return joinContent(output, afterEndsWithNewline, crlf);
+}
+/** Split raw content into LF lines, dropping the trailing-newline artifact. */
+function splitLines(content) {
+    const withoutTrailing = content.endsWith('\n') ? content.slice(0, -1) : content;
+    if (withoutTrailing === '')
+        return [];
+    return withoutTrailing.split('\n').map(line => line.endsWith('\r') ? line.slice(0, -1) : line);
+}
+function resolveTrailingNewline(lastHunk, reachesEnd, beforeEndsWithNewline) {
+    if (lastHunk === undefined || !reachesEnd)
+        return beforeEndsWithNewline;
+    const tail = newSideTail(lastHunk);
+    if (tail === 'context')
+        return beforeEndsWithNewline;
+    // Tail is an inserted line: newline-terminated unless the patch explicitly
+    // marked the new side as lacking the final newline.
+    return lastHunk.newNoNewline !== true;
+}
+function newSideTail(hunk) {
+    for (let i = hunk.lines.length - 1; i >= 0; i -= 1) {
+        const kind = hunk.lines[i].kind;
+        if (kind === 'context' || kind === 'add')
+            return kind;
+    }
+    return 'context';
+}
+/** Locate one hunk with the header-line hint, falling back to the plain cursor. */
+function locate(fileLines, hunk, cursor, path, hunkIndex) {
+    const options = { endOfFile: hunk.endOfFile };
+    if (hunk.oldStart !== undefined && hunk.oldStart > 0) {
+        const hinted = Math.max(cursor, hunk.oldStart - 1);
+        const atHint = findSequence(fileLines, hunk.lines, hinted, options);
+        if (atHint !== null)
+            return atHint;
+    }
+    const found = findSequence(fileLines, hunk.lines, cursor, options);
+    if (found !== null)
+        return found;
+    throw new PatchError('VALIDATION', mismatchMessage({
+        path,
+        hunkIndex,
+        searchFromLine: cursor + 1,
+        expected: hunk.lines.filter((line) => line.kind !== 'add').map(line => line.text),
+        actual: fileLines.slice(cursor, cursor + 10),
+        endOfFile: hunk.endOfFile,
+    }));
+}
+export { consumedLines };

package/lib/apply/plan.js

@@ -0,0 +1,79 @@
+/**
+ * Operation planning: path resolution, workspace containment, symlink policy
+ * and duplicate detection. Pure resolution work — no file content is read
+ * here (the engine's verify stage does that).
+ * @module dsh-patch-edit-plus/apply/plan
+ */
+import { duplicatePathError, limitError, missingParentError, pathEscapeError, symlinkRejectedError, } from '../errors.js';
+/**
+ * Plan a parsed patch against the filesystem backend.
+ * @throws {@link PatchError} on limits, path escapes, symlinks, missing parents or duplicate targets.
+ */
+export async function buildPlan(ctx, exec, parsed, cfg) {
+    if (parsed.ops.length > cfg.maxFiles)
+        throw limitError('file section count', parsed.ops.length, cfg.maxFiles);
+    const fs = ctx.fs;
+    const cwd = exec.agent?.session.header.cwd;
+    const resolveOpts = { cwd, signal: exec.signal };
+    // Containment root: the session workspace, when the call carries one.
+    const rootTarget = cwd === undefined ? undefined : await fs.resolve(cwd, resolveOpts);
+    const seen = new Map();
+    const entries = [];
+    for (const op of parsed.ops) {
+        const target = await resolveChecked(fs, op.path, resolveOpts, rootTarget, cfg, seen);
+        let moveToTarget;
+        const moveTo = op.kind === 'update' ? op.moveTo : undefined;
+        if (moveTo !== undefined)
+            moveToTarget = await resolveChecked(fs, moveTo, resolveOpts, rootTarget, cfg, seen);
+        if (op.kind === 'add')
+            await checkParent(fs, op.path, resolveOpts);
+        entries.push({ op, target, moveToTarget });
+    }
+    return { format: parsed.format, entries };
+}
+/** Resolve one path with containment + symlink policy and duplicate tracking. */
+async function resolveChecked(fs, path, resolveOpts, rootTarget, cfg, seen) {
+    const target = await fs.resolve(path, resolveOpts);
+    if (rootTarget !== undefined && !fs.contains(rootTarget, target))
+        throw pathEscapeError(path);
+    if (!cfg.followSymlinks)
+        await rejectSymlinks(fs, path, resolveOpts);
+    const previous = seen.get(target.targetKey);
+    if (previous !== undefined)
+        throw duplicatePathError(path);
+    seen.set(target.targetKey, path);
+    return target;
+}
+/** Reject when any path component (or the leaf) is a symbolic link. */
+async function rejectSymlinks(fs, path, resolveOpts) {
+    const segments = splitPath(path);
+    let prefix = '';
+    for (const segment of segments) {
+        prefix = prefix === '' ? segment : `${prefix}/${segment}`;
+        const info = await fs.lstat(prefix, { cwd: resolveOpts.cwd }, resolveOpts.signal);
+        if (info !== undefined && info.type === 'symlink')
+            throw symlinkRejectedError(path, prefix);
+    }
+}
+function splitPath(path) {
+    const normalized = path.replaceAll('\\', '/');
+    const segments = normalized.split('/').filter(segment => segment !== '' && segment !== '.');
+    // Trailing slash or root-relative paths have no meaningful segment chain.
+    return segments.length === 0 ? [] : segments;
+}
+/** The Add parent directory must exist (the native write tool does not mkdir either). */
+async function checkParent(fs, path, resolveOpts) {
+    const segments = splitPath(path);
+    if (segments.length <= 1)
+        return; // parent is the workspace root itself
+    const parent = segments.slice(0, -1).join('/');
+    const info = await fs.lstat(parent, { cwd: resolveOpts.cwd }, resolveOpts.signal);
+    if (info === undefined)
+        throw missingParentError(path, parent);
+    if (info.type !== 'directory')
+        throw missingParentError(path, parent);
+}
+/** True when the operation needs the shell backend (delete or move). */
+export function needsShell(op) {
+    return op.kind === 'delete' || (op.kind === 'update' && op.moveTo !== undefined);
+}

package/lib/apply/seek.js

@@ -0,0 +1,47 @@
+/**
+ * Context-line location with three tolerance levels.
+ *
+ * Levels, tried in order over the whole search window (exact matches always
+ * win over trimmed ones): exact equality → `trimEnd` → full `trim`. Only the
+ * context/remove lines participate; add lines are insertions and never
+ * constrain the position.
+ * @module dsh-patch-edit-plus/apply/seek
+ */
+/** Locate `expected` inside `fileLines` starting at `from`. Returns the match index or `null`. */
+export function findSequence(fileLines, expected, from, opts = {}) {
+    const sequence = expected.filter(line => line.kind !== 'add').map(line => line.text);
+    if (sequence.length === 0)
+        return from <= fileLines.length ? from : null;
+    const lastStart = fileLines.length - sequence.length;
+    if (lastStart < 0)
+        return null;
+    const start = opts.endOfFile === true ? Math.max(from, lastStart) : from;
+    if (start > lastStart)
+        return null;
+    const comparators = [
+        (a, b) => a === b,
+        (a, b) => a.trimEnd() === b.trimEnd(),
+        (a, b) => a.trim() === b.trim(),
+    ];
+    for (const equal of comparators) {
+        for (let i = start; i <= lastStart; i += 1) {
+            if (matchesAt(fileLines, sequence, i, equal))
+                return i;
+        }
+    }
+    return null;
+}
+function matchesAt(fileLines, sequence, at, equal) {
+    for (let j = 0; j < sequence.length; j += 1) {
+        if (!equal(fileLines[at + j], sequence[j]))
+            return false;
+    }
+    return true;
+}
+/**
+ * Number of old-side lines a hunk consumes at its match position
+ * (context + delete lines).
+ */
+export function consumedLines(hunk) {
+    return hunk.lines.filter(line => line.kind !== 'add').length;
+}

package/lib/config.js

@@ -0,0 +1,45 @@
+/**
+ * Plugin configuration: Schemastery schema + resolved defaults.
+ *
+ * Every knob the tool honors lives here; the tool body only ever reads the
+ * fully-resolved `ResolvedConfig` produced by `resolveConfig`.
+ * @module dsh-patch-edit-plus/config
+ */
+import z from '@deepseek-ai/schemastery';
+/** Schemastery schema for Loader defaults and generated configuration docs. */
+export const Config = z.object({
+    toolName: z.string().default('apply_patch'),
+    conflictPolicy: z.union(['rename', 'skip', 'fail']).default('rename'),
+    renameSuffix: z.string().default('_1'),
+    allowUnifiedDiff: z.boolean().default(true),
+    allowCodexPatch: z.boolean().default(false),
+    deleteBackend: z.union(['shell', 'none']).default('shell'),
+    shellDialect: z.union(['auto', 'posix', 'pwsh']).default('auto'),
+    deleteCommand: z.string(),
+    moveCommand: z.string(),
+    dryRunByDefault: z.boolean().default(false),
+    followSymlinks: z.boolean().default(false),
+    maxFiles: z.number().step(1).min(1).max(500).default(50),
+    maxPatchBytes: z.number().step(1).min(1024).default(512 * 1024),
+    maxDiffBytes: z.number().step(1).min(256).default(16 * 1024),
+});
+/** Fill user config with defaults; `undefined`/null entries fall back too. */
+export function resolveConfig(config) {
+    const c = config ?? {};
+    return {
+        toolName: typeof c.toolName === 'string' && c.toolName.trim() !== '' ? c.toolName : 'apply_patch',
+        conflictPolicy: c.conflictPolicy ?? 'rename',
+        renameSuffix: typeof c.renameSuffix === 'string' ? c.renameSuffix : '_1',
+        allowUnifiedDiff: c.allowUnifiedDiff ?? true,
+        allowCodexPatch: c.allowCodexPatch ?? false,
+        deleteBackend: c.deleteBackend ?? 'shell',
+        shellDialect: c.shellDialect ?? 'auto',
+        deleteCommand: typeof c.deleteCommand === 'string' && c.deleteCommand !== '' ? c.deleteCommand : undefined,
+        moveCommand: typeof c.moveCommand === 'string' && c.moveCommand !== '' ? c.moveCommand : undefined,
+        dryRunByDefault: c.dryRunByDefault ?? false,
+        followSymlinks: c.followSymlinks ?? false,
+        maxFiles: c.maxFiles ?? 50,
+        maxPatchBytes: c.maxPatchBytes ?? 512 * 1024,
+        maxDiffBytes: c.maxDiffBytes ?? 16 * 1024,
+    };
+}

package/lib/detect.js

@@ -0,0 +1,29 @@
+/**
+ * Patch format detection.
+ *
+ * Runs BEFORE any parser so a recognized-but-disabled style can produce an
+ * actionable hint instead of a generic parse error (Codex syntax is a strong
+ * prior for GPT-family models; a silent failure traps them in retry loops).
+ * @module dsh-patch-edit-plus/detect
+ */
+import { unrecognizedPatchError } from './errors.js';
+const HUNK_HINT = /^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/m;
+/**
+ * Classify patch text. Order matters: the `*** Begin Patch` sentinel wins
+ * first, then explicit unified-diff markers, then Codex section headers.
+ * @throws {@link PatchError} code `PARSE` (with both syntax examples) when the text matches neither supported syntax.
+ */
+export function detectFormat(patch) {
+    const normalized = patch.replaceAll('\r\n', '\n').trimStart();
+    if (normalized.startsWith('*** Begin Patch'))
+        return 'codex';
+    if (normalized.startsWith('diff --git '))
+        return 'unified';
+    if (normalized.startsWith('--- '))
+        return 'unified';
+    if (HUNK_HINT.test(normalized))
+        return 'unified';
+    if (normalized.includes('*** Add File:') || normalized.includes('*** Update File:') || normalized.includes('*** Delete File:'))
+        return 'codex';
+    throw unrecognizedPatchError();
+}

package/lib/errors.js

@@ -0,0 +1,125 @@
+/**
+ * Error taxonomy and model-facing message builders.
+ *
+ * Every failure surfaces as a `PatchError` with a stable machine code so
+ * retry/permission/UI layers can branch without parsing prose. Messages are
+ * written for the model to self-correct: they carry the concrete file, hunk,
+ * position and excerpt needed to fix the patch (no stacks, no internal paths).
+ * @module dsh-patch-edit-plus/errors
+ */
+/** Typed patch failure. */
+export class PatchError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'PatchError';
+        this.code = code;
+    }
+}
+/** Syntax examples embedded in "cannot recognize" errors so the model can retry in a valid dialect. */
+export const SYNTAX_EXAMPLES = [
+    'Supported patch styles:',
+    '1. git/unified diff:',
+    '--- a/file.txt',
+    '+++ b/file.txt',
+    '@@ -1,3 +1,3 @@',
+    ' context',
+    '-old line',
+    '+new line',
+    '2. Codex apply_patch syntax:',
+    '*** Begin Patch',
+    '*** Update File: file.txt',
+    '@@',
+    ' context',
+    '-old line',
+    '+new line',
+    '*** End Patch',
+].join('\n');
+/** PARSE error for input that matches neither supported syntax. */
+export function unrecognizedPatchError() {
+    return new PatchError('PARSE', `Cannot recognize the patch text as either supported syntax.\n${SYNTAX_EXAMPLES}`);
+}
+/** PARSE error with position information for malformed input. */
+export function parseError(lineNo, why) {
+    return new PatchError('PARSE', `Invalid patch at line ${lineNo}: ${why}`);
+}
+/** Structured error when a recognized Codex patch arrives while the style is disabled (actionable, not a parse failure). */
+export function codexDisabledError() {
+    return new PatchError('UNSUPPORTED', 'The patch was recognized as Codex `apply_patch` syntax, but that style is currently disabled. '
+        + 'Retry with a git/unified diff patch instead, or enable the Codex style by setting '
+        + '`allowCodexPatch: true` in the dsh-patch-edit-plus plugin configuration.');
+}
+/** Structured error when a unified diff arrives while that style is disabled. */
+export function unifiedDisabledError() {
+    return new PatchError('UNSUPPORTED', 'The patch was recognized as a git/unified diff, but that style is currently disabled. '
+        + 'Enable it by setting `allowUnifiedDiff: true` in the dsh-patch-edit-plus plugin configuration.');
+}
+/** CONFLICT error for an Add onto an existing path (Codex semantics). */
+export function addExistsError(path) {
+    return new PatchError('CONFLICT', `Add File targets "${path}" but the file already exists. Use an Update hunk to modify it, or Delete it first.`);
+}
+/** CONFLICT error for update/delete of a missing file. */
+export function missingFileError(path, action) {
+    return new PatchError('CONFLICT', `Cannot ${action} "${path}": the file does not exist.`);
+}
+/** CONFLICT error for a Move onto an existing path. */
+export function moveTargetExistsError(path) {
+    return new PatchError('CONFLICT', `Cannot move to "${path}": the target already exists.`);
+}
+/** CONFLICT error when one resolved file is hit by more than one patch operation. */
+export function duplicatePathError(path) {
+    return new PatchError('CONFLICT', `The patch touches "${path}" in more than one file section. Split it into separate apply_patch calls with one section per file.`);
+}
+/** VALIDATION error for paths escaping the workspace. */
+export function pathEscapeError(path) {
+    return new PatchError('VALIDATION', `Path "${path}" escapes the session workspace. Patch paths must stay inside the workspace.`);
+}
+/** VALIDATION error when a symlink is on the patch path (followSymlinks: false). */
+export function symlinkRejectedError(path, at) {
+    return new PatchError('VALIDATION', `Path "${path}" traverses the symbolic link "${at}". Symbolic links are rejected by the default followSymlinks: false policy.`);
+}
+/** VALIDATION error when the Add parent directory does not exist (matches the native write tool's behavior). */
+export function missingParentError(path, parent) {
+    return new PatchError('VALIDATION', `Cannot add "${path}": parent directory "${parent}" does not exist. Create the directory first (for example with the bash tool).`);
+}
+/** LIMIT error for exceeding a configured cap. */
+export function limitError(what, actual, limit) {
+    return new PatchError('LIMIT', `Patch rejected: ${what} is ${actual}, exceeding the configured limit of ${limit}. Split the patch into smaller apply_patch calls.`);
+}
+/** UNSUPPORTED error when delete/move is disabled or no shell capability exists. */
+export function unsupportedShellError(why) {
+    return new PatchError('UNSUPPORTED', `${why} Apply the change with a bash command instead (for example \`rm\` or \`mv\`), or adjust the dsh-patch-edit-plus deleteBackend configuration.`);
+}
+const MAX_PREVIEW_LINES = 12;
+const MAX_ACTUAL_LINES = 10;
+/** Render one line with visible whitespace so exact-match failures are diagnosable. */
+function visible(line) {
+    return line.replaceAll(' ', '[space]').replaceAll('\t', '[tab]') || '[empty]';
+}
+/**
+ * Four-element mismatch diagnostic: file + hunk index, search origin, expected
+ * preview, actual excerpt — plus a targeted hint when the expected lines look
+ * like they still carry patch markers (the classic duplicated-prefix mistake).
+ */
+export function mismatchMessage(input) {
+    const expected = input.expected.slice(0, MAX_PREVIEW_LINES).map(visible);
+    const actual = input.actual.slice(0, MAX_ACTUAL_LINES).map(visible);
+    const parts = [
+        `Hunk ${input.hunkIndex} of "${input.path}" does not apply: the context does not match the file.`,
+        `Search started at line ${input.searchFromLine}${input.endOfFile ? ' (pinned to end of file)' : ''}.`,
+        `Expected lines:\n${expected.join('\n')}`,
+        `File around the search origin:\n${actual.length > 0 ? actual.join('\n') : '[end of file]'}`,
+    ];
+    const markerHint = input.expected.find(line => /^[+\-@@]/.test(line));
+    if (markerHint !== undefined) {
+        parts.push(`Hint: an expected line starts with a patch marker ("${visible(markerHint).slice(0, 40)}"). `
+            + 'Inside an Update hunk only the context/removed lines must match the file exactly as it exists — '
+            + 'do not include "+"/"-"/"@@" prefixes from an outer diff in the hunk body.');
+    }
+    return parts.join('\n');
+}
+/** IO error wrapping a backend failure. */
+export function ioError(what, cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    return new PatchError('IO', `${what}: ${detail}`);
+}

package/lib/fsops.js

@@ -0,0 +1,51 @@
+/**
+ * Filesystem seam: reads plus the official write-intent dance.
+ *
+ * DSH providers NEVER dispatch `fs/*` events — the tool layer is the only
+ * initiator — so a bare `ctx.fs.writeText` would silently bypass the
+ * read-before-write gate. Every write here therefore replicates the official
+ * `write` tool verbatim:
+ * 1. `ctx.waterfall('fs/write-intent', target, exec, () => undefined)`
+ * 2. `ctx.fs.writeText(target, content, intent, exec.signal, sandboxPolicy)`
+ * 3. `ctx.emit('fs/observed', target, { kind: 'present', version }, exec)`
+ * With no policy plugin mounted the waterfall returns `undefined`, which is
+ * itself the correct "unconditional write" probe.
+ * @module dsh-patch-edit-plus/fsops
+ */
+import { ioError } from './errors.js';
+/**
+ * Write one file through the full intent dance. Must stay byte-for-byte the
+ * official sequence — the verification script asserts it.
+ * @throws {@link PatchError} code `IO` when the backend rejects the write.
+ */
+export async function writeFile(ctx, exec, target, content, sandboxPolicy) {
+    try {
+        const intent = await ctx.waterfall('fs/write-intent', target, exec, () => undefined);
+        const outcome = await ctx.fs.writeText(target, content, intent, exec.signal, sandboxPolicy);
+        ctx.emit('fs/observed', target, { kind: 'present', version: outcome.version }, exec);
+        return outcome;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'PatchError')
+            throw error;
+        throw ioError(`failed to write "${target.displayPath}"`, error);
+    }
+}
+/** Read one file's text (whole file). */
+export async function readFile(ctx, exec, target) {
+    try {
+        return await ctx.fs.readText(target, exec.signal);
+    }
+    catch (error) {
+        throw ioError(`failed to read "${target.displayPath}"`, error);
+    }
+}
+/** Stat one resolved target; `undefined` when absent. */
+export async function statFile(ctx, exec, target) {
+    try {
+        return await ctx.fs.stat(target, exec.signal);
+    }
+    catch (error) {
+        throw ioError(`failed to stat "${target.displayPath}"`, error);
+    }
+}

package/lib/index.js

@@ -0,0 +1,39 @@
+/**
+ * dsh-patch-edit-plus — patch-style file editing for DeepSeek Harness.
+ *
+ * One `apply_patch` tool accepting git/unified diff (default) and Codex
+ * `apply_patch` syntax (opt-in). All-or-nothing application through the
+ * official fs write-intent dance; delete/move through the sandbox-aware
+ * shell. Compatible with DSH 0.1.2-rc.1 through 0.1.5-rc.2: the tool
+ * authoring contract is byte-identical across those versions, so a single
+ * code path serves both; only settings registration needs the dual-API
+ * fallback (`installSection` first, `register` second).
+ *
+ * @module dsh-patch-edit-plus
+ */
+import { Config, resolveConfig } from './config.js';
+import { registerApplyPatchTool } from './register.js';
+/** Cordis plugin name used by Loader diagnostics. */
+export const name = 'dsh-patch-edit-plus';
+/** Settings namespace (a plain string literal: valid on every target version). */
+export const SETTINGS_NAMESPACE = 'patch_edit_plus';
+export { Config };
+/** Register the tool and the settings namespace. Every registration is scoped to this plugin. */
+export function apply(ctx, config) {
+    const cfg = resolveConfig(config);
+    ctx.effect(() => {
+        const disposer = registerApplyPatchTool(ctx, cfg);
+        return disposer ?? (() => { });
+    });
+    ctx.inject(['settings'], (settingsCtx) => {
+        const settings = settingsCtx.settings
+            ?? settingsCtx;
+        const base = config ?? {};
+        if (typeof settings?.installSection === 'function') {
+            settings.installSection(ctx, SETTINGS_NAMESPACE, Config, base, { setSource: () => { }, onChange: () => { } });
+        }
+        else if (typeof settings?.register === 'function') {
+            settings.register(SETTINGS_NAMESPACE, Config, { base });
+        }
+    });
+}