@xiaoso/dsh-tool-plus 0.1.7-beta.0 → 0.1.7

package/lib/types/tools/omp/browser/readable.d.ts

@@ -0,0 +1,17 @@
+export type ReadableFormat = "text" | "markdown";
+export interface ReadableResult {
+    url: string;
+    title?: string;
+    byline?: string;
+    excerpt?: string;
+    contentLength: number;
+    text?: string;
+    markdown?: string;
+}
+/**
+ * Extract readable content from raw HTML.
+ * Tries Readability (article-isolation scoring) first, then falls back to a
+ * CSS selector chain over the same pre-parsed DOM. Returns null if neither
+ * path yields usable content.
+ */
+export declare function extractReadableFromHtml(html: string, url: string, format: ReadableFormat): Promise<ReadableResult | null>;

package/lib/types/tools/omp/config/settings-schema.d.ts

@@ -0,0 +1,12 @@
+/**
+ * DSH adapter for OMP's `config/settings-schema.ts`.
+ *
+ * The OMP schema is a ~5900-line settings registry. The edit engine only
+ * needs `getDefault(path)` for a handful of keys; defaults are taken from the
+ * OMP schema values (verbatim) so engine behavior matches upstream. Full
+ * schema metadata (tabs, UI descriptors) is DSH-side and not replicated.
+ */
+export type SettingPath = string;
+export type SettingValue<P extends string = string> = unknown;
+/** Schema default for a setting path (verbatim OMP values; unknown -> undefined). */
+export declare function getDefault<P extends SettingPath>(path: P): any;

package/lib/types/tools/omp/config/settings.d.ts

@@ -0,0 +1,59 @@
+/**
+ * DSH adapter for OMP's `config/settings.ts` Settings surface.
+ *
+ * OMP edit engine reads session settings through `settings.get("edit.*")`,
+ * `settings.get("lsp.*")`, etc. DSH has its own configuration (fields.ts +
+ * dsh settings); this adapter maps the OMP dotted keys onto the resolved
+ * tool-plus config, so the verbatim OMP engine code compiles and runs
+ * without modification.
+ *
+ * Only the surface the edit engine actually touches is provided:
+ * - `Settings` class with `get(path)` and `getEditVariantForModel(model)`
+ * - `settings` singleton (uninitialized until `installGlobalSettings` runs)
+ * - `isSettingsInitialized()`
+ *
+ * LSP keys are not wired: the LSP integration was cut from the DSH port
+ * (plan.md §3), so those reads fall back to the schema default (their
+ * `enableLsp` gate is `false` at the call sites), never to a degraded
+ * edit path.
+ */
+import type { RuntimeConfig } from '../../../config/settings.ts';
+export type SettingPath = string;
+/** Raw settings document shape (verbatim OMP). */
+export interface RawSettings {
+    [key: string]: unknown;
+}
+export interface SettingsOptions {
+    cwd?: string;
+    agentDir?: string;
+    inMemory?: boolean;
+    readOnly?: boolean;
+    overrides?: Partial<Record<string, unknown>>;
+    configFiles?: string[];
+}
+export type SettingValue<P extends string = string> = unknown;
+/**
+ * Session-scoped settings adapter. `get(path)` resolves the OMP dotted key
+ * against the live tool-plus config; unknown keys return the schema default
+ * or undefined.
+ */
+export declare class Settings {
+    #private;
+    constructor(config: RuntimeConfig, getDefault: (path: string) => unknown);
+    get(path: string): any;
+    /** OMP storage accessor (DSH: no agent storage — null). */
+    getStorage(): null;
+    /** Whether a path is explicitly configured (DSH config is always resolved). */
+    isConfigured(_path: string): boolean;
+    /** Persist a setting (DSH: config is static at tool time — no-op). */
+    set(_path: string, _value: unknown): void;
+    /** OMP edit-variant override hook; DSH resolves the mode from config directly. */
+    getEditVariantForModel(_model: string | undefined): 'replace' | 'patch' | 'hashline' | 'apply_patch' | null;
+}
+/** Install the resolved tool-plus config into the global settings singleton. */
+export declare function installGlobalSettings(config: RuntimeConfig, getDefault: (path: string) => unknown): void;
+export declare function isSettingsInitialized(): boolean;
+/** Global settings singleton (read-only facade over the installed config). */
+export declare const settings: Settings;
+/** Re-exported schema default lookup (OMP settings.ts re-exports it too). */
+export { getDefault } from './settings-schema.ts';

package/lib/types/tools/omp/edit/apply-patch/parser.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Parser for the Codex `apply_patch` envelope format.
+ *
+ *     *** Begin Patch
+ *     *** Add File: <path>
+ *     +<line>
+ *     *** Delete File: <path>
+ *     *** Update File: <path>
+ *     *** Move to: <newpath>
+ *     @@ <optional context>
+ *     -old
+ *     +new
+ *      context
+ *     *** End of File
+ *     *** End Patch
+ *
+ * Input is the full envelope text (optionally heredoc-wrapped). Output is a
+ * list of `PatchInput` records, each ready to hand to the existing
+ * single-file `applyPatch()` in `../modes/patch.ts`.
+ *
+ * Per spec §4.3 Lenient mode: a `<<EOF` / `<<'EOF'` / `<<"EOF"` heredoc
+ * wrapper around the whole envelope is stripped before parsing.
+ */
+import type { PatchInput } from "../modes/patch";
+/**
+ * Parse a Codex `*** Begin Patch` envelope into a list of single-file
+ * patch inputs.
+ */
+export declare function parseApplyPatch(patchText: string): PatchInput[];
+/**
+ * Best-effort parser for in-progress TUI previews. It tolerates missing
+ * envelope markers and incomplete trailing hunks; do not use it to apply edits.
+ */
+export declare function parseApplyPatchStreaming(patchText: string): PatchInput[];

package/lib/types/tools/omp/edit/details.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Edit tool result detail shapes (shared by the replace / patch / hashline
+ * engines and the snapshot pruner). The TUI renderer that consumed these was
+ * cut with the TUI layer (plan.md 拍板#17); the shapes remain because the
+ * engines assemble them as their `AgentToolResult.details`.
+ */
+export type Operation = "create" | "delete" | "update";
+export interface EditToolPerFileResult {
+    path: string;
+    diff: string;
+    firstChangedLine?: number;
+    op?: Operation;
+    move?: string;
+    isError?: boolean;
+    errorText?: string;
+    /** TUI-friendly error text. When present, rendered to the user instead of `errorText`.
+     * Set when the underlying error carries a `displayMessage` (e.g. {@link HashlineMismatchError}). */
+    displayErrorText?: string;
+    meta?: OutputMeta;
+    /** Source-of-truth content before the edit; `undefined` for create operations. */
+    oldText?: string;
+    /** Source-of-truth content after the edit; `undefined` for delete operations. */
+    newText?: string;
+    /** True when {@link pruneOversizedEditSnapshots} dropped `oldText`/`newText` from this entry. Aggregators check this to suppress misleading combined snapshots when at least one entry of a multi-entry single-path edit was pruned. */
+    snapshotsPruned?: boolean;
+    /** Pre-move source path; set only when the edit moved/renamed the file. The header renders `sourcePath → path`. */
+    sourcePath?: string;
+}
+export interface EditToolDetails {
+    /** Unified diff of the changes made */
+    diff: string;
+    /** Line number of the first change in the new file (for editor navigation) */
+    firstChangedLine?: number;
+    /** Operation type (patch mode only) */
+    op?: Operation;
+    /** New path after move/rename (patch mode only) */
+    move?: string;
+    /** Structured output metadata */
+    meta?: OutputMeta;
+    /** Per-file results (multi-file edits) */
+    perFileResults?: EditToolPerFileResult[];
+    /** Absolute file path for single-file edit results. Required by ACP diff metadata consumers. */
+    path?: string;
+    /** Source-of-truth content before the edit; `undefined` for create operations. */
+    oldText?: string;
+    /** Source-of-truth content after the edit; `undefined` for delete operations. */
+    newText?: string;
+    /** True when {@link pruneOversizedEditSnapshots} dropped `oldText`/`newText` from this entry. Aggregators check this to suppress misleading combined snapshots when at least one entry of a multi-entry single-path edit was pruned. */
+    snapshotsPruned?: boolean;
+    /** Pre-move source path; set only when the edit moved/renamed the file. The header renders `sourcePath → path`. */
+    sourcePath?: string;
+}
+type OutputMeta = import("../../edit/adapter/tools/output-meta").OutputMeta;
+export {};

package/lib/types/tools/omp/edit/diff.d.ts

@@ -0,0 +1,60 @@
+import { type BlockContextSource } from "../../omp/utils/block-context.ts";
+export interface DiffResult {
+    diff: string;
+    firstChangedLine: number | undefined;
+}
+export interface DiffError {
+    error: string;
+}
+export interface DiffHunk {
+    changeContext?: string;
+    oldStartLine?: number;
+    newStartLine?: number;
+    hasContextLines: boolean;
+    oldLines: string[];
+    newLines: string[];
+    isEndOfFile: boolean;
+}
+export declare class ParseError extends Error {
+    readonly lineNumber?: number | undefined;
+    constructor(message: string, lineNumber?: number | undefined);
+}
+export declare class ApplyPatchError extends Error {
+    constructor(message: string);
+}
+/**
+ * Generate a unified diff string with line numbers and context.
+ * Returns both the diff string and the first changed line number (in the new file).
+ */
+export declare function generateDiffString(oldContent: string, newContent: string, contextLines?: number, source?: BlockContextSource): DiffResult;
+export interface ReplaceOptions {
+    /** Allow fuzzy matching */
+    fuzzy: boolean;
+    /** Replace all occurrences */
+    all: boolean;
+    /** Similarity threshold for fuzzy matching */
+    threshold?: number;
+}
+export interface ReplaceResult {
+    /** The new content after replacements */
+    content: string;
+    /** Number of replacements made */
+    count: number;
+}
+/**
+ * Generate a unified diff string without file headers.
+ * Returns both the diff string and the first changed line number (in the new file).
+ */
+export declare function generateUnifiedDiffString(oldContent: string, newContent: string, contextLines?: number, source?: BlockContextSource): DiffResult;
+export declare function normalizeDiff(diff: string): string;
+export declare function normalizeCreateContent(content: string): string;
+export declare function parseDiffHunks(diff: string): DiffHunk[];
+/**
+ * Find and replace text in content using fuzzy matching.
+ */
+export declare function replaceText(content: string, oldText: string, newText: string, options: ReplaceOptions): ReplaceResult;
+/**
+ * Compute the diff for an edit operation without applying it.
+ * Used for preview rendering in the TUI before the tool executes.
+ */
+export declare function computeEditDiff(path: string, oldText: string, newText: string, cwd: string, fuzzy?: boolean, all?: boolean, threshold?: number): Promise<DiffResult | DiffError>;

package/lib/types/tools/omp/edit/dispatch.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Edit dispatch layer — path resolution + multi-entry/multi-file aggregation.
+ *
+ * Ported verbatim from upstream `packages/coding-agent/src/edit/index.ts`
+ * (refs/oh-my-pi, 17.3.5): `resolveEditPath` (:77-93), `executeApplyPatchPerFile`
+ * (:139-256) and `executeSinglePathEntries` (:258-365). Algorithm and user-facing
+ * copy are byte-for-byte upstream; only the import surface was redirected to the
+ * DSH-resident modules and the LSP-only surface was cut, per the established
+ * omp/ adaptation conventions:
+ *   - `renderer` → `./details` (TUI renderer cut, plan.md 拍板#17): the
+ *     `EditToolDetails` / `EditToolPerFileResult` shapes live in `./details.ts`;
+ *     the upstream per-file `diagnostics` field went with the LSP layer.
+ *   - `resolvePlanPath` → DSH adapter shim (`edit/adapter/tools/plan-mode-guard`,
+ *     verbatim resolution minus local:// schemes) — same redirection the local
+ *     engines (modes/replace.ts, modes/patch.ts) already use.
+ *   - `LspBatchRequest` / `flushLspWritethroughBatch` → local type + no-op below.
+ *     DSH never constructs an outer batch request, so every `batchRequest` inside
+ *     the aggregators resolves to `undefined` and the flush branches stay
+ *     unreachable; the flow is kept verbatim so this file stays diffable
+ *     against refs.
+ */
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { ToolSession } from "../tools/index.ts";
+import type { EditToolDetails } from "./details";
+/**
+ * LSP write-batch handle (upstream `tools/render-utils.ts`, surfaced through the
+ * edit renderer). Shape verbatim; DSH cuts the LSP layer (plan.md 拍板#5), so no
+ * caller ever constructs one — see {@link flushLspWritethroughBatch}.
+ */
+export interface LspBatchRequest {
+    id: string;
+    flush: boolean;
+}
+export declare function resolveEditPath(session: ToolSession, authoredPath: string, options: {
+    mustExist: boolean;
+    signal?: AbortSignal;
+}): Promise<string>;
+/** Run apply_patch file operations and aggregate their multi-file result. */
+export declare function executeApplyPatchPerFile(fileEntries: {
+    path: string;
+    run: (batchRequest: LspBatchRequest | undefined) => Promise<AgentToolResult<EditToolDetails>>;
+}[], outerBatchRequest: LspBatchRequest | undefined, cwd: string, signal: AbortSignal | undefined, onUpdate?: (partialResult: AgentToolResult<EditToolDetails>) => void): Promise<AgentToolResult<EditToolDetails>>;
+export declare function executeSinglePathEntries(path: string, runs: ((batchRequest: LspBatchRequest | undefined) => Promise<AgentToolResult<EditToolDetails>>)[], outerBatchRequest: LspBatchRequest | undefined, onUpdate: ((partialResult: AgentToolResult<EditToolDetails>) => void) | undefined, cwd: string, signal: AbortSignal | undefined): Promise<AgentToolResult<EditToolDetails>>;

package/lib/types/tools/omp/edit/file-snapshot-store.d.ts

@@ -0,0 +1,81 @@
+import { type EditStore, type EditStoreOwner } from "../../hashline/native/index.ts";
+/**
+ * Upper bound on the file size we snapshot.
+ *
+ * A section tag is a content hash of the *whole* file, so minting one means
+ * holding the full normalized text in the store. Files above this cap emit no
+ * `[path#tag]` header — line-anchored editing of multi-megabyte files is out
+ * of scope under the full-content model.
+ *
+ * The value mirrors the native store's own cap (`EditStore.recordSnapshotFile`
+ * returns `null` for "unreadable or larger than 4 MiB",
+ * `@oh-my-pi/pi-natives` index.d.ts:132-136); `read` also uses it to decide
+ * whether to stream a whole file into memory.
+ */
+export declare const SNAPSHOT_MAX_BYTES: number;
+/**
+ * Look up (or lazily create) the file snapshot store attached to a session.
+ *
+ * One-line forward to the adapter's `getEditStore` so there is exactly one
+ * store per session; the DSH name is kept because this module owns the
+ * DSH-side concerns listed in the file header.
+ */
+export declare function getFileSnapshotStore(session: EditStoreOwner): EditStore;
+/**
+ * Canonicalize an absolute path into the stable key the snapshot store uses.
+ *
+ * Different code paths reach the snapshot store via different path forms:
+ * `read local://foo.md` records under the file's `fs.realpath` (the local
+ * protocol handler resolves symlinks); a subsequent `edit` may address the
+ * same artifact via `local://foo.md`, whose resolver does NOT realpath, or
+ * via the absolute path returned in the `[path#tag]` header. macOS adds the
+ * same hazard at the working-tree level (`/tmp/...` vs `/private/tmp/...`).
+ * Collapsing every key through `realpath` makes those forms fuse onto one
+ * snapshot entry, so a freshly-minted tag is never rejected as stale just
+ * because the lookup spelled the same file differently.
+ *
+ * Non-existent paths (new-file writes) fall back to a realpath of the parent
+ * directory + basename, then to the input. This keeps creates and updates on
+ * the same canonical key.
+ *
+ * Parity note (native migration): the Rust engine keys its own lookups by
+ * `policy.cwd` + the authored path, i.e. the unresolved spelling. For a path
+ * with no symlink component the two spellings are identical; for a symlinked
+ * subpath they are not, and a tag minted here would not be found by the
+ * engine. Listed for the parity doc (T-parity) rather than papered over —
+ * native exposes no path-canonicalization hook.
+ */
+export declare function canonicalSnapshotKey(absolutePath: string): string;
+/**
+ * Read the full text of `absolutePath` (within {@link SNAPSHOT_MAX_BYTES}),
+ * record it as a version snapshot, and return its content-hash tag. Returns
+ * `undefined` when the file exceeds the cap or cannot be read — callers then
+ * omit the section header so the model never sees a tag it can't anchor against.
+ *
+ * Producers that only displayed a slice of the file (range reads, search hits)
+ * use this to mint a whole-file tag: the displayed lines stay partial, but the
+ * tag fingerprints the entire file so a follow-up edit anchored at any line
+ * validates whenever the live file is byte-identical to what was read. Raw
+ * reads pass `seenLines` even though they do not emit a header, letting a prior
+ * or later same-content hashline tag inherit the raw range's provenance.
+ *
+ * `async` for call-site compatibility (`read`/`grep`/`ast-grep` await it); the
+ * native `recordSnapshotFile` performs the read, LF normalization and the
+ * 4 MiB cap synchronously, and returns `null` instead of `undefined`.
+ */
+export declare function recordFileSnapshot(session: EditStoreOwner, absolutePath: string, seenLines?: Iterable<number>): Promise<string | undefined>;
+/** Merge explicit 1-indexed displayed lines into a recorded hashline snapshot. */
+export declare function recordSeenLines(session: EditStoreOwner, absolutePath: string, tag: string, lines: readonly number[]): void;
+/**
+ * Attach the lines a read displayed to the snapshot it minted, so the engine's
+ * (opt-in) seen-line guard can reject edits anchored on lines the model never
+ * saw. Best-effort: a no-op when the body has no numbered rows or the snapshot
+ * already aged out. `tag` must be the tag returned when this exact content was
+ * recorded. Every displayed `NN:` row counts as seen, including column-clipped
+ * rows — the guard no longer distinguishes full-width from truncated display.
+ *
+ * The `N:` / `NN-MM:` row parsing lives in Rust now
+ * (`EditStore.recordSeenLinesFromBody`, including the collapsed-summary
+ * boundary-line rule), so this is a straight forward with key canonicalization.
+ */
+export declare function recordSeenLinesFromBody(session: EditStoreOwner, absolutePath: string, tag: string, body: string): void;

package/lib/types/tools/omp/edit/hashline/execute.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Coding-agent runner that drives the native hashline engine on behalf of the
+ * `edit` tool. Converts an `{input}` tool-call payload into a fully-applied
+ * patch, wraps the result in the agent's {@link AgentToolResult} shape, and
+ * attaches `outputMeta` for the renderer.
+ *
+ * Before the native migration this file drove the vendored TS engine
+ * (`Patch`/`Patcher`/`HashlineFilesystem`/`BlockResolver`/clipboard) and
+ * hand-assembled the model-facing text from per-section fields. Upstream 18.x
+ * moved all of that into Rust (`crates/pi-edit`), so the host side is now:
+ *
+ * 1. build the `EditPolicy` (`native/policy.ts`) and the writer
+ *    (`native/writer.ts`),
+ * 2. hand `EditSession.apply` the payload,
+ * 3. shape the returned {@link EditApplyOutcome} into DSH's
+ *    `EditToolDetails`.
+ *
+ * What the native engine now owns (and this file therefore no longer
+ * implements — each was verified byte-for-byte against the old DSH output):
+ * the parsed/aggregated model-facing text including the compact numbered
+ * preview and `PUT N*:` block-resolution lines, mismatch / unseen-anchor /
+ * missing-file diagnostics, the byte-identical no-op hint **and** its
+ * 3-strike escalation (the old `noop-loop-guard.ts`), tag validation with
+ * in-session recovery, `N*` block resolution, the `CUT`/`PUT` clipboard
+ * registers, and the multi-section merge for sections naming one file.
+ */
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import { MismatchError } from "../../../hashline/native/index.ts";
+import type { ToolSession } from "../../../omp/tools/index.ts";
+import type { WritethroughCallback } from "../../../omp/tools/writethrough.ts";
+import type { EditToolDetails } from "../details";
+import { type HashlineParams, hashlineEditParamsSchema } from "./params";
+export interface ExecuteHashlineSingleOptions {
+    session: ToolSession;
+    input: string;
+    signal?: AbortSignal;
+    writethrough: WritethroughCallback;
+}
+export declare function executeHashlineSingle(options: ExecuteHashlineSingleOptions): Promise<AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema>>;
+export { MismatchError as HashlineMismatchError, type HashlineParams, hashlineEditParamsSchema };

package/lib/types/tools/omp/edit/hashline/params.d.ts

@@ -0,0 +1,6 @@
+export declare const hashlineEditParamsSchema: import("@oh-my-pi/omptype").FluentType<{
+    input: string;
+}, {
+    input: string;
+}>;
+export type HashlineParams = typeof hashlineEditParamsSchema.infer;

package/lib/types/tools/omp/edit/modes/apply-patch.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Edit mode wrapper for the Codex `apply_patch` envelope format.
+ *
+ * The mode accepts a single `input` string containing a full
+ * `*** Begin Patch ... *** End Patch` block, parses it, and fans out to
+ * the existing `executePatchSingle` — so all the machinery (plan mode,
+ * LSP writethrough, fs-cache invalidation, diagnostics) is shared with
+ * the `patch` mode.
+ */
+import type { PatchEditEntry } from "./patch";
+export declare const applyPatchSchema: import("@oh-my-pi/omptype").FluentType<{
+    input: string;
+}, {
+    input: string;
+}>;
+export type ApplyPatchParams = typeof applyPatchSchema.infer;
+export type ApplyPatchEntry = PatchEditEntry & {
+    path: string;
+};
+/**
+ * Parse the envelope and lower each hunk to a `PatchEditEntry` so it can
+ * be routed through `executePatchSingle`.
+ */
+export declare function expandApplyPatchToEntries(params: ApplyPatchParams): ApplyPatchEntry[];
+export declare function expandApplyPatchToPreviewEntries(params: ApplyPatchParams): ApplyPatchEntry[];

package/lib/types/tools/omp/edit/modes/patch.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Patch application logic for the edit tool.
+ *
+ * Applies parsed diff hunks to file content using fuzzy matching
+ * for robust handling of whitespace and formatting differences.
+ */
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import { type WritethroughCallback } from "../../../omp/tools/writethrough.ts";
+import type { ToolSession } from "../../../omp/tools/index.ts";
+import type { EditToolDetails, Operation } from "../details";
+export interface PatchInput {
+    path: string;
+    op: Operation;
+    rename?: string;
+    diff?: string;
+}
+export interface FileSystem {
+    exists(path: string): Promise<boolean>;
+    read(path: string): Promise<string>;
+    readBinary?: (path: string) => Promise<Uint8Array>;
+    write(path: string, content: string): Promise<void>;
+    delete(path: string): Promise<void>;
+    mkdir(path: string): Promise<void>;
+}
+interface FileChange {
+    type: Operation;
+    path: string;
+    newPath?: string;
+    oldContent?: string;
+    newContent?: string;
+}
+export interface ApplyPatchResult {
+    change: FileChange;
+    warnings?: string[];
+}
+export interface ApplyPatchOptions {
+    cwd: string;
+    dryRun?: boolean;
+    fuzzyThreshold?: number;
+    allowFuzzy?: boolean;
+    fs?: FileSystem;
+    /**
+     * Permit `op: "create"` to replace an existing file (full-file overwrite).
+     * The JSON `patch` edit mode sanctions create-as-overwrite for major
+     * restructures (see prompts/tools/patch.md); the Codex `apply_patch`
+     * envelope documents `*** Add File` as strictly non-overwriting and must
+     * leave this unset.
+     */
+    allowCreateOverwrite?: boolean;
+}
+/** Default filesystem implementation using Bun APIs */
+export declare const defaultFileSystem: FileSystem;
+/**
+ * Apply a patch operation to the filesystem.
+ */
+export declare function applyPatch(input: PatchInput, options: ApplyPatchOptions): Promise<ApplyPatchResult>;
+/**
+ * Preview what changes a patch would make without applying it.
+ */
+export declare function previewPatch(input: PatchInput, options: ApplyPatchOptions): Promise<ApplyPatchResult>;
+export declare function computePatchDiff(input: PatchInput, cwd: string, options?: {
+    fuzzyThreshold?: number;
+    allowFuzzy?: boolean;
+    allowCreateOverwrite?: boolean;
+}): Promise<{
+    diff: string;
+    firstChangedLine: number | undefined;
+} | {
+    error: string;
+}>;
+export declare const patchEditEntrySchema: import("@oh-my-pi/omptype").FluentType<{
+    op?: "delete" | "create" | "update" | undefined;
+    rename?: string | undefined;
+    diff?: string | undefined;
+}, {
+    op?: "delete" | "create" | "update" | undefined;
+    rename?: string | undefined;
+    diff?: string | undefined;
+}>;
+export type PatchEditEntry = typeof patchEditEntrySchema.infer;
+export declare const patchEditSchema: import("@oh-my-pi/omptype").FluentType<{
+    path: string;
+    edits: {
+        op?: "delete" | "create" | "update" | undefined;
+        rename?: string | undefined;
+        diff?: string | undefined;
+    }[];
+}, {
+    path: string;
+    edits: {
+        op?: "delete" | "create" | "update" | undefined;
+        rename?: string | undefined;
+        diff?: string | undefined;
+    }[];
+}>;
+export type PatchParams = typeof patchEditSchema.infer;
+export interface ExecutePatchSingleOptions {
+    session: ToolSession;
+    path: string;
+    params: PatchEditEntry;
+    signal?: AbortSignal;
+    allowFuzzy: boolean;
+    fuzzyThreshold: number;
+    /** See {@link ApplyPatchOptions.allowCreateOverwrite}; set by the JSON `patch` mode only. */
+    allowCreateOverwrite?: boolean;
+    writethrough: WritethroughCallback;
+}
+export declare function executePatchSingle(options: ExecutePatchSingleOptions): Promise<AgentToolResult<EditToolDetails, typeof patchEditEntrySchema>>;
+export {};