@shuind/dsh-codex-harness 0.1.7

package/lib/types/index.js

@@ -0,0 +1,321 @@
+/** Codex-compatible prompt overlay and core tools for a dsh agent preset. */
+import z from '@deepseek-ai/schemastery';
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { applyPatchHunks, parsePatch } from "./patch.js";
+import { renderExecResult, runExecCommand, runWriteStdin } from "./exec.js";
+export const name = 'codex';
+export const inject = ['tools', 'systemPrompt', 'shell', 'fs'];
+/** Runtime configuration schema for the Codex tool bridge. */
+export const Config = z.object({
+    defaultYieldTimeMs: z.number().step(1).min(0).default(10_000),
+    pollYieldTimeMs: z.number().step(1).min(0).default(5_000),
+    writeYieldTimeMs: z.number().step(1).min(0).default(250),
+    maxOutputBytes: z.number().step(1).min(1).default(64_000),
+});
+const CODEX_BASE_PROMPT = String.raw `You are Codex, based on {{model}}. You are running as a coding agent in dsh Web on a user's computer.
+
+## General
+
+- When searching for text or files, prefer using rg or rg --files respectively because rg is much faster than alternatives like grep. If rg is not available, use the next best alternative.
+
+## Editing constraints
+
+- Default to ASCII when editing or creating files. Only introduce non-ASCII or other Unicode characters when there is a clear justification and the file already uses them.
+- Add succinct code comments that explain non-obvious code. Do not add comments that merely narrate assignments or control flow.
+- Use apply_patch for single-file edits when practical. The apply_patch tool accepts its freeform patch language; do not wrap that patch in JSON.
+- You may be in a dirty git worktree. Never revert existing changes you did not make unless the user explicitly requests it. If unrelated files are changed, leave them alone.
+
+## Planning
+
+- Use update_plan for work with multiple meaningful steps. Keep the plan current as the task progresses.
+- Do not use a plan for a trivial one-step request.
+
+## dsh session
+
+- The user and you share one workspace. Inspect the repository and every applicable AGENTS.md before editing.
+- This session's preset was selected when the session was created and stays fixed for its lifetime. Do not attempt to switch the preset or replace its tool catalog while the session is running.
+- dsh provides the execution, filesystem, session, policy, and Skills capabilities behind these tools. Use those extension points as supplied; do not invent a second harness or bypass the filesystem service for file edits.
+- The core Codex tool names, arguments, and result formats are fixed: use exec_command for terminal work, write_stdin for an existing interactive command, apply_patch for file changes, and update_plan for multi-step tasks.
+
+## Task execution
+
+- Keep the user informed with concise progress updates and lead with the result.
+- Prefer existing functions and extension points over new machinery.
+- Do not claim that a command, edit, or test succeeded unless it actually succeeded.
+- Use the exact tool names and argument formats supplied by this session; do not invent replacement editing tools.
+
+## Presenting your work
+
+- Be concise, direct, friendly, and actionable.
+- For substantial work, explain what changed and why, then mention relevant verification and next steps.
+- Do not dump large files into the conversation; refer to their paths.
+- Use plain text with short sections only when they improve scanability.
+`;
+const EXEC_COMMAND_DESCRIPTION = 'Runs a command in a PTY, returning output or a session ID for ongoing interaction.';
+const WRITE_STDIN_DESCRIPTION = 'Writes characters to an existing unified exec session and returns recent output.';
+const APPLY_PATCH_DESCRIPTION = 'The `apply_patch` tool can be used to edit files. This is a FREEFORM tool, so do not wrap the patch in JSON.';
+const UPDATE_PLAN_DESCRIPTION = 'Updates the task plan.\nProvide an optional explanation and a list of plan items, each with a step and status.\nAt most one step can be in_progress at a time.';
+const PLAN_STATUSES = ['pending', 'in_progress', 'completed'];
+function sessionCwd(exec) {
+    return exec.agent?.session.header.cwd;
+}
+function resolvePolicy(ctx, exec) {
+    const policy = ctx.get('sandboxPolicy');
+    return policy?.resolve(exec.agent === undefined ? {} : { session: exec.agent.session });
+}
+async function resolveTarget(ctx, path, exec) {
+    const cwd = sessionCwd(exec);
+    return ctx.fs.resolve(path, cwd === undefined ? { signal: exec.signal } : { cwd, signal: exec.signal });
+}
+async function observedTarget(ctx, target, exec) {
+    const info = await ctx.fs.stat(target, exec.signal);
+    if (info === undefined)
+        throw new Error(`apply_patch: file not found: ${target.displayPath}`);
+    if (info.type !== 'file')
+        throw new Error(`apply_patch: not a regular file: ${target.displayPath}`);
+    ctx.emit('fs/observed', target, { kind: 'present', version: info.version }, exec);
+    return info;
+}
+async function writePatchedFile(ctx, target, content, fallback, exec, policy) {
+    const intent = await ctx.waterfall('fs/write-intent', target, exec, () => fallback);
+    const outcome = await ctx.fs.writeText(target, content, intent, exec.signal, policy);
+    ctx.emit('fs/observed', target, { kind: 'present', version: outcome.version }, exec);
+    return outcome.operation === 'create' ? 'created' : 'updated';
+}
+async function deletePatchedFile(ctx, target, version, exec, policy) {
+    const remove = ctx.fs.remove;
+    if (typeof remove !== 'function') {
+        throw new Error('apply_patch: the configured dsh filesystem does not support file deletion');
+    }
+    await remove.call(ctx.fs, target, { version }, exec.signal, policy);
+    ctx.emit('fs/observed', target, { kind: 'absent' }, exec);
+}
+async function applyOnePatch(ctx, file, exec, policy) {
+    const target = await resolveTarget(ctx, file.path, exec);
+    if (file.kind === 'add') {
+        const existing = await ctx.fs.stat(target, exec.signal);
+        if (existing !== undefined)
+            throw new Error(`apply_patch: file already exists: ${target.displayPath}`);
+        ctx.emit('fs/observed', target, { kind: 'absent' }, exec);
+        await writePatchedFile(ctx, target, file.content, { kind: 'createIfAbsent' }, exec, policy);
+        return { path: file.path, operation: 'created' };
+    }
+    const sourceInfo = await observedTarget(ctx, target, exec);
+    const original = await ctx.fs.readText(target, exec.signal);
+    const updated = file.kind === 'delete' ? undefined : applyPatchHunks(original, file.hunks);
+    if (file.kind === 'delete') {
+        await deletePatchedFile(ctx, target, sourceInfo.version, exec, policy);
+        return { path: file.path, operation: 'deleted' };
+    }
+    if (file.moveTo === undefined) {
+        await writePatchedFile(ctx, target, updated, { kind: 'replaceIfVersion', version: sourceInfo.version }, exec, policy);
+        return { path: file.path, operation: 'updated' };
+    }
+    const destination = await resolveTarget(ctx, file.moveTo, exec);
+    if (destination.targetKey === target.targetKey) {
+        await writePatchedFile(ctx, target, updated, { kind: 'replaceIfVersion', version: sourceInfo.version }, exec, policy);
+        return { path: file.path, operation: 'updated', moveTo: file.moveTo };
+    }
+    const destinationInfo = await ctx.fs.stat(destination, exec.signal);
+    if (destinationInfo !== undefined)
+        throw new Error(`apply_patch: move destination already exists: ${destination.displayPath}`);
+    ctx.emit('fs/observed', destination, { kind: 'absent' }, exec);
+    await writePatchedFile(ctx, destination, updated, { kind: 'createIfAbsent' }, exec, policy);
+    await deletePatchedFile(ctx, target, sourceInfo.version, exec, policy);
+    return { path: file.path, operation: 'moved', moveTo: file.moveTo };
+}
+function patchSummary(value) {
+    const letter = (operation) => {
+        switch (operation) {
+            case 'created': return 'A';
+            case 'updated': return 'M';
+            case 'deleted': return 'D';
+            case 'moved': return 'M';
+            default: return operation;
+        }
+    };
+    return `Success. Updated the following files:\n${value.files.map(file => `${letter(file.operation)} ${file.operation === 'moved' ? file.moveTo : file.path}`).join('\n')}\n`;
+}
+function planTodos(args) {
+    const seen = new Set();
+    let active = 0;
+    const todos = [];
+    for (const item of args.plan) {
+        const content = item.step.trim();
+        if (content.length === 0)
+            throw new Error('update_plan: every step must be non-empty');
+        if (seen.has(content))
+            throw new Error(`update_plan: duplicate step ${JSON.stringify(content)}`);
+        seen.add(content);
+        if (item.status === 'in_progress')
+            active++;
+        todos.push({ content, status: item.status });
+    }
+    if (active > 1)
+        throw new Error('update_plan: at most one step may be in_progress');
+    return todos;
+}
+function registerExecTools(ctx, config) {
+    ctx.tools.register(defineTool({
+        name: 'exec_command',
+        description: EXEC_COMMAND_DESCRIPTION,
+        parameters: {
+            cmd: { type: 'string', required: true, description: 'Shell command to execute.' },
+            workdir: { type: 'string', description: 'Working directory for the command. Defaults to the turn cwd.' },
+            tty: { type: 'boolean', description: 'True allocates a PTY for the command; false or omitted uses plain pipes.' },
+            yield_time_ms: { type: 'number', description: 'Wait before yielding output. Defaults to 10000 ms; effective range is 250-30000 ms.' },
+            max_output_tokens: { type: 'number', description: 'Output token budget. Defaults to 10000 tokens; larger requests may be capped by policy.' },
+            shell: { type: 'string', description: "Shell binary to launch. Defaults to the user's default shell." },
+            login: { type: 'boolean', description: 'True runs the shell with -l/-i semantics; false disables them. Defaults to true.' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    chunk_id: { type: 'string' },
+                    wall_time_seconds: { type: 'number', required: true },
+                    exit_code: { type: 'number' },
+                    session_id: { type: 'number' },
+                    original_token_count: { type: 'number' },
+                    output: { type: 'string', required: true },
+                },
+            },
+            render: (_args, value) => [{ type: 'text', text: renderExecResult(value) }],
+        },
+        async execute(args, exec) {
+            return runExecCommand(ctx, args, exec, config);
+        },
+        presentCall: args => ({
+            card: 'terminal',
+            title: args.cmd,
+            ...args.workdir === undefined ? {} : { cwd: args.workdir },
+        }),
+    }));
+    ctx.tools.register(defineTool({
+        name: 'write_stdin',
+        description: WRITE_STDIN_DESCRIPTION,
+        parameters: {
+            session_id: { type: 'number', required: true, description: 'Identifier of the running unified exec session.' },
+            chars: { type: 'string', description: 'Bytes to write to stdin. Defaults to empty, which polls without writing.' },
+            yield_time_ms: { type: 'number', description: 'Wait before yielding output. Non-empty writes default to 250 ms and cap at 30000 ms; empty polls wait 5000-300000 ms by default.' },
+            max_output_tokens: { type: 'number', description: 'Output token budget. Defaults to 10000 tokens; larger requests may be capped by policy.' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    chunk_id: { type: 'string' },
+                    wall_time_seconds: { type: 'number', required: true },
+                    exit_code: { type: 'number' },
+                    session_id: { type: 'number' },
+                    original_token_count: { type: 'number' },
+                    output: { type: 'string', required: true },
+                },
+            },
+            render: (_args, value) => [{ type: 'text', text: renderExecResult(value) }],
+        },
+        async execute(args, exec) {
+            return runWriteStdin(ctx, args, exec, config);
+        },
+    }));
+}
+function registerPatchTool(ctx) {
+    ctx.tools.register(defineTool({
+        name: 'apply_patch',
+        description: APPLY_PATCH_DESCRIPTION,
+        parameters: {
+            input: { type: 'string', required: true, description: 'The complete patch text.' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    files: {
+                        type: 'array',
+                        required: true,
+                        items: {
+                            type: 'object',
+                            additionalProperties: false,
+                            properties: {
+                                path: { type: 'string', required: true },
+                                operation: { type: 'string', required: true, enum: ['created', 'updated', 'deleted', 'moved'] },
+                                moveTo: { type: 'string' },
+                            },
+                        },
+                    },
+                },
+            },
+            render: (_args, value) => [{ type: 'text', text: patchSummary(value) }],
+        },
+        async execute(args, exec) {
+            const files = parsePatch(args.input);
+            const policy = resolvePolicy(ctx, exec);
+            const applied = [];
+            for (const file of files)
+                applied.push(await applyOnePatch(ctx, file, exec, policy));
+            return { files: applied };
+        },
+        presentCall(args) {
+            return {
+                card: 'generic',
+                title: 'Apply patch',
+                kind: 'edit',
+                rawInput: args.input,
+            };
+        },
+    }));
+}
+function registerPlanTool(ctx) {
+    ctx.tools.register(defineTool({
+        name: 'update_plan',
+        description: UPDATE_PLAN_DESCRIPTION,
+        parameters: {
+            explanation: { type: 'string', description: 'Optional explanation for this plan update.' },
+            plan: {
+                type: 'array',
+                required: true,
+                description: 'The list of steps',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: {
+                        step: { type: 'string', required: true, description: 'Task step text.' },
+                        status: { type: 'string', required: true, enum: [...PLAN_STATUSES], description: 'Step status.' },
+                    },
+                },
+            },
+        },
+        output: {
+            schema: { type: 'object', additionalProperties: false, properties: {} },
+            render: () => [{ type: 'text', text: 'Plan updated' }],
+        },
+        execute(args, exec) {
+            const agent = exec.agent;
+            if (agent === undefined)
+                throw new Error('update_plan requires an owning agent session');
+            agent.session.append('todo/write', { todos: planTodos(args) });
+            return Promise.resolve({});
+        },
+    }));
+}
+/** Mount the Codex prompt/tool layer inside one fixed agent preset. */
+export function apply(ctx, config = {}) {
+    const resolved = {
+        defaultYieldTimeMs: config.defaultYieldTimeMs ?? 10_000,
+        pollYieldTimeMs: config.pollYieldTimeMs ?? 5_000,
+        writeYieldTimeMs: config.writeYieldTimeMs ?? 250,
+        maxOutputBytes: config.maxOutputBytes ?? 64_000,
+    };
+    if (ctx.fs.sandboxMode !== undefined && ctx.get('sandboxPolicy') === undefined) {
+        throw new Error('codex: a sandboxing filesystem requires ctx.sandboxPolicy');
+    }
+    ctx.systemPrompt.section({ name: 'codex:base', order: 10, text: CODEX_BASE_PROMPT });
+    registerExecTools(ctx, resolved);
+    registerPatchTool(ctx);
+    registerPlanTool(ctx);
+}
+export default { name, inject, Config, apply };
+//# sourceMappingURL=index.js.map

package/lib/types/installer.d.ts

@@ -0,0 +1,23 @@
+/** Install the user-visible Codex agent preset supplied by this bundle. */
+import type { Context } from '@deepseek-ai/cordis';
+/** Bundle plugin name for the preset installer. */
+export declare const name = "codex-preset-installer";
+/**
+ * Install the shipped Codex preset only when the user has not authored one.
+ *
+ * The directory is committed with a staging rename so a failed copy cannot
+ * leave a half-written preset that hides the mode from the roster. Existing
+ * directories are intentionally preserved, including user customizations.
+ *
+ * @param targetDir - destination preset directory.
+ * @param sourceDir - directory containing the packaged preset files.
+ */
+export declare function installCodexPreset(targetDir?: string, sourceDir?: string): void;
+/** Install the preset during profile boot without changing the host tool catalog. */
+export declare function apply(ctx: Context): void;
+declare const _default: {
+    name: string;
+    apply: typeof apply;
+};
+export default _default;
+//# sourceMappingURL=installer.d.ts.map

package/lib/types/installer.js

@@ -0,0 +1,64 @@
+/** Install the user-visible Codex agent preset supplied by this bundle. */
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const PRESET_ID = 'codex';
+const PRESET_FILES = ['agent.cordis.yml', 'preset.yml'];
+const SOURCE_PRESET_DIR = fileURLToPath(new URL('../presets/codex/', import.meta.url));
+function dshHomePath(...segments) {
+    const configured = process.env.DSH_HOME?.trim();
+    const expanded = configured === undefined || configured.length === 0
+        ? join(homedir(), '.dsh')
+        : configured === '~'
+            ? homedir()
+            : configured.startsWith('~/') || configured.startsWith('~\\')
+                ? join(homedir(), configured.slice(2))
+                : configured;
+    return join(resolve(expanded), ...segments);
+}
+/** Bundle plugin name for the preset installer. */
+export const name = 'codex-preset-installer';
+/**
+ * Install the shipped Codex preset only when the user has not authored one.
+ *
+ * The directory is committed with a staging rename so a failed copy cannot
+ * leave a half-written preset that hides the mode from the roster. Existing
+ * directories are intentionally preserved, including user customizations.
+ *
+ * @param targetDir - destination preset directory.
+ * @param sourceDir - directory containing the packaged preset files.
+ */
+export function installCodexPreset(targetDir = dshHomePath('.agent-presets', PRESET_ID), sourceDir = SOURCE_PRESET_DIR) {
+    if (existsSync(targetDir))
+        return;
+    const parentDir = dirname(targetDir);
+    mkdirSync(parentDir, { recursive: true });
+    const stagingDir = mkdtempSync(join(parentDir, `.${PRESET_ID}-`));
+    try {
+        for (const file of PRESET_FILES)
+            copyFileSync(join(sourceDir, file), join(stagingDir, file));
+        try {
+            renameSync(stagingDir, targetDir);
+        }
+        catch (error) {
+            if (!existsSync(targetDir))
+                throw error;
+        }
+    }
+    finally {
+        if (existsSync(stagingDir))
+            rmSync(stagingDir, { recursive: true, force: true });
+    }
+}
+/** Install the preset during profile boot without changing the host tool catalog. */
+export function apply(ctx) {
+    try {
+        installCodexPreset();
+    }
+    catch (error) {
+        ctx.logger.warn(`dsh-codex: could not install the Codex preset: ${String(error)}`);
+    }
+}
+export default { name, apply };
+//# sourceMappingURL=installer.js.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@shuind/dsh-codex-harness`.
+ * @module @shuind/dsh-codex-harness/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Codex companion plugin name. */
+export declare const name = "codex-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/invariant.js

@@ -0,0 +1,22 @@
+/**
+ * Package-owned invariant companion for `@shuind/dsh-codex-harness`.
+ * @module @shuind/dsh-codex-harness/invariant
+ */
+const PACKAGE_NAME = '@shuind/dsh-codex-harness';
+/** Codex companion plugin name. */
+export const name = 'codex-invariant';
+/** Service required before the companion can reserve package ownership. */
+export const inject = ['invariants'];
+/**
+ * Codex has no independent lifecycle stream: its model-visible state is owned
+ * by the tool registry and session projection services it consumes.
+ */
+const install = () => { };
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+/* jscpd:ignore-end */
+//# sourceMappingURL=invariant.js.map

package/lib/types/patch.d.ts

@@ -0,0 +1,36 @@
+/** Parser and line-oriented applicator for Codex's `apply_patch` language. */
+/** The grammar sent to providers that support OpenAI custom grammar tools. */
+export declare const APPLY_PATCH_GRAMMAR: string;
+export type PatchLine = {
+    kind: 'context';
+    text: string;
+} | {
+    kind: 'delete';
+    text: string;
+} | {
+    kind: 'add';
+    text: string;
+};
+export interface PatchHunk {
+    context?: string;
+    lines: PatchLine[];
+    endOfFile: boolean;
+}
+export type PatchFile = {
+    kind: 'add';
+    path: string;
+    content: string;
+} | {
+    kind: 'delete';
+    path: string;
+} | {
+    kind: 'update';
+    path: string;
+    moveTo?: string;
+    hunks: PatchHunk[];
+};
+/** Parse one complete Codex patch after normalizing CRLF input to LF. */
+export declare function parsePatch(input: string): PatchFile[];
+/** Apply parsed update hunks and return LF-normalized text. */
+export declare function applyPatchHunks(original: string, hunks: readonly PatchHunk[]): string;
+//# sourceMappingURL=patch.d.ts.map

package/lib/types/patch.js

@@ -0,0 +1,186 @@
+/** Parser and line-oriented applicator for Codex's `apply_patch` language. */
+/** The grammar sent to providers that support OpenAI custom grammar tools. */
+export const APPLY_PATCH_GRAMMAR = String.raw `start: begin_patch hunk+ end_patch
+begin_patch: "*** Begin Patch" LF
+end_patch: "*** End Patch" LF?
+hunk: add_hunk | delete_hunk | update_hunk
+add_hunk: "*** Add File: " filename LF add_line+
+delete_hunk: "*** Delete File: " filename LF
+update_hunk: "*** Update File: " filename LF change_move? change?
+filename: /(.+)/
+add_line: "+" /(.*)/ LF -> line
+change_move: "*** Move to: " filename LF
+change: (change_context | change_line)+ eof_line?
+change_context: ("@@" | "@@ " /(.+)/) LF
+change_line: ("+" | "-" | " ") /(.*)/ LF
+eof_line: "*** End of File" LF
+%import common.LF
+`;
+function invalid(message) {
+    throw new Error(`apply_patch: ${message}`);
+}
+function isFileHeader(line) {
+    const trimmed = line.trim();
+    return trimmed.startsWith('*** Add File: ')
+        || trimmed.startsWith('*** Delete File: ')
+        || trimmed.startsWith('*** Update File: ');
+}
+function pathFrom(line, prefix) {
+    const path = line.slice(prefix.length).trim();
+    if (path.length === 0)
+        invalid(`${prefix.trim()} requires a file path`);
+    return path;
+}
+function isChangeMarker(line) {
+    const marker = line.trimEnd();
+    return marker === '@@' || marker.startsWith('@@ ');
+}
+function isPotentialChangeMarker(line) {
+    return line.trimEnd().startsWith('@@');
+}
+/** Parse one complete Codex patch after normalizing CRLF input to LF. */
+export function parsePatch(input) {
+    const lines = input.replaceAll('\r\n', '\n').trim().split('\n');
+    if (lines[0]?.trim() !== '*** Begin Patch')
+        invalid('input must start with "*** Begin Patch"');
+    if (lines.at(-1)?.trim() !== '*** End Patch')
+        invalid('input must end with "*** End Patch"');
+    const files = [];
+    let index = 1;
+    const end = lines.length - 1;
+    while (index < end) {
+        const header = lines[index++]?.trim();
+        if (header === undefined)
+            invalid('unexpected end of input');
+        if (header.startsWith('*** Add File: ')) {
+            const path = pathFrom(header, '*** Add File: ');
+            const content = [];
+            while (index < end && lines[index]?.startsWith('+') === true) {
+                content.push(lines[index].slice(1));
+                index++;
+            }
+            if (content.length === 0)
+                invalid(`add file ${JSON.stringify(path)} needs at least one content line`);
+            files.push({ kind: 'add', path, content: `${content.join('\n')}\n` });
+            continue;
+        }
+        if (header.startsWith('*** Delete File: ')) {
+            files.push({ kind: 'delete', path: pathFrom(header, '*** Delete File: ') });
+            continue;
+        }
+        if (!header.startsWith('*** Update File: '))
+            invalid(`unexpected directive ${JSON.stringify(header)}`);
+        const path = pathFrom(header, '*** Update File: ');
+        let moveTo;
+        if (lines[index]?.trim().startsWith('*** Move to: ') === true) {
+            moveTo = pathFrom(lines[index].trim(), '*** Move to: ');
+            index++;
+        }
+        const hunks = [];
+        while (index < end && !isFileHeader(lines[index])) {
+            const patchLines = [];
+            let context;
+            if (isPotentialChangeMarker(lines[index])) {
+                const marker = lines[index].trimEnd();
+                if (!isChangeMarker(marker)) {
+                    invalid(`invalid update hunk marker ${JSON.stringify(lines[index])}`);
+                }
+                index++;
+                context = marker.length === 2 ? undefined : marker.slice(3);
+            }
+            while (index < end && !isFileHeader(lines[index])
+                && !isPotentialChangeMarker(lines[index])
+                && lines[index].trimEnd() !== '*** End of File') {
+                const line = lines[index++];
+                const kind = line[0];
+                if (kind !== ' ' && kind !== '+' && kind !== '-') {
+                    invalid(`unexpected update line ${JSON.stringify(line)}`);
+                }
+                patchLines.push({ kind: kind === ' ' ? 'context' : kind === '+' ? 'add' : 'delete', text: line.slice(1) });
+            }
+            const endOfFile = lines[index]?.trimEnd() === '*** End of File';
+            if (endOfFile)
+                index++;
+            if (patchLines.length === 0) {
+                if (context !== undefined || endOfFile)
+                    invalid('an update hunk needs context or changed lines');
+                break;
+            }
+            hunks.push({
+                ...context === undefined ? {} : { context },
+                lines: patchLines,
+                endOfFile,
+            });
+        }
+        if (hunks.length === 0 && moveTo === undefined)
+            invalid(`update file ${JSON.stringify(path)} has no changes`);
+        files.push({
+            kind: 'update',
+            path,
+            ...moveTo === undefined ? {} : { moveTo },
+            hunks,
+        });
+    }
+    if (files.length === 0)
+        invalid('no files were modified');
+    return files;
+}
+function splitText(text) {
+    if (text.length === 0)
+        return { lines: [], trailingNewline: false };
+    const trailingNewline = text.endsWith('\n');
+    const lines = text.split('\n');
+    if (trailingNewline)
+        lines.pop();
+    return { lines, trailingNewline };
+}
+function joinText(value) {
+    const body = value.lines.join('\n');
+    return value.trailingNewline ? `${body}\n` : body;
+}
+function findSequence(lines, expected, from, endOfFile) {
+    if (expected.length === 0)
+        return Math.min(from, lines.length);
+    if (expected.length > lines.length)
+        return -1;
+    const first = endOfFile ? Math.max(from, lines.length - expected.length) : from;
+    const last = lines.length - expected.length;
+    const matchers = [
+        (actual, wanted) => actual === wanted,
+        (actual, wanted) => actual.trimEnd() === wanted.trimEnd(),
+        (actual, wanted) => actual.trim() === wanted.trim(),
+    ];
+    for (const matchesLine of matchers) {
+        for (let index = first; index <= last; index++) {
+            let matches = true;
+            for (let offset = 0; offset < expected.length; offset++) {
+                if (!matchesLine(lines[index + offset], expected[offset])) {
+                    matches = false;
+                    break;
+                }
+            }
+            if (matches)
+                return index;
+        }
+    }
+    return -1;
+}
+/** Apply parsed update hunks and return LF-normalized text. */
+export function applyPatchHunks(original, hunks) {
+    const value = splitText(original.replaceAll('\r\n', '\n'));
+    let cursor = 0;
+    for (const hunk of hunks) {
+        const expected = hunk.lines.filter(line => line.kind !== 'add').map(line => line.text);
+        const start = findSequence(value.lines, expected, cursor, hunk.endOfFile);
+        if (start < 0) {
+            const detail = expected.join('\n');
+            invalid(`could not find expected lines${detail.length === 0 ? '' : `:\n${detail}`}`);
+        }
+        const replacement = hunk.lines.filter(line => line.kind !== 'delete').map(line => line.text);
+        value.lines.splice(start, expected.length, ...replacement);
+        cursor = start + replacement.length;
+        value.trailingNewline = !hunk.endOfFile;
+    }
+    return joinText(value);
+}
+//# sourceMappingURL=patch.js.map