pi-agent-flow 2.0.1 → 2.0.2

package/agents/audit.md

@@ -11,16 +11,18 @@ mission: During this audit flow your mission is to verify and remediate quality
 workflow:
 1 Scope: identify the files behavior or change set to audit
 2 Inspect: review security correctness maintainability and performance risks use batch with o read s offset l limit for targeted file reading instead of bash sed head tail
-3 Classify: assign severity and explain the impact of each issue found
+3 Classify: assign severity and explain the impact of each issue found use P0 critical immediate action P1 serious fix soon P2 moderate schedule fix P3 minor note and track
 4 Fix: apply safe localized fixes directly with available tools
 5 Verify: run relevant tests or checks after fixes when practical
-6 Report: distinguish fixed issues from remaining risks
+6 Report: distinguish fixed issues from remaining risks give overall verdict CLEAN CAUTION or AT_RISK with confidence 0.0-1.0
 
 rules:
+A real issue causes data loss exposes secrets crashes produces wrong results violates contracts regresses perf >20% blocks CI or introduces a race style-only without behavioral impact is not an issue
 Be specific cite exact file paths and line numbers
 If code is clean say so do not invent issues
 Fix issues autonomously when the fix is safe and localized
 Do not apply risky rewrites or broad redesigns from audit flag them with severity instead
+Enumerate exhaustively before judging completeness do not stop at the first few issues
 If a fix requires broader redesign recommend craft in next steps
 If root cause is unclear recommend debug rather than guessing
 Markers: Prefix substantive claims with [V] verified, [I] inferred, [A] assumed, or [U] unknown.

package/agents/build.md

@@ -12,9 +12,9 @@ workflow:
 1 Analyze: read existing code for context
 2 Plan: outline approach before modifying
 3 Test: write or identify a failing test when practical
-4 Execute: implement changes following core principles
+4 Execute: implement changes following core principles size gate 800 lines or 500 complex lines per stage if exceeded split or recommend craft guard breaking changes with explicit migration note
 5 Verify: run tests and checks refactor only if working
-6 Ship: commit push monitor CI fix failures until green
+6 Ship: self-review changes and rate confidence 0.0-1.0 before committing push monitor CI fix failures until green
 7 Cleanup: delete old branch local and remote if requested otherwise leave the branch for the user to merge
 
 rules:
@@ -24,6 +24,7 @@ Commit with conventional messages feat fix refactor
 Do not merge to main unless the user explicitly requests it
 If merging use squash merge
 Update relevant docs if none changed, state why
+Prefer integration tests for coverage over unit tests alone when behavior crosses module boundaries
 Unexpected errors recommend debug do not guess
 Markers: Prefix substantive claims with [V] verified, [I] inferred, [A] assumed, or [U] unknown.
 Bite-first: Output raw evidence (code, paths, logs) before any prose explanation.

package/agents/craft.md

@@ -10,10 +10,10 @@ mission: During this craft flow your mission is to design a clear well structure
 
 workflow:
 1 Understand: define the problem constraints existing behavior and success criteria
-2 Explore: map relevant patterns dependencies and existing architecture use batch with o read s offset l limit for targeted file reading instead of bash sed head tail
+2 Explore: map relevant patterns dependencies and existing architecture use batch with o read s offset l limit for targeted file reading instead of bash sed head tail enumerate exhaustively
 3 Evaluate: assess whether the change fits existing patterns or requires a clean migration prefer incremental improvement when safe endorse full cut redesign when the architecture demands it
-4 Design: produce a concrete plan with ordered tasks data flow module boundaries and interface contracts
-5 Review: check risks edge cases test strategy migration path and handoff to build
+4 Design: produce a concrete plan with ordered tasks data flow module boundaries and interface contracts tag priorities P0-P3 cap each stage at 800 lines or 500 complex design bounded context buffers for large reads
+5 Review: check risks edge cases test strategy migration path and transfer to build include breaking-changes checklist require integration tests and give architecture soundness verdict
 
 rules:
 Follow SOLID (Single Responsibility Open Closed Liskov Substitution Interface Segregation Dependency Inversion) DRY (Do Not Repeat Yourself) KISS (Keep It Simple Stupid)

package/agents/debug.md

@@ -13,16 +13,17 @@ workflow:
 2 Hypothesize: list three to five concrete causes subsystem branch timing data shape each must be falsifiable
 3 Instrument: add minimal temporary logs or probes so one run can support or reject several hypotheses in parallel tag each log with hypothesisId prefer existing test hooks or stderr over noisy prints
 4 Run once: clear prior logs if applicable reproduce read the evidence before editing logic
-5 Conclude: for each hypothesis state CONFIRMED REJECTED or INCONCLUSIVE with cited lines log stack trace assertion
-6 Fix: only after a hypothesis is confirmed by evidence no speculative guards revert any change tied to a rejected hypothesis
+5 Conclude: for each hypothesis state CONFIRMED REJECTED or INCONCLUSIVE with confidence HIGH 0.8-1.0 MEDIUM 0.5-0.8 or LOW <0.5 and cite lines log stack trace assertion
+6 Fix: only after a hypothesis is confirmed by evidence no speculative guards revert any change tied to a rejected hypothesis if fix exceeds 50 lines recommend craft instead of a broad patch
 7 Verify: same repro plus tests compare before and after evidence no sleep or polling hacks as fixes unless the product contract truly requires delay
-8 Finalize: remove temporary instrumentation after verification or when orchestrator confirms if applicable update relevant docs, runbooks, or troubleshooting notes after finishing Documentation-only updates are required after finishing the work
+8 Finalize: remove temporary instrumentation after verification or when root state confirms if applicable update relevant docs, runbooks, or troubleshooting notes after finishing Documentation-only updates are required after finishing the work give overall verdict FIXED CONFIRMED INCONCLUSIVE or CANNOT_REPRODUCE with confidence 0.0-1.0
 
 rules:
 Evidence before edits read errors failing tests and traces before wide code reads
 Targeted reads use batch with o read s and l avoid bash sed head tail for source
 No fix without proof do not ship guesses if blocked report what evidence is still missing
 Keep instrumentation through verification do not strip logs until the post fix run proves the fix or the user confirms
+Prefer integration tests or existing test reproduction over manual steps when available
 State missing evidence or environment gaps do not invent a fix
 Markers: Prefix substantive claims with [V] verified, [I] inferred, [A] assumed, or [U] unknown.
 Bite-first: Output raw evidence (code, paths, logs) before any prose explanation.

package/agents/ideas.md

@@ -9,16 +9,17 @@ tier: full
 mission: During this ideas flow your mission is to generate and compare possible directions. Use inherited context as background and constraints but avoid anchoring too tightly on prior solutions.
 
 workflow:
-1 Diverge: explore many possibilities without judging too early
-2 Evaluate: compare trade offs risks effort and reversibility
-3 Recommend: identify the strongest options and explain why
-4 Package: present choices clearly enough for planning or implementation handoff
+1 Diverge: explore many possibilities without judging too early enumerate exhaustively before narrowing
+2 Evaluate: compare trade offs risks effort and reversibility tag each option P0-P3 and assess change size against 800/500 line caps plus breaking-changes risk
+3 Recommend: identify the strongest options explain why and give overall verdict with justification and confidence_score 0.0-1.0
+4 Package: present choices clearly enough for planning or implementation transfer
 
 rules:
 Stay focused on the requested intent creativity should still serve the objective
 Prefer several distinct options over variations of the same idea
 Make assumptions explicit when evidence is limited
 If file context is needed use batch with o read s offset l limit for targeted reading instead of bash sed head tail
+Prefer integration-testable ideas over brittle manual-only designs
 Do not implement changes from this flow
 Markers: Prefix substantive claims with [V] verified, [I] inferred, [A] assumed, or [U] unknown.
 Bite-first: Output raw evidence (code, paths, logs) before any prose explanation.

package/agents/scout.md

@@ -12,16 +12,18 @@ workflow:
 1 Survey: use ls find and grep to locate relevant files and symbols before reading whole files
 2 Inspect: use batch with o read s offset l limit for targeted file reading instead of bash sed head tail
 3 Trace: if batch returns a context map for a large file use the reported line ranges for targeted follow up reads then follow code paths dependencies configuration and tests that explain the requested area
-4 Report: cite concrete evidence with precise file paths and line ranges stop when the requested context is mapped
+4 Report: cite concrete evidence with precise file paths and line ranges stop when the requested context is mapped enumerate exhaustively before declaring completeness
 5 Validate: cross-check evidence, verify inferences against source, mark gaps with [U], and confirm sufficiency.
 
 rules:
+Keep context reads bounded cap grep ls find output highlight any artifact over 1k tokens as [P0] and read in chunks
 This is a read oriented flow do not modify files
 Cite every finding with a precise file path and line number or range
 Include relevant snippets or evidence inline so citations are verifiable
 Show actual code or data not excessive summaries
 If something is not found say so directly do not guess
 Workflow: Scouts must complete 5 steps (Survey → Inspect → Trace → Report → Validate). Reject and resend if Validate is missing.
+When tracing code paths surface any breaking-changes footprint deprecated APIs or altered contracts
 Snap mode: when session mode is snap, prioritize Survey and Inspect. Skip deep Trace. Emit partial findings fast — incomplete maps are acceptable.
 Markers: Preserve exactly ([V] Verified, [I] Inferred, [A] Assumed, [U] Unknown). Never present [A] or [U] as facts to the user. Dispatch a validation scout if critical claims are [A]/[U].
 Output: Zero preamble or filler. Start immediately with the answer or tool call.

package/dist/batch/apply-patch.d.ts

@@ -0,0 +1,60 @@
+/**
+ * apply-patch — 1:1 port of OpenAI Codex CLI apply_patch tool.
+ *
+ * Parses patch text into hunks, locates context via 4-stage fuzzy matching,
+ * computes replacements, and applies them to the filesystem.
+ */
+export interface UpdateFileChunk {
+    changeContext?: string;
+    oldLines: string[];
+    newLines: string[];
+    isEndOfFile: boolean;
+}
+export type Hunk = {
+    type: "add";
+    path: string;
+    contents: string;
+} | {
+    type: "delete";
+    path: string;
+} | {
+    type: "update";
+    path: string;
+    movePath?: string;
+    chunks: UpdateFileChunk[];
+};
+export interface ApplyPatchArgs {
+    patch: string;
+    hunks: Hunk[];
+    environmentId?: string;
+}
+export declare class ParseError extends Error {
+    readonly kind: "invalid-patch" | "invalid-hunk";
+    readonly lineNumber?: number | undefined;
+    constructor(kind: "invalid-patch" | "invalid-hunk", message: string, lineNumber?: number | undefined);
+}
+export declare class ComputeReplacementsError extends Error {
+    constructor(message: string);
+}
+export declare function parsePatch(patch: string): ApplyPatchArgs;
+export declare function seekSequence(lines: string[], pattern: string[], start: number, eof: boolean): number | undefined;
+export declare function computeReplacements(originalLines: string[], filePath: string, chunks: UpdateFileChunk[]): Array<{
+    startIdx: number;
+    oldLen: number;
+    newLines: string[];
+}>;
+export declare function applyReplacements(lines: string[], replacements: Array<{
+    startIdx: number;
+    oldLen: number;
+    newLines: string[];
+}>): string[];
+export interface AffectedPaths {
+    added: string[];
+    modified: string[];
+    deleted: string[];
+}
+export declare function applyPatch(patchText: string, cwd: string): Promise<{
+    affected: AffectedPaths;
+    exact: boolean;
+}>;
+//# sourceMappingURL=apply-patch.d.ts.map

package/dist/batch/apply-patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-patch.d.ts","sourceRoot":"","sources":["../../src/batch/apply-patch.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAwBH,MAAM,WAAW,eAAe;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,MAAM,IAAI,GACb;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,eAAe,EAAE,CAAA;CAAE,CAAC;AAElF,MAAM,WAAW,cAAc;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,UAAW,SAAQ,KAAK;aAEnB,IAAI,EAAE,eAAe,GAAG,cAAc;aAEtC,UAAU,CAAC,EAAE,MAAM;gBAFnB,IAAI,EAAE,eAAe,GAAG,cAAc,EACtD,OAAO,EAAE,MAAM,EACC,UAAU,CAAC,EAAE,MAAM,YAAA;CAKpC;AAED,qBAAa,wBAAyB,SAAQ,KAAK;gBACtC,OAAO,EAAE,MAAM;CAI3B;AA6ND,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAsBxD;AAMD,wBAAgB,YAAY,CAC3B,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,EAAE,MAAM,EAAE,EACjB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,OAAO,GACV,MAAM,GAAG,SAAS,CA4GpB;AAMD,wBAAgB,mBAAmB,CAClC,aAAa,EAAE,MAAM,EAAE,EACvB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,eAAe,EAAE,GACvB,KAAK,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAkDjE;AAED,wBAAgB,iBAAiB,CAChC,KAAK,EAAE,MAAM,EAAE,EACf,YAAY,EAAE,KAAK,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,GAC3E,MAAM,EAAE,CAOV;AA8BD,MAAM,WAAW,aAAa;IAC7B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,wBAAsB,UAAU,CAC/B,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,GACT,OAAO,CAAC;IAAE,QAAQ,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC,CAmEtD"}

package/dist/batch/apply-patch.js

@@ -0,0 +1,477 @@
+/**
+ * apply-patch — 1:1 port of OpenAI Codex CLI apply_patch tool.
+ *
+ * Parses patch text into hunks, locates context via 4-stage fuzzy matching,
+ * computes replacements, and applies them to the filesystem.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+// ---------------------------------------------------------------------------
+// Parser constants
+// ---------------------------------------------------------------------------
+const BEGIN_PATCH_MARKER = "*** Begin Patch";
+const END_PATCH_MARKER = "*** End Patch";
+const ENVIRONMENT_ID_MARKER = "*** Environment ID: ";
+const ADD_FILE_MARKER = "*** Add File: ";
+const DELETE_FILE_MARKER = "*** Delete File: ";
+const UPDATE_FILE_MARKER = "*** Update File: ";
+const MOVE_TO_MARKER = "*** Move to: ";
+const EOF_MARKER = "*** End of File";
+const CHANGE_CONTEXT_MARKER = "@@ ";
+const EMPTY_CHANGE_CONTEXT_MARKER = "@@";
+export class ParseError extends Error {
+    kind;
+    lineNumber;
+    constructor(kind, message, lineNumber) {
+        super(message);
+        this.kind = kind;
+        this.lineNumber = lineNumber;
+        this.name = "ParseError";
+    }
+}
+export class ComputeReplacementsError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ComputeReplacementsError";
+    }
+}
+// ---------------------------------------------------------------------------
+// Patch parser
+// ---------------------------------------------------------------------------
+function checkPatchBoundariesStrict(lines) {
+    if (lines.length === 0) {
+        throw new ParseError("invalid-patch", "The first line of the patch must be '*** Begin Patch'");
+    }
+    const first = lines[0].trim();
+    const last = lines[lines.length - 1].trim();
+    if (first !== BEGIN_PATCH_MARKER) {
+        throw new ParseError("invalid-patch", "The first line of the patch must be '*** Begin Patch'");
+    }
+    if (last !== END_PATCH_MARKER) {
+        throw new ParseError("invalid-patch", "The last line of the patch must be '*** End Patch'");
+    }
+    return { patchLines: lines, hunkLines: lines.slice(1, -1) };
+}
+function checkPatchBoundariesLenient(lines) {
+    try {
+        return checkPatchBoundariesStrict(lines);
+    }
+    catch (strictErr) {
+        if (lines.length >= 4) {
+            const first = lines[0].trim();
+            const last = lines[lines.length - 1].trim();
+            if ((first === "<<EOF" || first === "<<'EOF'" || first === '<<"EOF"') &&
+                last.endsWith("EOF")) {
+                const inner = lines.slice(1, -1);
+                try {
+                    return checkPatchBoundariesStrict(inner);
+                }
+                catch {
+                    /* fall through to return original error */
+                }
+            }
+        }
+        throw strictErr;
+    }
+}
+function parseEnvironmentIdPreamble(lines) {
+    if (lines.length === 0) {
+        return { remaining: lines, lineNumber: 2 };
+    }
+    const first = lines[0].trimStart();
+    if (first.startsWith(ENVIRONMENT_ID_MARKER)) {
+        const id = first.slice(ENVIRONMENT_ID_MARKER.length).trim();
+        if (id === "") {
+            throw new ParseError("invalid-patch", "apply_patch environment_id cannot be empty");
+        }
+        return { environmentId: id, remaining: lines.slice(1), lineNumber: 3 };
+    }
+    return { remaining: lines, lineNumber: 2 };
+}
+function parseUpdateFileChunk(lines, lineNumber, allowMissingContext) {
+    if (lines.length === 0) {
+        throw new ParseError("invalid-hunk", "Update hunk does not contain any lines", lineNumber);
+    }
+    let changeContext;
+    let startIndex = 0;
+    if (lines[0] === EMPTY_CHANGE_CONTEXT_MARKER) {
+        changeContext = undefined;
+        startIndex = 1;
+    }
+    else if (lines[0].startsWith(CHANGE_CONTEXT_MARKER)) {
+        changeContext = lines[0].slice(CHANGE_CONTEXT_MARKER.length);
+        startIndex = 1;
+    }
+    else {
+        if (!allowMissingContext) {
+            throw new ParseError("invalid-hunk", `Expected update hunk to start with a @@ context marker, got: '${lines[0]}'`, lineNumber);
+        }
+        changeContext = undefined;
+        startIndex = 0;
+    }
+    if (startIndex >= lines.length) {
+        throw new ParseError("invalid-hunk", "Update hunk does not contain any lines", lineNumber + 1);
+    }
+    const oldLines = [];
+    const newLines = [];
+    let isEndOfFile = false;
+    let parsedLines = 0;
+    for (let i = startIndex; i < lines.length; i++) {
+        const line = lines[i];
+        if (line === EOF_MARKER) {
+            if (parsedLines === 0) {
+                throw new ParseError("invalid-hunk", "Update hunk does not contain any lines", lineNumber + 1);
+            }
+            isEndOfFile = true;
+            parsedLines += 1;
+            break;
+        }
+        const firstChar = line.charAt(0);
+        if (firstChar === "") {
+            oldLines.push("");
+            newLines.push("");
+        }
+        else if (firstChar === " ") {
+            oldLines.push(line.slice(1));
+            newLines.push(line.slice(1));
+        }
+        else if (firstChar === "+") {
+            newLines.push(line.slice(1));
+        }
+        else if (firstChar === "-") {
+            oldLines.push(line.slice(1));
+        }
+        else {
+            if (parsedLines === 0) {
+                throw new ParseError("invalid-hunk", `Unexpected line found in update hunk: '${line}'. Every line should start with ' ' (context line), '+' (added line), or '-' (removed line)`, lineNumber + 1);
+            }
+            // Assume start of next hunk.
+            break;
+        }
+        parsedLines += 1;
+    }
+    return {
+        chunk: { changeContext, oldLines, newLines, isEndOfFile },
+        parsedLines: parsedLines + startIndex,
+    };
+}
+function parseOneHunk(lines, lineNumber) {
+    const firstLine = lines[0].trim();
+    if (firstLine.startsWith(ADD_FILE_MARKER)) {
+        const filePath = firstLine.slice(ADD_FILE_MARKER.length);
+        let contents = "";
+        let parsedLines = 1;
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.startsWith("+")) {
+                contents += line.slice(1) + "\n";
+                parsedLines += 1;
+            }
+            else {
+                break;
+            }
+        }
+        return { hunk: { type: "add", path: filePath, contents }, parsedLines };
+    }
+    if (firstLine.startsWith(DELETE_FILE_MARKER)) {
+        const filePath = firstLine.slice(DELETE_FILE_MARKER.length);
+        return { hunk: { type: "delete", path: filePath }, parsedLines: 1 };
+    }
+    if (firstLine.startsWith(UPDATE_FILE_MARKER)) {
+        const filePath = firstLine.slice(UPDATE_FILE_MARKER.length);
+        let remaining = lines.slice(1);
+        let parsedLines = 1;
+        let movePath;
+        if (remaining.length > 0 && remaining[0].startsWith(MOVE_TO_MARKER)) {
+            movePath = remaining[0].slice(MOVE_TO_MARKER.length);
+            remaining = remaining.slice(1);
+            parsedLines += 1;
+        }
+        const chunks = [];
+        while (remaining.length > 0) {
+            if (remaining[0].trim() === "") {
+                parsedLines += 1;
+                remaining = remaining.slice(1);
+                continue;
+            }
+            if (remaining[0].startsWith("*")) {
+                break;
+            }
+            const { chunk, parsedLines: chunkLines } = parseUpdateFileChunk(remaining, lineNumber + parsedLines, chunks.length === 0);
+            chunks.push(chunk);
+            parsedLines += chunkLines;
+            remaining = remaining.slice(chunkLines);
+        }
+        if (chunks.length === 0) {
+            throw new ParseError("invalid-hunk", `Update file hunk for path '${filePath}' is empty`, lineNumber);
+        }
+        return { hunk: { type: "update", path: filePath, movePath, chunks }, parsedLines };
+    }
+    throw new ParseError("invalid-hunk", `'${firstLine}' is not a valid hunk header. Valid hunk headers: '*** Add File: {path}', '*** Delete File: {path}', '*** Update File: {path}'`, lineNumber);
+}
+export function parsePatch(patch) {
+    const trimmed = patch.trim();
+    const lines = trimmed.split("\n");
+    const { patchLines, hunkLines } = checkPatchBoundariesLenient(lines);
+    const { environmentId, remaining, lineNumber } = parseEnvironmentIdPreamble(hunkLines);
+    let remainingLines = remaining;
+    let currentLine = lineNumber;
+    const hunks = [];
+    while (remainingLines.length > 0) {
+        const { hunk, parsedLines } = parseOneHunk(remainingLines, currentLine);
+        hunks.push(hunk);
+        currentLine += parsedLines;
+        remainingLines = remainingLines.slice(parsedLines);
+    }
+    return {
+        patch: patchLines.join("\n"),
+        hunks,
+        environmentId,
+    };
+}
+// ---------------------------------------------------------------------------
+// seek_sequence — 4-stage fuzzy matching
+// ---------------------------------------------------------------------------
+export function seekSequence(lines, pattern, start, eof) {
+    if (pattern.length === 0) {
+        return start;
+    }
+    if (pattern.length > lines.length) {
+        return undefined;
+    }
+    const searchStart = eof && lines.length >= pattern.length ? lines.length - pattern.length : start;
+    // Stage 1: exact match
+    for (let i = searchStart; i <= lines.length - pattern.length; i++) {
+        let ok = true;
+        for (let j = 0; j < pattern.length; j++) {
+            if (lines[i + j] !== pattern[j]) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok)
+            return i;
+    }
+    // Stage 2: rstrip match (ignore trailing whitespace)
+    for (let i = searchStart; i <= lines.length - pattern.length; i++) {
+        let ok = true;
+        for (let j = 0; j < pattern.length; j++) {
+            if (lines[i + j].trimEnd() !== pattern[j].trimEnd()) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok)
+            return i;
+    }
+    // Stage 3: trim match (ignore leading and trailing whitespace)
+    for (let i = searchStart; i <= lines.length - pattern.length; i++) {
+        let ok = true;
+        for (let j = 0; j < pattern.length; j++) {
+            if (lines[i + j].trim() !== pattern[j].trim()) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok)
+            return i;
+    }
+    // Stage 4: Unicode normalisation
+    function normalise(s) {
+        return s
+            .trim()
+            .split("")
+            .map((c) => {
+            switch (c) {
+                // Dashes / hyphens → ASCII '-'
+                case "\u2010":
+                case "\u2011":
+                case "\u2012":
+                case "\u2013":
+                case "\u2014":
+                case "\u2015":
+                case "\u2212":
+                    return "-";
+                // Fancy single quotes → '\''
+                case "\u2018":
+                case "\u2019":
+                case "\u201A":
+                case "\u201B":
+                    return "'";
+                // Fancy double quotes → '"'
+                case "\u201C":
+                case "\u201D":
+                case "\u201E":
+                case "\u201F":
+                    return '"';
+                // Odd spaces → normal space
+                case "\u00A0":
+                case "\u2002":
+                case "\u2003":
+                case "\u2004":
+                case "\u2005":
+                case "\u2006":
+                case "\u2007":
+                case "\u2008":
+                case "\u2009":
+                case "\u200A":
+                case "\u202F":
+                case "\u205F":
+                case "\u3000":
+                    return " ";
+                default:
+                    return c;
+            }
+        })
+            .join("");
+    }
+    for (let i = searchStart; i <= lines.length - pattern.length; i++) {
+        let ok = true;
+        for (let j = 0; j < pattern.length; j++) {
+            if (normalise(lines[i + j]) !== normalise(pattern[j])) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok)
+            return i;
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// compute_replacements + apply_replacements
+// ---------------------------------------------------------------------------
+export function computeReplacements(originalLines, filePath, chunks) {
+    const replacements = [];
+    let lineIndex = 0;
+    for (const chunk of chunks) {
+        if (chunk.changeContext) {
+            const idx = seekSequence(originalLines, [chunk.changeContext], lineIndex, false);
+            if (idx === undefined) {
+                throw new ComputeReplacementsError(`Failed to find context '${chunk.changeContext}' in ${filePath}`);
+            }
+            lineIndex = idx + 1;
+        }
+        if (chunk.oldLines.length === 0) {
+            // Pure addition — insert at end (or just before the trailing empty line).
+            const insertionIdx = originalLines.length > 0 && originalLines[originalLines.length - 1] === ""
+                ? originalLines.length - 1
+                : originalLines.length;
+            replacements.push({ startIdx: insertionIdx, oldLen: 0, newLines: chunk.newLines });
+            continue;
+        }
+        let pattern = chunk.oldLines;
+        let found = seekSequence(originalLines, pattern, lineIndex, chunk.isEndOfFile);
+        let newSlice = chunk.newLines;
+        if (found === undefined && pattern.length > 0 && pattern[pattern.length - 1] === "") {
+            // Retry without the trailing empty sentinel.
+            pattern = pattern.slice(0, -1);
+            if (newSlice.length > 0 && newSlice[newSlice.length - 1] === "") {
+                newSlice = newSlice.slice(0, -1);
+            }
+            found = seekSequence(originalLines, pattern, lineIndex, chunk.isEndOfFile);
+        }
+        if (found === undefined) {
+            throw new ComputeReplacementsError(`Failed to find expected lines in ${filePath}:\n${chunk.oldLines.join("\n")}`);
+        }
+        replacements.push({ startIdx: found, oldLen: pattern.length, newLines: newSlice });
+        lineIndex = found + pattern.length;
+    }
+    replacements.sort((a, b) => a.startIdx - b.startIdx);
+    return replacements;
+}
+export function applyReplacements(lines, replacements) {
+    const result = [...lines];
+    for (let i = replacements.length - 1; i >= 0; i--) {
+        const { startIdx, oldLen, newLines } = replacements[i];
+        result.splice(startIdx, oldLen, ...newLines);
+    }
+    return result;
+}
+function deriveNewContentsFromChunks(originalContent, chunks, filePath) {
+    let originalLines = originalContent.split("\n").map((l) => l);
+    // Drop the trailing empty element that results from the final newline
+    // so that line counts match the behaviour of standard diff.
+    if (originalLines.length > 0 && originalLines[originalLines.length - 1] === "") {
+        originalLines.pop();
+    }
+    const replacements = computeReplacements(originalLines, filePath, chunks);
+    let newLines = applyReplacements(originalLines, replacements);
+    // Ensure file terminates with a newline.
+    if (newLines.length === 0 || newLines[newLines.length - 1] !== "") {
+        newLines.push("");
+    }
+    return newLines.join("\n");
+}
+export async function applyPatch(patchText, cwd) {
+    const args = parsePatch(patchText);
+    const added = [];
+    const modified = [];
+    const deleted = [];
+    let exact = true;
+    for (const hunk of args.hunks) {
+        switch (hunk.type) {
+            case "add": {
+                const targetPath = path.resolve(cwd, hunk.path);
+                await fs.mkdir(path.dirname(targetPath), { recursive: true });
+                await fs.writeFile(targetPath, hunk.contents, "utf-8");
+                added.push(hunk.path);
+                break;
+            }
+            case "delete": {
+                const targetPath = path.resolve(cwd, hunk.path);
+                try {
+                    await fs.unlink(targetPath);
+                }
+                catch (err) {
+                    if (err.code === "ENOENT") {
+                        exact = false;
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                deleted.push(hunk.path);
+                break;
+            }
+            case "update": {
+                const targetPath = path.resolve(cwd, hunk.path);
+                let originalContent;
+                try {
+                    originalContent = await fs.readFile(targetPath, "utf-8");
+                }
+                catch (err) {
+                    if (err.code === "ENOENT") {
+                        throw new Error(`File not found: ${hunk.path}`);
+                    }
+                    throw err;
+                }
+                const newContent = deriveNewContentsFromChunks(originalContent, hunk.chunks, hunk.path);
+                if (hunk.movePath) {
+                    const destPath = path.resolve(cwd, hunk.movePath);
+                    await fs.mkdir(path.dirname(destPath), { recursive: true });
+                    await fs.writeFile(destPath, newContent, "utf-8");
+                    try {
+                        await fs.unlink(targetPath);
+                    }
+                    catch (err) {
+                        if (err.code === "ENOENT") {
+                            exact = false;
+                        }
+                        else {
+                            throw err;
+                        }
+                    }
+                    modified.push(hunk.movePath);
+                }
+                else {
+                    await fs.writeFile(targetPath, newContent, "utf-8");
+                    modified.push(hunk.path);
+                }
+                break;
+            }
+        }
+    }
+    return { affected: { added, modified, deleted }, exact };
+}
+//# sourceMappingURL=apply-patch.js.map