dsh-hashline-edit 0.2.0 → 0.2.2

package/src/write-hook.ts

@@ -0,0 +1,130 @@
+/**
+ * SAFETY: Guard + auto-read seam around `write`: the `tool_call` listener refuses
+ * reproduced served rows before they can reach disk.
+ * Ported from dsh@0.4.1 `src/write-hook.ts` adapted to pi's FileIO/session view.
+ * @module pi-better-edit/write-hook
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { abortIf, splitLines } from "./utils.js";
+import { resolveTarget } from "./fs-write.js";
+import { toCwd } from "./paths.js";
+import { createSessionHandle, sessionKeyFor } from "./served-session/session.js";
+import {
+  findServedHashEcho,
+  buildServedWriteMessage,
+  trackServedWriteRefusal,
+} from "./served-session/serve-render.js";
+import { reportDiagnostic } from "./diagnostics.js";
+
+export { findServedHashEcho };
+
+export interface WriteHookIO {
+  resolve(path: string, cwd: string, signal?: AbortSignal): Promise<string>;
+}
+
+/**
+ * SAFETY: Inspect one validated-looking built-in write request against session-scoped
+ * served state. Returns a pre-dispatch denial reason only with evidence: the
+ * candidate begins with a served anchor at any position AND reproduces the
+ * served content for that anchor (GLOSSARY.md served hash echo). No canon data
+ * means no evidence, so the check stays silent — never a shape refusal.
+ */
+export async function servedHashEchoDenial(
+  io: WriteHookIO | null | undefined,
+  rawPath: string,
+  content: string,
+  cwd: string,
+  sessionKey: string,
+  signal?: AbortSignal,
+  mode: "general" | "literal" = "general",
+): Promise<string | undefined> {
+  abortIf(signal);
+  if (mode === "literal") return undefined;
+  let absolutePath: string;
+  if (io && typeof (io as WriteHookIO).resolve === "function") {
+    absolutePath = await (io as WriteHookIO).resolve(rawPath, cwd, signal);
+  } else {
+    absolutePath = await resolveTarget(toCwd(rawPath, cwd));
+  }
+  abortIf(signal);
+  const handle = createSessionHandle(sessionKey, absolutePath);
+  const served = await handle.load();
+  let canonDigests: (string | null)[] = [];
+  try {
+    canonDigests = await handle.loadCanonDigests();
+  } catch (error) {
+    reportDiagnostic("write-hook", "Failed to load served canon digests for write:", error);
+    canonDigests = [];
+  }
+  const lines = splitLines(content);
+  const reproduction = findServedHashEcho(lines, served, canonDigests, 1);
+  if (!reproduction) return undefined;
+  const offendingLine = lines[reproduction.k - 1] ?? "";
+  // WHY: verification side of the tally: this refusal runs pre-dispatch, so no bytes move
+  // WHY: and no clear is due — the clear belongs to the committed write, which re-serves
+  // WHY: the file (`lifecycle-hooks` post-write), never to this gate.
+  const count = trackServedWriteRefusal(sessionKey, absolutePath, offendingLine);
+  return buildServedWriteMessage({
+    path: rawPath,
+    line: reproduction.line,
+    hash: reproduction.hash,
+    servedLine: reproduction.servedLine,
+    count,
+  });
+}
+
+/**
+ * SAFETY: Register the pre-write served hash echo guard on the calling extension's scope.
+ * The guard denies before dispatch; infrastructure failures fail open so the
+ * plugin never breaks an otherwise valid write.
+ */
+export function registerWriteHook(pi: ExtensionAPI): void {
+  pi.on("tool_call", async (event, ctx) => {
+    if (event.toolName !== "write") return;
+    const input = event.input as Record<string, unknown> | undefined;
+    const rawPath = input?.path as unknown;
+    const content = input?.content as unknown;
+    if (typeof rawPath !== "string" || typeof content !== "string") return;
+    // WHY: pi's builtin `write` schema tolerates the extra top-level `mode` field
+    // WHY: (verified with TypeBox `Compile`: an additional `mode?: "general" | "literal"`
+    // WHY: property passes `additionalProperties` handling on the builtin schema, so the
+    // WHY: literal declaration rides the same input object with no schema change).
+    const modeValue = (input as Record<string, unknown>)?.mode;
+    const mode: "general" | "literal" = modeValue === "literal" ? "literal" : "general";
+
+    const cwd = ctx.cwd;
+    // SAFETY: ExtensionAPI ctx carries sessionManager at runtime; cast narrows to sessionKeyFor's expected shape which is validated by sessionKeyFor's internal guards.
+    const sessionKey = sessionKeyFor(
+      ctx as unknown as { sessionManager?: { getSessionId(): string } },
+    );
+    const signal = ctx.signal;
+    try {
+      const io: WriteHookIO = {
+        resolve: async (p: string, c: string, sig?: AbortSignal) => {
+          abortIf(sig);
+          return resolveTarget(toCwd(p, c));
+        },
+      };
+      const reason = await servedHashEchoDenial(
+        io,
+        rawPath,
+        content,
+        cwd,
+        sessionKey,
+        signal,
+        mode,
+      );
+      if (reason !== undefined) {
+        return { block: true, reason };
+      }
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      reportDiagnostic(
+        "write-hook",
+        `pi-better-edit: pre-write served hash guard failed open: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+    return;
+  });
+}

package/lib/types/dsh/hide.d.ts

@@ -1,78 +0,0 @@
-/**
- * Hide the native edit-class tools so every precise text change goes through
- * `apply_patch` — the one mutation entry point of the v4 surface.
- *
- * DSH 0.2.2-alpha.3 owns tool declarations in the tool registry, not in the
- * `system-prompt/assemble` waterfall: the waterfall receives sections, contexts
- * and variables only. The authoritative schema filter is therefore the
- * per-agent registry restriction (`tools.restrict({ deny })`), which removes a
- * global tool from both the native schema list and the PTC `tools:sdk` section
- * because both are rendered from `tools.definitions(scope, toolSet)`.
- *
- * Three seams still back that up, because a restriction only governs the
- * registry view and a stale session or a hand-rolled section could carry a
- * residual binding:
- *
- * 1. `tools.restrict({ deny })` drops the hidden schemas for this agent;
- * 2. `system-prompt/assemble` empties the `tool:edit` guidance section (its
- *    text is prose, never a tool mention) and deletes the hidden tools' member
- *    blocks from any rendered PTC `tools:sdk` section;
- * 3. `tools.guard` is the monotonic execution backstop for a stale schema or
- *    any residual binding.
- *
- * `write` stays visible on purpose: whole-file replacement has no operation in
- * `apply_patch` (`*** Add File:` refuses to overwrite), so hiding it would leave
- * a rewrite with nowhere to go. Callers that want it gone can list it in
- * `hiddenToolNames`.
- *
- * The layer is installed only when `apply_patch` actually registered: hiding
- * the native editors while owning no replacement would leave the profile with
- * no way to change a file.
- *
- * @module dsh-hashline-edit/hide
- */
-/** A boolean config value, or a live getter (used when a host exposes volatile config). */
-type BooleanSource = boolean | (() => boolean);
-/** The hide-layer configuration after the plugin-level defaults are applied. */
-export interface NativeHideConfig {
-    /** The registered replacement tool name, protected from `hiddenToolNames`. */
-    readonly toolName: string;
-    /** Hide `edit`/`str_replace_editor`; defaults to true. */
-    readonly hideNativeWriteTools?: BooleanSource;
-    /** Extra global tool names to hide alongside the native set. */
-    readonly hiddenToolNames?: readonly string[];
-    /** The Agent scope key used for the agent-view probe; absent keeps the global probe. */
-    readonly scope?: unknown;
-}
-/**
- * Delete the hidden tools' member blocks from one rendered `tools:sdk` text.
- *
- * Structural, renderer-specific parsing — never a mention match:
- * - TypeScript: a member starts at `  name: type` (2-space indent) inside
- *   `ToolArgsMap`/`ToolOutputMap`, may open braces on the same line, and ends
- *   at the first line that closes every opened brace and ends with `;`. Its
- *   optional single-line JSDoc comment directly above goes with it.
- * - Python: a `Tools` protocol member starts at an indented `async def` line
- *   and spans until the next line at that member indent or shallower.
- * @param text - the rendered SDK section text.
- * @param hidden - the tool names to remove.
- * @returns the text with every hidden member block removed.
- */
-export declare function stripSdkMembers(text: string, hidden: ReadonlySet<string>): string;
-interface LoggerLike {
-    warn?(message: string): void;
-}
-declare function warn(rootCtx: {
-    logger?: LoggerLike;
-}, message: string): void;
-/**
- * Install the hide layer for one agent. Only call this after `apply_patch`
- * registered successfully.
- *
- * @param rootCtx - the plugin/root scope, used for the global-name probe and warnings.
- * @param agentCtx - the agent scope whose tool view is restricted.
- * @param config - the resolved hide configuration.
- * @returns the exact disposer; disposing lifts the restriction and every listener.
- */
-export declare function registerNativeToolHiding(rootCtx: Parameters<typeof warn>[0], agentCtx: unknown, config: NativeHideConfig): () => void;
-export {};

package/lib/types/dsh/tools/apply-patch.d.ts

@@ -1,38 +0,0 @@
-import type { FileDiff, ToolDefinition } from "@deepseek-ai/dsh-tools";
-import { APPLY_PATCH_TOOL_NAME } from "../../src/apply-patch/tool.js";
-import type { ApplyPatchTool } from "../../src/apply-patch/tool.js";
-/** Public tool name re-exported for host registration and surface tests. */
-export { APPLY_PATCH_TOOL_NAME };
-import type { ToolDependencies } from "../contracts.js";
-/** One call's intended file diffs, parsed from the patch headers for the pending card. */
-interface PatchPreview {
-    readonly diffs: FileDiff[];
-    readonly locations: string[];
-}
-/**
- * Scan the patch headers for the pending card. This is a presentation-only
- * projection: it never decides whether the patch is valid (the grammar and
- * planner do), and it never throws on malformed text.
- * @param input - the raw patch text.
- * @returns the intended additions and every path the patch names.
- */
-export declare function previewPatch(input: string): PatchPreview;
-/** Every path this patch writes, including a Cut From source; Copy From sources are read-only. */
-export declare function writtenPatchPaths(input: string): string[];
-/** Options for {@link buildApplyPatchTool}; the factory seam is for tests. */
-export interface ApplyPatchToolOptions {
-    /** Test seam: build the use case without touching the real engine/store. */
-    readonly create?: () => ApplyPatchTool;
-}
-/**
- * Build the dsh 'apply_patch' tool for one agent install.
- *
- * The use case is created lazily: building a tool definition must not touch the
- * engine or the store, and a composition where 'apply_patch' is skipped must
- * still install the rest of the toolset.
- *
- * @param deps - the host seams this tool may touch; 'sandbox' advertises and resolves escalation.
- * @param options - test seam for the use case.
- * @returns a registry-ready dsh tool definition named 'apply_patch'.
- */
-export declare function buildApplyPatchTool(deps: ToolDependencies, options?: ApplyPatchToolOptions): ToolDefinition;

package/lib/types/src/apply-patch/commit.d.ts

@@ -1,49 +0,0 @@
-import type { HashStore } from "../hash-store.js";
-import type { ApplyPatchFailure, PatchPlan, ServedFileBlock } from "./types.js";
-/** Options for {@link commitPlan}. */
-export interface CommitPlanOptions {
-    readonly cwd: string;
-    readonly sessionKey: string;
-    readonly signal?: AbortSignal;
-    readonly store?: HashStore;
-    /** POSIX access-mode bitmask; defaults to read+write. */
-    readonly accessMode?: number;
-    /** TEST-ONLY: fires before the first rename, while the pre-images/undo rows are durable. */
-    readonly onBeforeFirstWrite?: () => void | Promise<void>;
-    /** TEST-ONLY: fires between two member renames, after the earlier one is durable. */
-    readonly onBetweenWrites?: (committedAbsolutePath: string) => void | Promise<void>;
-    /** TEST-ONLY: fires after a move rename and before the destination rewrite (mid-member failure). */
-    readonly onAfterMoveRename?: (toAbsolutePath: string) => void | Promise<void>;
-}
-/** One committed file's lifecycle status and line accounting. */
-export interface CommittedFile {
-    readonly path: string;
-    readonly status: "A" | "M" | "R" | "D";
-    /** Original path for a rename (`R` only). */
-    readonly fromPath?: string;
-    readonly addedLines: number;
-    readonly removedLines: number;
-    /** New anchors for the changed lines; absent when the member wrote no content. */
-    readonly served?: ServedFileBlock;
-}
-/** Commit outcome: the per-file facts on success, the whole failure on rejection. */
-export type CommitPlanResult = {
-    readonly ok: true;
-    readonly files: readonly CommittedFile[];
-    readonly diff: string;
-    readonly warnings: readonly string[];
-} | {
-    readonly ok: false;
-    readonly failure: ApplyPatchFailure;
-};
-/**
- * Commit one plan atomically (one correlated transaction, one undo record set).
- *
- * The implementation reuses `commitTransaction` — the existing correlated skeleton — and extends
- * its member shape with the plan's lifecycle action; the undo schema gains the matching action.
- *
- * @param plan - the fully resolved plan.
- * @param options - cwd/session/store, cancellation and the test fault seams.
- * @returns the committed facts, or a failure whose `changedNothing` reflects the rollback.
- */
-export declare function commitPlan(plan: PatchPlan, options: CommitPlanOptions): Promise<CommitPlanResult>;

package/lib/types/src/apply-patch/grammar.d.ts

@@ -1,29 +0,0 @@
-import type { AnchorSpan, ParsePatchResult } from "./types.js";
-/** Hard cap on one patch input (bytes), mirroring the host request budget. */
-export declare const PATCH_MAX_BYTES: number;
-/** Options for {@link parseApplyPatch}. */
-export interface ParsePatchOptions {
-    /** Maximum accepted input size in bytes; defaults to {@link PATCH_MAX_BYTES}. */
-    readonly maxBytes?: number;
-}
-/**
- * Parse one patch document.
- *
- * Success returns the AST defined in `types.ts`; failure returns every syntax
- * problem the parser could diagnose in one pass (never a throw for malformed
- * user input). Rejections use `E_PATCH_SYNTAX` with the offending patch line.
- *
- * @param input - the raw `*** Begin Patch` … `*** End Patch` text.
- * @param options - size guard knobs.
- * @returns the parsed document or the collected problems.
- */
-export declare function parseApplyPatch(input: string, options?: ParsePatchOptions): ParsePatchResult;
-/**
- * Parse an anchor token: `<a>` (single line) or `<a>-<b>` (closed span).
- * Returns `undefined` when the token is not a valid four-character anchor pair; the
- * grammar layer turns that into an `E_PATCH_SYNTAX` problem at the patch line.
- *
- * @param token - the text after `@@` (no leading space).
- * @returns the closed span, or undefined for a malformed token.
- */
-export declare function parseAnchorSpan(token: string): AnchorSpan | undefined;

package/lib/types/src/apply-patch/lifecycle.d.ts

@@ -1,32 +0,0 @@
-import { type HashStore } from "../hash-store.js";
-import type { ProcessedEditFile } from "../mutation-engine/types.js";
-import type { PatchPath, PlannedFile } from "./types.js";
-/**
- * apply_patch lifecycle materialization — the plan-to-engine adapter.
- *
- * The planner resolves every mutation against a pre-call baseline; this module turns that plan
- * into the mutation engine's `ProcessedEditFile` member shape (plus the engine-local lifecycle
- * action). It never writes: the correlated transaction in `mutation-engine/pipeline.ts` owns the
- * one commit path. Pure text application (splice at baseline coordinates) is the only work here,
- * and the resulting anchors are always derived under the member's COMMITTED path.
- *
- * @module dsh-hashline-edit/apply-patch/lifecycle
- */
-/** One materialized member: the plan facts plus the engine member the commit consumes. */
-export interface MaterializedMember {
-    readonly planned: PlannedFile;
-    readonly member: ProcessedEditFile;
-    readonly status: "A" | "M" | "R" | "D";
-    /** The committed display path (destination for a move; the pre path otherwise). */
-    readonly committedPath: PatchPath;
-    /** The pre-transaction display path (move only). */
-    readonly fromPath?: PatchPath;
-}
-/**
- * Materialize one planned file into the engine's member shape.
- *
- * The result text is produced by applying the plan's baseline-coordinate mutations; the anchors
- * are then derived under the committed path. No file is read or written here — the plan already
- * carries every baseline byte the commit needs.
- */
-export declare function materializeMember(planned: PlannedFile, store?: HashStore): Promise<MaterializedMember>;

package/lib/types/src/apply-patch/plan.d.ts

@@ -1,50 +0,0 @@
-import type { LeaseSpanSource } from "../hashline/resolve.js";
-import { type HashStore } from "../hash-store.js";
-import { type ServedAnchors } from "./resolve.js";
-import type { ApplyPatchEngineOptions, FileBaseline, PatchDocument, PatchPath, PlannedMutation, PlanPatchResult } from "./types.js";
-/**
- * The baseline/served loader port.
- *
- * Production wires `readBaseline` to the file-content decode path,
- * `readServed` to `createSessionHandle(...).load()` and `readLeaseSource` to
- * the read-only lease identity source. Tests inject a pure in-memory
- * implementation, which is what makes the planner testable without a store.
- */
-export interface PlanFileLoader {
-    /** Load one file's baseline (LF-normalized text + anchors + BOM + ending). */
-    readBaseline(path: PatchPath, absolutePath: string, signal?: AbortSignal): Promise<FileBaseline>;
-    /** Load this session's served anchors for one file, parallel to its lines. */
-    readServed(absolutePath: string, sessionKey: string, store?: HashStore): Promise<ServedAnchors>;
-    /** Session-wide anchor homes, for foreign-anchor diagnosis (optional legacy port). */
-    anchorHomes?(anchor: string, sessionKey: string, store?: HashStore): readonly PatchPath[];
-    /** Build the read-only lease identity source for one file's baseline content. */
-    readLeaseSource?(absolutePath: string, sessionKey: string, content: string, store?: HashStore): Promise<LeaseSpanSource>;
-}
-/** Options for {@link planApplyPatch}; `loader` is the test seam. */
-export interface PlanApplyPatchOptions extends ApplyPatchEngineOptions {
-    readonly loader?: PlanFileLoader;
-}
-/** A baseline for a file that does not exist yet (Add File / missing target). */
-export declare function absentBaseline(path: PatchPath, absolutePath: string): FileBaseline;
-/** The production loader over node:fs, the file-content decoder and the hash store. */
-export declare function createDefaultPlanFileLoader(): PlanFileLoader;
-/** Apply resolved baseline-coordinate mutations to a line array (descending, so coordinates stay valid). */
-export declare function applyPlannedMutations(lines: readonly string[], mutations: readonly PlannedMutation[]): string[];
-export declare function mutationDelta(baselineLines: readonly string[], mutation: PlannedMutation): {
-    added: number;
-    removed: number;
-};
-/**
- * Plan one apply_patch call without writing anything.
- *
- * All hunks resolve against the pre-call baseline (never chained application);
- * a later hunk's fragment window begins after the previous hunk's end. Any
- * problem aborts the whole call: the returned list is every independently
- * diagnosable problem, not just the first, together with the current rows of
- * every named file (reject-and-serve).
- *
- * @param document - the parsed patch AST.
- * @param options - cwd/session/store plus the optional baseline loader.
- * @returns the plan, or every problem found plus the rows to serve.
- */
-export declare function planApplyPatch(document: PatchDocument, options: PlanApplyPatchOptions): Promise<PlanPatchResult>;

package/lib/types/src/apply-patch/render.d.ts

@@ -1,51 +0,0 @@
-/**
- * apply_patch v4 — renderer.
- *
- * One renderer owns both surfaces:
- *
- * - success: file-level summary lines first (`A`/`M`/`R`/`D`), then the
- *   changed-line anchor rows (`HASH│content`) per file, so a second call needs
- *   no `read`;
- * - rejection: every problem as `- patch line N ([E_*], path): message`,
- *   followed by each problem file's current rows.
- *
- * @module dsh-hashline-edit/apply-patch/render
- */
-import type { ApplyPatchFailure, ApplyPatchResult, ApplyPatchSuccess, ApplyPatchToolResult, AppliedFileSummary, PatchProblem, ServedFileBlock } from "./types.js";
-/**
- * Render one apply_patch outcome into the model-facing tool envelope.
- * @param result - the committed success or the collected rejection.
- * @returns `{ content, details }` ready for the dsh tool registry.
- */
-export declare function renderApplyPatchResult(result: ApplyPatchResult): ApplyPatchToolResult;
-/**
- * Render a successful outcome.
- * @param success - committed file facts plus new anchor rows.
- * @returns the model-facing envelope.
- */
-export declare function renderSuccess(success: ApplyPatchSuccess): ApplyPatchToolResult;
-/**
- * Render a rejected outcome: all problems first, then the served rows.
- * @param failure - the collected problems and current rows.
- * @returns the model-facing envelope (as an `isError` tool result at the host seam).
- */
-export declare function renderFailure(failure: ApplyPatchFailure): ApplyPatchToolResult;
-/**
- * Render the file-level summary block: `Updated N files:` then one status line
- * per file (`R src/old.ts -> src/new.ts` for a rename).
- * @param files - the committed file summaries.
- * @returns the summary text.
- */
-export declare function renderFileSummary(files: readonly AppliedFileSummary[]): string;
-/**
- * Render the new-anchor blocks for every changed file.
- * @param blocks - per-file served rows.
- * @returns one `<path>\nHASH│content` section per block.
- */
-export declare function renderServedBlocks(blocks: readonly ServedFileBlock[]): string;
-/**
- * Render one problem line: `- patch line N ([E_*], path): message`.
- * @param problem - one collected problem.
- * @returns the single-line rendering, without a trailing newline.
- */
-export declare function formatPatchProblem(problem: PatchProblem): string;

package/lib/types/src/apply-patch/resolve.d.ts

@@ -1,129 +0,0 @@
-/**
- * apply_patch v4 — resolution layer.
- *
- * Two addressing families meet here:
- *
- * - **fragment mode** is content matching against the pre-call baseline. The
- *   `oldLines` sequence (' ' and '-' lines) must match exactly one place in the
- *   hunk's window; `@@ <context>` must itself match exactly one line and moves
- *   the window start after it. Zero or multiple hits reject with candidate rows.
- * - **identity mode** is served-lease addressing. Both anchors must belong to
- *   the `(session, file, anchor)` served set; a missing, retired or foreign
- *   anchor rejects with the file's current rows served back.
- *
- * The layer is pure over `FileBaseline` + served anchors: no I/O, no store
- * access. `plan.ts` supplies the baselines and the lease source.
- *
- * @module dsh-hashline-edit/apply-patch/resolve
- */
-import { type LeaseSpanSource } from "../hashline/resolve.js";
-import type { Anchor, FileBaseline, FragmentHunk, IdentityHunk, LineRange, PatchCandidate, PatchPath, PatchProblem, PlannedMutation, PlannedReferenceUse, ReferenceHunk } from "./types.js";
-/** A file's served anchors, parallel to its baseline lines; `null` = never served. */
-export type ServedAnchors = readonly (string | null)[];
-/** The inputs one hunk resolution reads. */
-export interface ResolveContext {
-    readonly baseline: FileBaseline;
-    readonly served: ServedAnchors;
-    /**
-     * Read-only lease identity source for identity mode. When present it is
-     * authoritative (MVCC lease identity, including rebasing); the `served`
-     * mirror is only the fallback for tests/callers with no store lease view.
-     */
-    readonly identity?: LeaseSpanSource;
-    /**
-     * Session-wide anchor homes — other files that served this anchor. Used only
-     * to diagnose a foreign anchor; a cross-file anchor is refused either way.
-     */
-    readonly homesOf?: (anchor: Anchor) => readonly PatchPath[];
-}
-/** A successful fragment match in baseline coordinates. */
-export interface FragmentMatch {
-    /** Inclusive range covering the hunk's oldLines (' ' + '-'); zero-width when oldLines is empty. */
-    readonly range: LineRange;
-    /** 1-based line where the search window began (after `@@ <context>`, else 1). */
-    readonly windowStart: number;
-}
-/** Fragment match failure: no occurrence or more than one, with candidate rows. */
-export type FragmentMatchResult = {
-    readonly ok: true;
-    readonly match: FragmentMatch;
-} | {
-    readonly ok: false;
-    readonly reason: "no-match" | "ambiguous";
-    readonly candidates: readonly PatchCandidate[];
-};
-/** Identity resolution outcome. */
-export type IdentityResolveResult = {
-    readonly ok: true;
-    readonly range: LineRange;
-} | {
-    readonly ok: false;
-    readonly problems: readonly PatchProblem[];
-};
-/** Reference resolution outcome. */
-export type ReferenceResolveResult = {
-    readonly ok: true;
-    readonly reference: PlannedReferenceUse;
-    /** The destination replacement this reference materializes. */
-    readonly mutation: PlannedMutation;
-} | {
-    readonly ok: false;
-    readonly problems: readonly PatchProblem[];
-};
-/** The baseline's lines; an empty file is zero lines, never one empty line. */
-export declare function baselineLinesOf(baseline: FileBaseline): string[];
-/**
- * Match one fragment hunk against its baseline.
- *
- * Byte-exact: no whitespace, Unicode or newline normalization. The window is
- * `[windowStart, end]` and every subsequent hunk's window begins after the
- * previous hunk's end (the planner enforces the monotonic cursor).
- *
- * @param hunk - the parsed fragment hunk.
- * @param context - baseline plus served anchors (served is unused here; kept for one call shape).
- * @param windowStart - 1-based line the search starts at; defaults to 1.
- * @returns the unique match or the rejection with candidates.
- */
-export declare function matchFragmentHunk(hunk: FragmentHunk, context: ResolveContext, windowStart?: number): FragmentMatchResult;
-/**
- * Resolve one identity hunk (`@@<a>` / `@@<a>-<b>`) against the served set.
- *
- * The anchors must be present in `context.served` at exactly one position each
- * (or hold a live lease when `context.identity` is present), `from` not after
- * `to`. Every failure uses `E_STALE_ANCHOR` with the anchor named, so the
- * planner can serve the file's current rows for a retry.
- *
- * @param hunk - the parsed identity hunk.
- * @param context - baseline plus served anchors / lease source.
- * @returns the resolved inclusive range, or all problems for this hunk.
- */
-export declare function resolveIdentityHunk(hunk: IdentityHunk, context: ResolveContext): IdentityResolveResult;
-/**
- * Resolve one `*** Copy From:` / `*** Cut From:` hunk.
- *
- * The target addressing must be identity mode (`@@<a>` / `@@<a>-<b>`): a
- * fragment-mode reference hunk is refused with `E_PATCH_SYNTAX` at the
- * reference line. The source span must be served for the declared source file;
- * the destination is replaced by the source bytes. A `cut` also plans the
- * source retirement, in the same transaction, as a deletion over the same
- * anchors.
- *
- * @param hunk - the parsed reference hunk.
- * @param destination - the target file's baseline + served anchors / lease source.
- * @param source - the source file's baseline + served anchors / lease source.
- * @returns the materialized reference and destination mutation, or the problems.
- */
-export declare function resolveReferenceHunk(hunk: ReferenceHunk, destination: ResolveContext, source: ResolveContext | FileBaseline, sourceServed?: ServedAnchors): ReferenceResolveResult;
-/**
- * Check one file's resolved mutations for overlap.
- *
- * Two mutations whose target ranges intersect reject the whole call with
- * `E_BATCH_ABORT`-shaped evidence (both patch lines named). Zero-width
- * insertions at the same point are ordered by submission, not treated as
- * overlap; every other intersection is a rejection.
- *
- * @param mutations - one file's mutations, in submission order.
- * @param path - the target file for the problem's path field.
- * @returns every overlap problem found (empty when disjoint).
- */
-export declare function checkMutationOverlaps(mutations: readonly PlannedMutation[], path?: PatchPath): readonly PatchProblem[];

package/lib/types/src/apply-patch/tool.d.ts

@@ -1,54 +0,0 @@
-/**
- * apply_patch v4 — tool use case.
- *
- * The deep module the dsh host adapter calls. One `execute` owns the whole pipeline for one call:
- *
- *   grammar.parseApplyPatch → plan.planApplyPatch → commit.commitPlan → render
- *
- * and returns the model-facing `{ content, details }` envelope. A rejection carries the rendered
- * `[E_*]` envelope and is marked `isError`; nothing was written because plan/grammar own every
- * pre-commit check and commit rolls back or reports its recovery report.
- *
- * The orchestration deps are injectable so the transaction lane can test the complete
- * parse→plan→commit→render path before the grammar/resolve lanes merge into this branch.
- *
- * @module dsh-hashline-edit/apply-patch/tool
- */
-import { parseApplyPatch, type ParsePatchOptions } from "./grammar.js";
-import { planApplyPatch, type PlanApplyPatchOptions } from "./plan.js";
-import { type CommitPlanOptions, type CommitPlanResult } from "./commit.js";
-import { renderFailure, renderSuccess } from "./render.js";
-import type { ApplyPatchContext, ApplyPatchToolResult, PatchPlan, PlanPatchResult } from "./types.js";
-/** The registered tool name; `apply_patch` is the only mutation entry point. */
-export declare const APPLY_PATCH_TOOL_NAME = "apply_patch";
-/** The use-case seam: one narrow interface over the pipeline. */
-export interface ApplyPatchTool {
-    /**
-     * Execute one apply_patch call.
-     * @param input - the raw patch text.
-     * @param ctx - live cwd, session identity and cancellation.
-     * @returns the model-facing envelope; `isError` marks a rejection (nothing written).
-     */
-    execute(input: string, ctx: ApplyPatchContext): Promise<ApplyPatchToolResult>;
-    /**
-     * Parse + plan without writing, for previews and tests.
-     * @param input - the raw patch text.
-     * @param ctx - live cwd, session identity and cancellation.
-     * @returns the plan or every collected problem.
-     */
-    plan(input: string, ctx: ApplyPatchContext): Promise<PlanPatchResult>;
-}
-/** The injectable seams of the pipeline; production uses the real modules. */
-export interface ApplyPatchToolDeps {
-    readonly parse?: (input: string, options?: ParsePatchOptions) => ReturnType<typeof parseApplyPatch>;
-    readonly plan?: (document: Parameters<typeof planApplyPatch>[0], options: PlanApplyPatchOptions) => ReturnType<typeof planApplyPatch>;
-    readonly commit?: (plan: PatchPlan, options: CommitPlanOptions) => Promise<CommitPlanResult>;
-    readonly renderSuccess?: typeof renderSuccess;
-    readonly renderFailure?: typeof renderFailure;
-}
-/**
- * Build the apply_patch use case.
- * @param deps - optional seam overrides; production binds the real modules.
- * @returns the tool seam bound to the real hashline engine and store.
- */
-export declare function createApplyPatchTool(deps?: ApplyPatchToolDeps): ApplyPatchTool;