@hheei/pi-apply-patch 0.0.0-stage → 0.1.0

package/dist/apply-patch/presentation.js

@@ -0,0 +1,127 @@
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+import { agentResultText, isRecord, } from "@hheei/pi-ext-core";
+import { createV4aPreviewCursor, previewV4aPatchPrefix } from "./parser.js";
+import { applyPatchResultFacts, applyPatchSummary, formatApplyPatchOperationRow, formatApplyPatchRejectionRows, formatApplyPatchSnapshotRows, } from "./view.js";
+/**
+ * Preview cursors live in this module's own map, keyed by the row's shared render state: the cursor
+ * is display-only progress, so it is never persisted and never read back from the session.
+ */
+const previewCursors = new WeakMap();
+function patchArgument(args) {
+    return isRecord(args) && typeof args.patch === "string" ? args.patch : "";
+}
+function pendingOperation(operation) {
+    return {
+        operationIndex: 0,
+        kind: operation.kind,
+        path: operation.path,
+        addedLines: operation.addedLines,
+        removedLines: operation.removedLines,
+        status: "pending",
+    };
+}
+/**
+ * Incremental preview of the operation headers recognized so far. The cursor belongs to the row, so
+ * one streamed update only reads the lines the previous one had not seen.
+ */
+function previewOperations(patch, context) {
+    const key = typeof context.state === "object" && context.state !== null ? context.state : undefined;
+    const cursor = key === undefined
+        ? createV4aPreviewCursor()
+        : (previewCursors.get(key) ?? createV4aPreviewCursor());
+    const operations = previewV4aPatchPrefix(patch, context.argsComplete === true, cursor);
+    if (key !== undefined)
+        previewCursors.set(key, cursor);
+    return operations.map(pendingOperation);
+}
+function operationRows(operations, theme) {
+    return operations.map((operation) => formatApplyPatchOperationRow(operation, theme));
+}
+/**
+ * The call phase: operation headers recognized in the streamed patch as pending rows. The glyph only
+ * marks a recognized header — it promises neither validation nor application.
+ */
+function callPresentation(args, theme, context, isError) {
+    const patch = patchArgument(args);
+    const operations = previewOperations(patch, context);
+    const rows = operationRows(operations, theme);
+    const files = new Set(operations.map((operation) => operation.path)).size;
+    return {
+        summary: files > 0
+            ? applyPatchSummary(files, operations.reduce((sum, operation) => sum + operation.addedLines, 0), operations.reduce((sum, operation) => sum + operation.removedLines, 0))
+            : "",
+        status: isError ? "error" : "none",
+        ...(rows.length === 0 ? {} : { collapsedRows: rows }),
+        ...(rows.length === 0 ? {} : { sections: [{ railToken: "dim", content: rows }] }),
+        ...(patch === "" ? {} : { copy: { primary: patch } }),
+    };
+}
+function resultStatus(facts, isError, isPartial) {
+    if (facts === undefined)
+        return isError ? "error" : isPartial ? "running" : "ok";
+    if (facts.status === "failed")
+        return "error";
+    if (facts.status === "partial")
+        return "warn";
+    return "none";
+}
+/** Result sections: operation rows, one row block per applied snapshot, then the failure rows. */
+function resultSections(facts, theme) {
+    const sections = [];
+    const rows = operationRows(facts.operations, theme);
+    if (rows.length > 0)
+        sections.push({ railToken: "dim", content: rows });
+    for (const snapshot of facts.snapshots) {
+        const snapshotRows = formatApplyPatchSnapshotRows(snapshot, theme);
+        if (snapshotRows.length > 0)
+            sections.push({ railToken: "dim", content: snapshotRows });
+    }
+    const failures = [
+        ...formatApplyPatchRejectionRows(facts.rejected, "rejected", theme),
+        ...formatApplyPatchRejectionRows(facts.unconfirmed, "unconfirmed", theme),
+        ...formatApplyPatchRejectionRows(facts.notApplied, "not_applied", theme),
+    ];
+    if (failures.length > 0)
+        sections.push({ railToken: "error", content: failures });
+    return sections;
+}
+function copySpec(patch, output) {
+    if (patch === "")
+        return output === "" ? undefined : { primary: output };
+    return output === "" ? { primary: patch } : { primary: patch, full: `${patch}\n---\n${output}` };
+}
+/**
+ * The owned presentation of one apply_patch call or result. Facts come from the executor's
+ * persisted details, never from the current workspace; a result without those details keeps its
+ * model-visible text.
+ */
+export const applyPatchPresentation = (args, result, theme, context) => {
+    const isError = context.isError || result?.isError === true;
+    if (result === undefined)
+        return callPresentation(args, theme, context, isError);
+    const output = stripTerminalSequences(agentResultText(result));
+    const copy = copySpec(patchArgument(args), output);
+    const facts = applyPatchResultFacts(result.details);
+    if (facts === undefined) {
+        return {
+            summary: "",
+            status: resultStatus(facts, isError, context.isPartial),
+            replaceCallOnPartial: true,
+            ...(output === "" ? {} : { output }),
+            ...(output === ""
+                ? {}
+                : { sections: [{ railToken: isError ? "error" : "dim", content: output.split("\n") }] }),
+            ...(copy === undefined ? {} : { copy }),
+        };
+    }
+    const rows = operationRows(facts.operations, theme);
+    return {
+        summary: applyPatchSummary(new Set(facts.changedPaths).size, facts.addedLines, facts.removedLines),
+        status: resultStatus(facts, isError, context.isPartial),
+        replaceCallOnPartial: true,
+        ...(output === "" ? {} : { output }),
+        ...(rows.length === 0 ? {} : { collapsedRows: rows }),
+        sections: resultSections(facts, theme),
+        ...(copy === undefined ? {} : { copy }),
+    };
+};

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

@@ -0,0 +1,5 @@
+import { type SettingsProvider } from "@hheei/pi-ext-core";
+export interface ApplyPatchSettingsProviderOptions {
+    readonly path?: string;
+}
+export declare function createApplyPatchSettingsProvider(options?: ApplyPatchSettingsProviderOptions): SettingsProvider;

package/dist/apply-patch/settings.js

@@ -0,0 +1,33 @@
+import { createJsonSettingsStorage } from "@hheei/pi-ext-core";
+import { APPLY_PATCH_SETTINGS_KEY } from "./policy.js";
+export function createApplyPatchSettingsProvider(options = {}) {
+    return {
+        id: "pi-apply-patch",
+        title: "Apply Patch",
+        origin: "@hheei/pi-apply-patch",
+        description: "Configure Codex V4A apply_patch editing tool parameters.",
+        groups: [
+            {
+                id: APPLY_PATCH_SETTINGS_KEY,
+                title: "",
+                fields: [
+                    {
+                        id: "fuzzFactor",
+                        label: "Context Fuzz Factor",
+                        type: "number",
+                        defaultValue: 0,
+                        description: "Line-edit context tolerance (0 for strict, 2 for relaxed context line matching).",
+                        parse: (value) => Number.parseInt(value, 10),
+                        validate: (value) => value === 0 || value === 2
+                            ? undefined
+                            : "applyPatch.fuzzFactor must be an integer from 0 to 2",
+                    },
+                ],
+            },
+        ],
+        storage: createJsonSettingsStorage({
+            ...(options.path === undefined ? {} : { path: options.path }),
+            group: APPLY_PATCH_SETTINGS_KEY,
+        }),
+    };
+}

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

@@ -0,0 +1,18 @@
+import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { type Static, Type } from "typebox";
+import { type ApplyPatchInWorkspaceResult, type ApplyPatchProgress } from "./index.js";
+export declare const APPLY_PATCH_PARAMETERS: Type.TObject<{
+    patch: Type.TString;
+}>;
+type ApplyPatchParameters = Static<typeof APPLY_PATCH_PARAMETERS>;
+export type ApplyPatchStatus = "success" | "partial" | "failed";
+export interface ApplyPatchToolDetails extends ApplyPatchInWorkspaceResult {
+    readonly status: ApplyPatchStatus;
+    readonly progress?: ApplyPatchProgress;
+}
+export declare function isApplyPatchToolDetails(value: unknown): value is ApplyPatchToolDetails;
+export declare function parseApplyPatchParameters(params: unknown): ApplyPatchParameters;
+export declare function formatApplyPatchResult(result: ApplyPatchInWorkspaceResult): string;
+export declare function createApplyPatchTool(): ToolDefinition<typeof APPLY_PATCH_PARAMETERS, ApplyPatchToolDetails, unknown>;
+export declare function registerApplyPatchTool(pi: ExtensionAPI): ToolDefinition;
+export {};

package/dist/apply-patch/tool.js

@@ -0,0 +1,178 @@
+import { createOptionalToolRenderers, createToolPresentationRenderers, defaultExtensionSettingsPaths, errorMessage, textToolResult, } from "@hheei/pi-ext-core";
+import { Type } from "typebox";
+import { applyPatchInWorkspace, loadApplyPatchPolicy, } from "./index.js";
+import { isPatchPathOutsideWorkspace } from "./paths.js";
+import { applyPatchPresentation } from "./presentation.js";
+const MAX_CANDIDATES = 6;
+const APPLY_PATCH_DESCRIPTION = "Apply a V4A patch to files (32 MiB per file).";
+const APPLY_PATCH_PARAMETER_DESCRIPTION = "One unfenced *** Begin Patch / *** End Patch envelope with Add/Update/Delete File sections. Paths may be absolute or workspace-relative.";
+const APPLY_PATCH_PROMPT_SNIPPET = "Apply related file changes in one V4A patch.";
+const APPLY_PATCH_PROMPT_GUIDELINES = [
+    "apply_patch: use @@ text anchors or *** End of File; pure moves use *** Move to: without a hunk.",
+    "apply_patch: confirmed changes persist after failure or cancellation.",
+];
+export const APPLY_PATCH_PARAMETERS = Type.Object({
+    patch: Type.String({ description: APPLY_PATCH_PARAMETER_DESCRIPTION }),
+}, { additionalProperties: false });
+export function isApplyPatchToolDetails(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        "status" in value &&
+        (value.status === "success" ||
+            value.status === "partial" ||
+            value.status === "failed"));
+}
+export function parseApplyPatchParameters(params) {
+    if (typeof params !== "object" || params === null || Array.isArray(params))
+        throw new Error("apply_patch requires exactly one string parameter: patch");
+    const keys = Object.keys(params);
+    if (keys.length !== 1 || !("patch" in params) || typeof params.patch !== "string")
+        throw new Error("apply_patch requires exactly one string parameter: patch");
+    return { patch: params.patch };
+}
+function statusFor(result) {
+    if (!result.rejected.some((rejection) => rejection.operationIndices.length > 0) &&
+        result.unconfirmed.length === 0 &&
+        result.notApplied.length === 0)
+        return "success";
+    return result.changedPaths.length === 0 ? "failed" : "partial";
+}
+function operationText(index) {
+    return `operation ${index + 1}`;
+}
+function rejectionLines(rejection) {
+    const operation = rejection.operationIndices.map(operationText).join(", ");
+    const path = rejection.paths.join(", ");
+    const prefix = `- ${operation}, ${path}`;
+    if (rejection.diagnostics.length === 0)
+        return [`${prefix}: ${rejection.error}`];
+    return rejection.diagnostics.map((diagnostic) => {
+        switch (diagnostic.kind) {
+            case "context_not_found":
+                return diagnostic.hint !== undefined
+                    ? `${prefix}, hunk ${diagnostic.hunkIndex}: context not found (${diagnostic.hint})`
+                    : `${prefix}, hunk ${diagnostic.hunkIndex}: context not found`;
+            case "ambiguous_exact":
+                return `${prefix}, hunk ${diagnostic.hunkIndex}: exact context is ambiguous at lines ${diagnostic.candidateStartLines
+                    .slice(0, MAX_CANDIDATES)
+                    .join(", ")} (${diagnostic.candidateStartLines.length} candidates)`;
+            default:
+                throw new Error(`Unknown patch diagnostic: ${String(diagnostic)}`);
+        }
+    });
+}
+export function formatApplyPatchResult(result) {
+    const status = statusFor(result);
+    const rejectedHunksByOperation = new Map();
+    for (const rejection of result.rejected)
+        if (rejection.diagnostics.length > 0)
+            for (const operationIndex of rejection.operationIndices)
+                rejectedHunksByOperation.set(operationIndex, (rejectedHunksByOperation.get(operationIndex) ?? 0) + rejection.diagnostics.length);
+    const applied = result.applied.map((operation) => {
+        const path = operation.paths.at(-1) ?? "<unknown>";
+        const rejectedHunks = rejectedHunksByOperation.get(operation.operationIndex) ?? 0;
+        const totalHunks = operation.outcomes.length + rejectedHunks;
+        return `- ${path}: ${operation.kind}${totalHunks === 0 ? "" : ` (${operation.outcomes.length}/${totalHunks} hunks applied)`}`;
+    });
+    const fuzzy = result.applied.flatMap((operation) => operation.outcomes
+        .filter((outcome) => outcome.match === "fuzzy")
+        .map((outcome) => `- ${operation.paths.at(-1) ?? "unknown"}, ${operationText(operation.operationIndex)}, hunk ${outcome.hunkIndex}: lines ${outcome.startLine}-${outcome.startLine + outcome.length - 1}, fuzzy`));
+    const headline = status === "success"
+        ? `Applied patch: ${result.applied.length} operations in ${result.changedPaths.length} files.`
+        : status === "partial"
+            ? "Patch partially applied."
+            : "Patch was not applied.";
+    return [
+        headline,
+        ...(applied.length === 0 ? [] : ["Changed:", ...applied]),
+        ...(fuzzy.length === 0 ? [] : ["Fuzzy-applied:", ...fuzzy]),
+        ...(result.rejected.length === 0
+            ? []
+            : ["Rejected:", ...result.rejected.flatMap(rejectionLines)]),
+        ...(result.unconfirmed.length === 0
+            ? []
+            : ["Unconfirmed:", ...result.unconfirmed.flatMap(rejectionLines)]),
+        ...(result.notApplied.length === 0
+            ? []
+            : ["NotApplied:", ...result.notApplied.flatMap(rejectionLines)]),
+    ].join("\n");
+}
+function externalPathWarning(workspaceRoot, result) {
+    const paths = [
+        ...new Set(result.changedPaths.filter((path) => isPatchPathOutsideWorkspace(workspaceRoot, path))),
+    ];
+    return paths.length === 0
+        ? ""
+        : `\nWarning: changed path outside the workspace: ${paths.join(", ")}`;
+}
+function progressDetails(progress) {
+    return {
+        changedPaths: [],
+        addedLines: progress.addedLines,
+        removedLines: progress.removedLines,
+        operations: progress.operations,
+        operationCount: progress.operations.length,
+        exactUpdateCount: 0,
+        fuzzyUpdateCount: 0,
+        applied: [],
+        rejected: [],
+        unconfirmed: [],
+        notApplied: [],
+        status: "success",
+        progress,
+    };
+}
+export function createApplyPatchTool() {
+    return {
+        name: "apply_patch",
+        label: "apply_patch",
+        description: APPLY_PATCH_DESCRIPTION,
+        parameters: APPLY_PATCH_PARAMETERS,
+        promptSnippet: APPLY_PATCH_PROMPT_SNIPPET,
+        promptGuidelines: APPLY_PATCH_PROMPT_GUIDELINES,
+        executionMode: "sequential",
+        async execute(_toolCallId, params, signal, onUpdate, ctx) {
+            const { patch } = parseApplyPatchParameters(params);
+            try {
+                const policy = await loadApplyPatchPolicy({
+                    paths: defaultExtensionSettingsPaths(ctx.cwd),
+                    ...(signal === undefined ? {} : { signal }),
+                });
+                const result = await applyPatchInWorkspace({
+                    workspaceRoot: ctx.cwd,
+                    patch,
+                    policy,
+                    ...(signal === undefined ? {} : { signal }),
+                    onProgress: (progress) => onUpdate?.({
+                        content: [],
+                        details: progressDetails(progress),
+                    }),
+                });
+                const warning = externalPathWarning(ctx.cwd, result);
+                const status = statusFor(result);
+                const isError = status !== "success";
+                return {
+                    ...textToolResult(`${formatApplyPatchResult(result)}${warning}`, {
+                        ...result,
+                        status,
+                    }),
+                    ...(isError ? { isError: true } : {}),
+                };
+            }
+            catch (error) {
+                const message = errorMessage(error);
+                throw new Error(`apply_patch failed: ${message}`);
+            }
+        },
+    };
+}
+export function registerApplyPatchTool(pi) {
+    const tool = {
+        ...createApplyPatchTool(),
+        ...createOptionalToolRenderers(pi, "apply_patch", createToolPresentationRenderers(pi, "apply_patch", applyPatchPresentation)),
+        defaultActive: false,
+    };
+    pi.registerTool(tool);
+    return tool;
+}

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

@@ -0,0 +1,34 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { ApplyPatchHunkSnapshot, ApplyPatchOperationProgress, ApplyPatchOperationStatus, ApplyPatchRejection } from "./outcome.js";
+/**
+ * Display-side reading of the persisted `apply_patch` details. The details are the contract; a
+ * session written by an older build reaches this module as untrusted JSON, so every field is
+ * narrowed once here and dropped when it does not match.
+ */
+export interface ApplyPatchResultFacts {
+    readonly status: "success" | "partial" | "failed";
+    readonly operations: readonly ApplyPatchOperationProgress[];
+    readonly snapshots: readonly ApplyPatchHunkSnapshot[];
+    readonly rejected: readonly ApplyPatchRejection[];
+    readonly unconfirmed: readonly ApplyPatchRejection[];
+    readonly notApplied: readonly ApplyPatchRejection[];
+    readonly addedLines: number;
+    readonly removedLines: number;
+    readonly changedPaths: readonly string[];
+}
+/** Reads only the persisted `apply_patch` details; other shapes return undefined. */
+export declare function applyPatchResultFacts(details: unknown): ApplyPatchResultFacts | undefined;
+/** How one mutation outcome is drawn. One outcome never draws two symbols across the tools. */
+export declare function applyPatchGlyph(status: string, theme: Theme): string;
+/** The header summary every apply_patch row shares, including nested calls. */
+export declare function applyPatchSummary(files: number, added: number, removed: number): string;
+/** One operation row: glyph, verb, path, delta, fuzzy marker, hunk summary. */
+export declare function formatApplyPatchOperationRow(operation: ApplyPatchOperationProgress, theme: Theme): string;
+/** Rejected, unconfirmed and not-applied rows, each carrying its own outcome glyph. */
+export declare function formatApplyPatchRejectionRows(rejections: readonly ApplyPatchRejection[], status: ApplyPatchOperationStatus, theme: Theme): readonly string[];
+/**
+ * Rows of one applied snapshot: the single-column sign, absolute line number and text the shared
+ * diff body draws. Context rows come from the snapshot's own before/after lines, so no file context
+ * outside the recorded window is invented.
+ */
+export declare function formatApplyPatchSnapshotRows(snapshot: ApplyPatchHunkSnapshot, theme: Theme): readonly string[];

package/dist/apply-patch/view.js

@@ -0,0 +1,256 @@
+import { isRecord } from "@hheei/pi-ext-core";
+import { diffArrays } from "diff";
+import { MUTATION_GLYPH, MUTATION_TONE } from "./glyph.js";
+const OPERATION_STATUSES = new Set([
+    "pending",
+    "applied",
+    "partial",
+    "fuzzy",
+    "unconfirmed",
+    "not_applied",
+    "rejected",
+]);
+function isPatchStatus(value) {
+    return value === "success" || value === "partial" || value === "failed";
+}
+function numberField(source, key) {
+    const value = source[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function stringField(source, key) {
+    const value = source[key];
+    return typeof value === "string" ? value : undefined;
+}
+function stringList(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string")
+        : [];
+}
+function operationView(value) {
+    if (!isRecord(value))
+        return undefined;
+    const path = stringField(value, "path");
+    const kind = value.kind;
+    const status = value.status;
+    if (path === undefined)
+        return undefined;
+    if (kind !== "add" && kind !== "delete" && kind !== "update")
+        return undefined;
+    if (typeof status !== "string" || !OPERATION_STATUSES.has(status))
+        return undefined;
+    const appliedHunks = numberField(value, "appliedHunks");
+    const totalHunks = numberField(value, "totalHunks");
+    const partialReason = stringField(value, "partialReason");
+    return {
+        operationIndex: numberField(value, "operationIndex") ?? 0,
+        kind,
+        path,
+        addedLines: numberField(value, "addedLines") ?? 0,
+        removedLines: numberField(value, "removedLines") ?? 0,
+        status: status,
+        ...(appliedHunks === undefined ? {} : { appliedHunks }),
+        ...(totalHunks === undefined ? {} : { totalHunks }),
+        ...(partialReason === undefined ? {} : { partialReason }),
+    };
+}
+function snapshotView(value) {
+    if (!isRecord(value))
+        return undefined;
+    const path = stringField(value, "path");
+    if (path === undefined)
+        return undefined;
+    const before = value.before;
+    const after = value.after;
+    if (!Array.isArray(before) || !Array.isArray(after))
+        return undefined;
+    const startLine = numberField(value, "startLine");
+    return {
+        path,
+        hunkIndex: numberField(value, "hunkIndex") ?? 0,
+        startLine: startLine !== undefined && startLine > 0 ? startLine : 1,
+        afterStartLine: numberField(value, "afterStartLine") ?? startLine ?? 1,
+        before: before.filter((line) => typeof line === "string"),
+        after: after.filter((line) => typeof line === "string"),
+    };
+}
+function diagnosticView(value) {
+    if (!isRecord(value))
+        return undefined;
+    const hunkIndex = numberField(value, "hunkIndex");
+    if (hunkIndex === undefined)
+        return undefined;
+    switch (value.kind) {
+        case "context_not_found": {
+            const hint = stringField(value, "hint");
+            return { kind: "context_not_found", hunkIndex, ...(hint === undefined ? {} : { hint }) };
+        }
+        case "ambiguous_exact":
+            return {
+                kind: "ambiguous_exact",
+                hunkIndex,
+                candidateStartLines: Array.isArray(value.candidateStartLines)
+                    ? value.candidateStartLines.filter((line) => typeof line === "number")
+                    : [],
+            };
+        default:
+            return undefined;
+    }
+}
+function rejectionView(value) {
+    if (!isRecord(value))
+        return undefined;
+    const error = stringField(value, "error");
+    if (error === undefined)
+        return undefined;
+    const operationIndices = Array.isArray(value.operationIndices)
+        ? value.operationIndices.filter((index) => typeof index === "number")
+        : [];
+    return {
+        operationIndices,
+        paths: stringList(value.paths),
+        error,
+        diagnostics: Array.isArray(value.diagnostics)
+            ? value.diagnostics
+                .map(diagnosticView)
+                .filter((diagnostic) => diagnostic !== undefined)
+            : [],
+    };
+}
+function rejectionList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map(rejectionView)
+        .filter((rejection) => rejection !== undefined);
+}
+/** Applied-operation snapshots, in the executor's operation order. */
+function snapshotList(value) {
+    if (!Array.isArray(value))
+        return [];
+    const snapshots = [];
+    for (const operation of value) {
+        if (!isRecord(operation) || !Array.isArray(operation.snapshots))
+            continue;
+        for (const snapshot of operation.snapshots) {
+            const view = snapshotView(snapshot);
+            if (view !== undefined)
+                snapshots.push(view);
+        }
+    }
+    return snapshots;
+}
+/** Reads only the persisted `apply_patch` details; other shapes return undefined. */
+export function applyPatchResultFacts(details) {
+    if (!isRecord(details) || !isPatchStatus(details.status))
+        return undefined;
+    return {
+        status: details.status,
+        operations: Array.isArray(details.operations)
+            ? details.operations
+                .map(operationView)
+                .filter((operation) => operation !== undefined)
+            : [],
+        snapshots: snapshotList(details.applied),
+        rejected: rejectionList(details.rejected),
+        unconfirmed: rejectionList(details.unconfirmed),
+        notApplied: rejectionList(details.notApplied),
+        addedLines: numberField(details, "addedLines") ?? 0,
+        removedLines: numberField(details, "removedLines") ?? 0,
+        changedPaths: stringList(details.changedPaths),
+    };
+}
+/** How one mutation outcome is drawn. One outcome never draws two symbols across the tools. */
+export function applyPatchGlyph(status, theme) {
+    const glyph = MUTATION_GLYPH[status] ?? "✗";
+    const tone = MUTATION_TONE[status] ?? "error";
+    return theme.fg(tone, glyph);
+}
+/** The header summary every apply_patch row shares, including nested calls. */
+export function applyPatchSummary(files, added, removed) {
+    return `modify ${String(files)}${files === 1 ? " file" : " files"} (+${String(added)} -${String(removed)})`;
+}
+/** One operation row: glyph, verb, path, delta, fuzzy marker, hunk summary. */
+export function formatApplyPatchOperationRow(operation, theme) {
+    const glyph = applyPatchGlyph(operation.status, theme);
+    const kind = operation.kind === "add" ? "create" : operation.kind === "delete" ? "delete" : "modify";
+    const path = operation.path;
+    const deltaParts = [];
+    if (operation.addedLines > 0)
+        deltaParts.push(theme.fg("success", `+${String(operation.addedLines)}`));
+    if (operation.removedLines > 0)
+        deltaParts.push(theme.fg("error", `-${String(operation.removedLines)}`));
+    const delta = deltaParts.length > 0 ? ` (${deltaParts.join(" ")})` : "";
+    const score = operation.status === "fuzzy" ? ` ${theme.fg("dim", "fuzzy")}` : "";
+    const hunks = operation.status === "partial" &&
+        operation.appliedHunks !== undefined &&
+        operation.totalHunks !== undefined
+        ? ` ${theme.fg("dim", `(${String(operation.appliedHunks)}/${String(operation.totalHunks)} hunks applied${operation.partialReason === undefined ? "" : `; ${operation.partialReason}`})`)}`
+        : "";
+    return `${glyph} ${theme.fg("toolTitle", kind)} ${path}${delta}${score}${hunks}`.trimEnd();
+}
+function diagnosticText(diagnostic) {
+    switch (diagnostic.kind) {
+        case "context_not_found":
+            return diagnostic.hint === undefined
+                ? "context not found"
+                : `context not found (${diagnostic.hint})`;
+        case "ambiguous_exact":
+            return `exact context is ambiguous at lines ${diagnostic.candidateStartLines.join(", ")}`;
+        default:
+            return "context not applied";
+    }
+}
+/** Rejected, unconfirmed and not-applied rows, each carrying its own outcome glyph. */
+export function formatApplyPatchRejectionRows(rejections, status, theme) {
+    const rows = [];
+    for (const rejection of rejections) {
+        const prefix = `${applyPatchGlyph(status, theme)} ${rejection.paths[0] ?? "<unknown>"} · `;
+        if (rejection.diagnostics.length === 0) {
+            rows.push(`${prefix}${rejection.error}`);
+            continue;
+        }
+        for (const diagnostic of rejection.diagnostics) {
+            rows.push(`${prefix}${diagnosticText(diagnostic)}`);
+        }
+    }
+    return rows;
+}
+/**
+ * Rows of one applied snapshot: the single-column sign, absolute line number and text the shared
+ * diff body draws. Context rows come from the snapshot's own before/after lines, so no file context
+ * outside the recorded window is invented.
+ */
+export function formatApplyPatchSnapshotRows(snapshot, theme) {
+    const lines = snapshotLines(snapshot);
+    if (lines.length === 0)
+        return [];
+    const numberWidth = Math.max(2, ...lines.map((line) => String(line.line).length));
+    const rows = lines.map((line) => `${theme.fg(line.tone, `${line.sign}${String(line.line).padStart(numberWidth)} ${line.text}`)}`);
+    return rows;
+}
+/** Line LCS of one stored before/after window, numbered from the snapshot's own start lines. */
+function snapshotLines(snapshot) {
+    if (snapshot.before.length === 0 && snapshot.after.length === 0)
+        return [];
+    const rows = [];
+    let oldLine = snapshot.startLine;
+    let newLine = snapshot.afterStartLine;
+    for (const part of diffArrays([...snapshot.before], [...snapshot.after])) {
+        for (const text of part.value) {
+            if (part.added === true) {
+                rows.push({ sign: "+", tone: "success", line: newLine, text });
+                newLine += 1;
+            }
+            else if (part.removed === true) {
+                rows.push({ sign: "-", tone: "error", line: oldLine, text });
+                oldLine += 1;
+            }
+            else {
+                rows.push({ sign: " ", tone: "dim", line: newLine, text });
+                oldLine += 1;
+                newLine += 1;
+            }
+        }
+    }
+    return rows;
+}

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

@@ -0,0 +1 @@
+export * from "./apply-patch/tool.js";

package/dist/apply-patch-tool.js

@@ -0,0 +1 @@
+export * from "./apply-patch/tool.js";

package/dist/extension.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export default function piApplyPatchExtension(pi: ExtensionAPI): void;