@chances-ai/engine 28.0.0 → 30.0.0

package/dist/hashline/input.d.ts

@@ -0,0 +1,101 @@
+import type { ApplyResult, BlockResolver, Edit, SplitOptions } from "./types.js";
+interface RawSection {
+    path: string;
+    fileHash?: string;
+    diff: string;
+}
+/**
+ * Returns true when the input contains at least one line that the tokenizer
+ * recognizes as a hashline op. Used by streaming previews to decide whether
+ * the partial input is worth treating as a hashline patch yet.
+ */
+export declare function containsRecognizableHashlineOperations(input: string): boolean;
+/**
+ * Snapshot of one section in a parsed {@link Patch}: a target file plus the
+ * lazily-parsed list of edits that should land on it. Constructed by
+ * {@link Patch.parse}; consumers usually iterate `patch.sections` rather
+ * than build these directly.
+ */
+export declare class PatchSection {
+    #private;
+    readonly path: string;
+    readonly fileHash: string | undefined;
+    readonly diff: string;
+    constructor(raw: RawSection);
+    /**
+     * Parse this section's diff body. Cached: subsequent calls return the
+     * same `{ edits, warnings }` object so callers can safely call this from
+     * multiple paths (preflight, apply, diff-preview).
+     */
+    parse(): {
+        edits: Edit[];
+        warnings: readonly string[];
+    };
+    /** Parsed edits for this section. */
+    get edits(): readonly Edit[];
+    /** Warnings emitted during parsing of this section. */
+    get warnings(): readonly string[];
+    /**
+     * True when at least one edit anchors to concrete file content. Pure
+     * `insert head:` / `insert tail:` literal inserts do not count: those are
+     * safe to apply to files that don't yet exist.
+     */
+    get hasAnchorScopedEdit(): boolean;
+    /** Anchor lines touched by this section, sorted ascending and deduplicated. */
+    collectAnchorLines(): readonly number[];
+    /**
+     * Apply this section's edits to `text` and return the post-edit result.
+     * Pure: does no I/O, does not validate the section snapshot tag. The
+     * {@link Patcher} owns tag validation and recovery; reach for this
+     * method directly when you've already validated the file content and
+     * just want the result.
+     *
+     * `blockResolver` resolves any `replace block N:` edits against `text`; an
+     * unresolvable block throws (this is the final, authoritative preview path).
+     */
+    applyTo(text: string, blockResolver?: BlockResolver): ApplyResult;
+    /**
+     * Streaming-tolerant counterpart to {@link applyTo}. Uses
+     * {@link parsePatchStreaming} so a trailing in-flight op (no payload yet,
+     * or a per-token parse error mid-stream) does not throw or emit a phantom
+     * empty-payload edit. Intended for incremental diff previews; the writer
+     * path should always use {@link applyTo}.
+     *
+     * `blockResolver` resolves any `replace block N:` edits against `text`; an
+     * unresolvable block is silently dropped so a half-written file does not
+     * throw mid-stream.
+     */
+    applyPartialTo(text: string, blockResolver?: BlockResolver): ApplyResult;
+}
+/**
+ * A parsed hashline patch — zero or more {@link PatchSection}s, each rooted
+ * at a `¶PATH#HASH` header. Construct via {@link Patch.parse}.
+ *
+ * `Patch` is pure data: parsing is line-anchored and does not look at the
+ * filesystem. To apply a patch, hand it to {@link Patcher.apply}.
+ */
+export declare class Patch {
+    readonly sections: readonly PatchSection[];
+    private constructor();
+    /**
+     * Parse `input` into a {@link Patch}. `options.cwd` resolves absolute
+     * paths inside headers to cwd-relative form; `options.path` provides a
+     * fallback when the input lacks a header but contains hashline ops
+     * (useful for streaming previews).
+     *
+     * Consecutive sections targeting the same path are merged into a single
+     * section with concatenated diff bodies. Anchors authored against the
+     * same file snapshot must be applied as one batch; otherwise the first
+     * sub-edit shifts line numbers out from under the second's anchors and
+     * validation fails.
+     */
+    static parse(input: string, options?: SplitOptions): Patch;
+    /**
+     * Parse `input` and return only the first section. Throws if the input
+     * has zero sections. Convenience for the single-section case where the
+     * caller already knows the patch is one hunk.
+     */
+    static parseSingle(input: string, options?: SplitOptions): PatchSection;
+}
+export {};
+//# sourceMappingURL=input.d.ts.map

package/dist/hashline/input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../src/hashline/input.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAgEjF,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd;AA+CD;;;;GAIG;AACH,wBAAgB,sCAAsC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAK7E;AAyED;;;;;GAKG;AACH,qBAAa,YAAY;;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAGV,GAAG,EAAE,UAAU;IAM3B;;;;OAIG;IACH,KAAK,IAAI;QAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE;IAKvD,qCAAqC;IACrC,IAAI,KAAK,IAAI,SAAS,IAAI,EAAE,CAE3B;IAED,uDAAuD;IACvD,IAAI,QAAQ,IAAI,SAAS,MAAM,EAAE,CAEhC;IAED;;;;OAIG;IACH,IAAI,mBAAmB,IAAI,OAAO,CAOjC;IAED,+EAA+E;IAC/E,kBAAkB,IAAI,SAAS,MAAM,EAAE;IAkBvC;;;;;;;;;OASG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,aAAa,GAAG,WAAW;IAYjE;;;;;;;;;;OAUG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,aAAa,GAAG,WAAW;CASzE;AAED;;;;;;GAMG;AACH,qBAAa,KAAK;IAChB,QAAQ,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;IAE3C,OAAO;IAIP;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,KAAK;IAK9D;;;;OAIG;IACH,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,YAAY;CAM5E"}

package/dist/hashline/input.js

@@ -0,0 +1,378 @@
+/**
+ * Top-level patch parser. Splits an authored hashline input into a list of
+ * {@link PatchSection}s, each rooted at a `¶PATH#HASH` header, then exposes
+ * a {@link Patch} class that gives lazy access to the parsed edits per
+ * section. Ported from oh-my-pi `packages/hashline/src/input.ts`.
+ *
+ * The splitter is purely lexical — it doesn't know whether a section's path
+ * actually exists. That's the patcher's job.
+ */
+import * as path from "node:path";
+import { applyEdits } from "./apply.js";
+import { resolveBlockEdits } from "./block.js";
+import { HL_FILE_HASH_LENGTH, HL_FILE_HASH_SEP, HL_FILE_PREFIX } from "./format.js";
+import { parsePatch, parsePatchStreaming } from "./parser.js";
+import { Tokenizer } from "./tokenizer.js";
+/** UTF-8 BOM (U+FEFF). Built from a code point so the source stays ASCII. */
+const BOM = String.fromCharCode(0xfeff);
+// Pure classification — single shared tokenizer is safe.
+const TOKENIZER = new Tokenizer();
+function unquoteHashlinePath(pathText) {
+    if (pathText.length < 2)
+        return pathText;
+    const first = pathText[0];
+    const last = pathText[pathText.length - 1];
+    if ((first === '"' || first === "'") && first === last)
+        return pathText.slice(1, -1);
+    return pathText;
+}
+/**
+ * Strip apply_patch-style noise that models reflexively prepend to the
+ * path. Examples observed in benchmark traces:
+ *
+ *   `Update File:foo.ts`, `Update:foo.ts`, `UpdateFile:foo.ts`,
+ *   `Update/File:foo.ts`, `Update-file:foo.ts`, `Update(File):foo.ts`,
+ *   `Update<File:foo.ts`, `Add File:foo.ts`, `Delete File:foo.ts`,
+ *   `Move to:foo.ts`, `***foo.ts`, `***Update File:foo.ts`.
+ *
+ * We strip a leading `***` (the model duplicating the header sigil) and a
+ * leading `(Update|Add|Delete|Move)[<separator>]*(File|to)?[<separator>]*:`
+ * keyword block, case-insensitive. The remaining text is the real path.
+ */
+const APPLY_PATCH_PATH_NOISE_RE = /^\*{0,3}\s*(?:(?:update|add|delete|move)[^A-Za-z0-9]*(?:file|to)?[^A-Za-z0-9]*:)?\s*\*{0,3}\s*/i;
+function stripApplyPatchPathNoise(pathText) {
+    return pathText.replace(APPLY_PATCH_PATH_NOISE_RE, "");
+}
+/**
+ * Best-effort recovery for `¶`-prefixed lines the strict tokenizer
+ * rejects. Strips apply_patch keyword noise (`Update File:`, `Update:`,
+ * etc.) and an extra leading `***` (some models emit a hybrid `¶***foo.ts`
+ * shape), then expects `PATH(#HASH)?` with no embedded whitespace.
+ * Returns `null` when no clean path can be salvaged.
+ */
+function tryParseRecoveryHeader(line, cwd) {
+    if (!line.startsWith(HL_FILE_PREFIX))
+        return null;
+    const body = stripApplyPatchPathNoise(line.slice(HL_FILE_PREFIX.length).trim());
+    if (body.length === 0)
+        return null;
+    const match = new RegExp(`^(\\S+?)(?:#([0-9A-Fa-f]{${HL_FILE_HASH_LENGTH}}))?\\s*$`).exec(body);
+    if (match === null)
+        return null;
+    const parsedPath = normalizeHashlinePath(match[1] ?? "", cwd);
+    if (parsedPath.length === 0)
+        return null;
+    return match[2] !== undefined
+        ? { path: parsedPath, fileHash: match[2].toUpperCase(), diff: "" }
+        : { path: parsedPath, diff: "" };
+}
+function normalizeHashlinePath(rawPath, cwd) {
+    const unquoted = stripApplyPatchPathNoise(unquoteHashlinePath(rawPath.trim()));
+    if (!cwd || !path.isAbsolute(unquoted))
+        return unquoted;
+    const relative = path.relative(path.resolve(cwd), path.resolve(unquoted));
+    const isWithinCwd = relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+    return isWithinCwd ? relative || "." : unquoted;
+}
+/**
+ * Parse a `¶PATH[#hash]` header line. Returns `null` for lines that do
+ * not start with `¶`. Throws the strict "Input header must be …" error
+ * when a `¶`-prefixed line fails the strict shape (so malformed paths
+ * surface immediately instead of being silently re-classified as payload).
+ */
+function parseHashlineHeaderLine(line, cwd) {
+    const trimmed = line.trimEnd();
+    if (!trimmed.startsWith(HL_FILE_PREFIX))
+        return null;
+    const token = TOKENIZER.tokenize(trimmed);
+    if (token.kind !== "header") {
+        // Recovery: try to extract a path from the raw line after stripping
+        // apply_patch noise. This handles `*** Update File:foo.ts#CB5` and
+        // the half-dozen variants models actually emit.
+        const recovered = tryParseRecoveryHeader(trimmed, cwd);
+        if (recovered !== null)
+            return recovered;
+        throw new Error(`Input header must be ${HL_FILE_PREFIX}PATH or ${HL_FILE_PREFIX}PATH${HL_FILE_HASH_SEP}TAG with a ${HL_FILE_HASH_LENGTH}-hex content-hash tag; got ${JSON.stringify(trimmed)}.`);
+    }
+    const parsedPath = normalizeHashlinePath(token.path, cwd);
+    if (parsedPath.length === 0) {
+        throw new Error(`Input header "${HL_FILE_PREFIX}" is empty; provide a file path.`);
+    }
+    return token.fileHash !== undefined
+        ? { path: parsedPath, fileHash: token.fileHash, diff: "" }
+        : { path: parsedPath, diff: "" };
+}
+function stripLeadingBlankLines(input) {
+    const stripped = input.startsWith(BOM) ? input.slice(1) : input;
+    const lines = stripped.split("\n");
+    while (lines.length > 0) {
+        const head = lines[0].replace(/\r$/, "");
+        if (head.trim().length === 0 || TOKENIZER.tokenize(head).kind === "envelope-begin") {
+            lines.shift();
+            continue;
+        }
+        break;
+    }
+    return lines.join("\n");
+}
+/**
+ * Returns true when the input contains at least one line that the tokenizer
+ * recognizes as a hashline op. Used by streaming previews to decide whether
+ * the partial input is worth treating as a hashline patch yet.
+ */
+export function containsRecognizableHashlineOperations(input) {
+    for (const line of input.split(/\r?\n/)) {
+        if (TOKENIZER.isOp(line))
+            return true;
+    }
+    return false;
+}
+function normalizeFallbackInput(input, options) {
+    const stripped = input.startsWith(BOM) ? input.slice(1) : input;
+    const hasExplicitHeader = stripped
+        .split(/\r?\n/)
+        .some((rawLine) => parseHashlineHeaderLine(rawLine, options.cwd) !== null);
+    if (hasExplicitHeader)
+        return input;
+    if (!options.path || !containsRecognizableHashlineOperations(input))
+        return input;
+    const fallbackPath = normalizeHashlinePath(options.path, options.cwd);
+    if (fallbackPath.length === 0)
+        return input;
+    return `${HL_FILE_PREFIX}${fallbackPath}\n${input}`;
+}
+function splitRawSections(input, options = {}) {
+    const stripped = stripLeadingBlankLines(normalizeFallbackInput(input, options));
+    const lines = stripped.split(/\r?\n/);
+    const firstLine = lines[0] ?? "";
+    if (parseHashlineHeaderLine(firstLine, options.cwd) === null) {
+        // Catch unified-diff hunk-header contamination on the first line so
+        // the model sees a focused error.
+        const firstTrimmed = firstLine.trimEnd();
+        if (/^@@\s+[-+]?\d+,\d+\s+[-+]?\d+,\d+\s+@@/.test(firstTrimmed)) {
+            throw new Error("unified-diff hunk header (`@@ -N,M +N,M @@`) is not valid in hashline. " +
+                "File sections start with `¶path#HASH`; use `replace`, `delete`, or `insert` ops.");
+        }
+        const preview = JSON.stringify(firstLine.slice(0, 120));
+        throw new Error(`input must begin with "${HL_FILE_PREFIX}PATH${HL_FILE_HASH_SEP}HASH" on the first non-blank line for anchored edits; got: ${preview}. ` +
+            `Example: "${HL_FILE_PREFIX}src/foo.ts${HL_FILE_HASH_SEP}0A3" then edit ops.`);
+    }
+    const sections = [];
+    let current;
+    let currentLines = [];
+    const flush = () => {
+        if (!current)
+            return;
+        const hasOps = currentLines.some((line) => line.trim().length > 0);
+        if (hasOps)
+            sections.push({ ...current, diff: currentLines.join("\n") });
+        currentLines = [];
+    };
+    for (const line of lines) {
+        const trimmed = line.trimEnd();
+        const token = TOKENIZER.tokenize(line);
+        if (token.kind === "envelope-end" || token.kind === "abort")
+            break;
+        if (token.kind === "envelope-begin")
+            continue;
+        // Route every `¶`-prefixed line through parseHashlineHeaderLine so
+        // malformed headers still raise the strict "Input header must be …"
+        // diagnostic (the tokenizer alone would silently classify them as
+        // payload).
+        if (trimmed.startsWith(HL_FILE_PREFIX)) {
+            const header = parseHashlineHeaderLine(line, options.cwd);
+            if (header !== null) {
+                flush();
+                current = header;
+                currentLines = [];
+                continue;
+            }
+        }
+        currentLines.push(line);
+    }
+    flush();
+    return sections;
+}
+/**
+ * Snapshot of one section in a parsed {@link Patch}: a target file plus the
+ * lazily-parsed list of edits that should land on it. Constructed by
+ * {@link Patch.parse}; consumers usually iterate `patch.sections` rather
+ * than build these directly.
+ */
+export class PatchSection {
+    path;
+    fileHash;
+    diff;
+    #parsed;
+    constructor(raw) {
+        this.path = raw.path;
+        this.fileHash = raw.fileHash;
+        this.diff = raw.diff;
+    }
+    /**
+     * Parse this section's diff body. Cached: subsequent calls return the
+     * same `{ edits, warnings }` object so callers can safely call this from
+     * multiple paths (preflight, apply, diff-preview).
+     */
+    parse() {
+        this.#parsed ??= parsePatch(this.diff);
+        return this.#parsed;
+    }
+    /** Parsed edits for this section. */
+    get edits() {
+        return this.parse().edits;
+    }
+    /** Warnings emitted during parsing of this section. */
+    get warnings() {
+        return this.parse().warnings;
+    }
+    /**
+     * True when at least one edit anchors to concrete file content. Pure
+     * `insert head:` / `insert tail:` literal inserts do not count: those are
+     * safe to apply to files that don't yet exist.
+     */
+    get hasAnchorScopedEdit() {
+        return this.edits.some((edit) => {
+            if (edit.kind === "delete")
+                return true;
+            // A `replace block N:` edit is anchored to concrete content on line N.
+            if (edit.kind === "block")
+                return true;
+            return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
+        });
+    }
+    /** Anchor lines touched by this section, sorted ascending and deduplicated. */
+    collectAnchorLines() {
+        const lines = new Set();
+        for (const edit of this.edits) {
+            if (edit.kind === "delete") {
+                lines.add(edit.anchor.line);
+                continue;
+            }
+            if (edit.kind === "block") {
+                lines.add(edit.anchor.line);
+                continue;
+            }
+            if (edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor") {
+                lines.add(edit.cursor.anchor.line);
+            }
+        }
+        return [...lines].sort((a, b) => a - b);
+    }
+    /**
+     * Apply this section's edits to `text` and return the post-edit result.
+     * Pure: does no I/O, does not validate the section snapshot tag. The
+     * {@link Patcher} owns tag validation and recovery; reach for this
+     * method directly when you've already validated the file content and
+     * just want the result.
+     *
+     * `blockResolver` resolves any `replace block N:` edits against `text`; an
+     * unresolvable block throws (this is the final, authoritative preview path).
+     */
+    applyTo(text, blockResolver) {
+        const { edits, warnings } = this.parse();
+        const resolved = resolveBlockEdits(edits, text, this.path, blockResolver, { onUnresolved: "throw" });
+        const result = applyEdits(text, resolved);
+        // Preserve parse warnings so consumers don't need to call `parse()`
+        // separately.
+        const merged = warnings.length === 0 ? result.warnings : [...warnings, ...(result.warnings ?? [])];
+        return merged && merged.length > 0
+            ? { ...result, warnings: merged }
+            : { text: result.text, firstChangedLine: result.firstChangedLine };
+    }
+    /**
+     * Streaming-tolerant counterpart to {@link applyTo}. Uses
+     * {@link parsePatchStreaming} so a trailing in-flight op (no payload yet,
+     * or a per-token parse error mid-stream) does not throw or emit a phantom
+     * empty-payload edit. Intended for incremental diff previews; the writer
+     * path should always use {@link applyTo}.
+     *
+     * `blockResolver` resolves any `replace block N:` edits against `text`; an
+     * unresolvable block is silently dropped so a half-written file does not
+     * throw mid-stream.
+     */
+    applyPartialTo(text, blockResolver) {
+        const { edits, warnings } = parsePatchStreaming(this.diff);
+        const resolved = resolveBlockEdits(edits, text, this.path, blockResolver, { onUnresolved: "drop" });
+        const result = applyEdits(text, resolved);
+        const merged = warnings.length === 0 ? result.warnings : [...warnings, ...(result.warnings ?? [])];
+        return merged && merged.length > 0
+            ? { ...result, warnings: merged }
+            : { text: result.text, firstChangedLine: result.firstChangedLine };
+    }
+}
+/**
+ * A parsed hashline patch — zero or more {@link PatchSection}s, each rooted
+ * at a `¶PATH#HASH` header. Construct via {@link Patch.parse}.
+ *
+ * `Patch` is pure data: parsing is line-anchored and does not look at the
+ * filesystem. To apply a patch, hand it to {@link Patcher.apply}.
+ */
+export class Patch {
+    sections;
+    constructor(sections) {
+        this.sections = sections;
+    }
+    /**
+     * Parse `input` into a {@link Patch}. `options.cwd` resolves absolute
+     * paths inside headers to cwd-relative form; `options.path` provides a
+     * fallback when the input lacks a header but contains hashline ops
+     * (useful for streaming previews).
+     *
+     * Consecutive sections targeting the same path are merged into a single
+     * section with concatenated diff bodies. Anchors authored against the
+     * same file snapshot must be applied as one batch; otherwise the first
+     * sub-edit shifts line numbers out from under the second's anchors and
+     * validation fails.
+     */
+    static parse(input, options = {}) {
+        const raw = mergeSamePathSections(splitRawSections(input, options));
+        return new Patch(raw.map((section) => new PatchSection(section)));
+    }
+    /**
+     * Parse `input` and return only the first section. Throws if the input
+     * has zero sections. Convenience for the single-section case where the
+     * caller already knows the patch is one hunk.
+     */
+    static parseSingle(input, options = {}) {
+        const patch = Patch.parse(input, options);
+        const first = patch.sections[0];
+        if (!first)
+            throw new Error("Patch input did not produce any sections.");
+        return first;
+    }
+}
+/**
+ * Collapse consecutive or interleaved sections targeting the same path into a
+ * single section with concatenated diffs. Anchors authored against the same
+ * file snapshot must be applied as one batch; otherwise the first sub-edit
+ * shifts line numbers out from under the second's anchors and validation
+ * fails. Path order is preserved by first occurrence.
+ */
+function mergeSamePathSections(sections) {
+    const byPath = new Map();
+    for (const section of sections) {
+        const existing = byPath.get(section.path);
+        if (existing) {
+            if (existing.fileHash !== undefined &&
+                section.fileHash !== undefined &&
+                existing.fileHash !== section.fileHash) {
+                throw new Error(`Conflicting hashline snapshot tags for ${section.path}: #${existing.fileHash} and #${section.fileHash}. Re-read the file and retry with one current header.`);
+            }
+            if (existing.fileHash === undefined && section.fileHash !== undefined)
+                existing.fileHash = section.fileHash;
+            existing.diffs.push(section.diff);
+            continue;
+        }
+        byPath.set(section.path, {
+            ...(section.fileHash !== undefined ? { fileHash: section.fileHash } : {}),
+            diffs: [section.diff],
+        });
+    }
+    return Array.from(byPath, ([sectionPath, entry]) => ({
+        path: sectionPath,
+        ...(entry.fileHash !== undefined ? { fileHash: entry.fileHash } : {}),
+        diff: entry.diffs.join("\n"),
+    }));
+}
+//# sourceMappingURL=input.js.map

package/dist/hashline/input.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.js","sourceRoot":"","sources":["../../src/hashline/input.ts"],"names":[],"mappings":"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"}

package/dist/hashline/messages.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Centralized error and warning text emitted by the hashline parser, applier,
+ * and patcher. Consolidating these as named constants makes them easy to
+ * audit and keeps wording stable across the rendering paths that surface
+ * them. Ported from oh-my-pi `packages/hashline/src/messages.ts`.
+ */
+/** Lines of context shown either side of a hash mismatch. */
+export declare const MISMATCH_CONTEXT = 2;
+/** Optional patch envelope start marker; silently consumed when present. */
+export declare const BEGIN_PATCH_MARKER = "*** Begin Patch";
+/** Optional patch envelope end marker; terminates parsing when encountered. */
+export declare const END_PATCH_MARKER = "*** End Patch";
+/**
+ * Recovery sentinel emitted by an agent loop when a contaminated tool-call
+ * stream is truncated mid-call. Behaves like {@link END_PATCH_MARKER} for
+ * parsing — terminates the line loop — and does not surface a warning.
+ */
+export declare const ABORT_MARKER = "*** Abort";
+/** Warning text appended when two consecutive hunks target the exact same concrete range. */
+export declare const REPLACE_PAIR_COALESCED_WARNING = "Detected two identical-range hashline hunks; kept only the second hunk. Issue ONE `replace N..M:` hunk per range \u2014 payload is the final desired content, never both old and new.";
+/** Warning text appended when an empty bodyless hunk is followed by an overlapping concrete hunk. */
+export declare const REPLACE_PAIR_COALESCED_OVERLAP_WARNING = "Detected an overlapping bare hashline hunk immediately followed by a concrete hunk; dropped the earlier bare hunk. Issue ONE `replace N..M:` hunk per range \u2014 payload is the final desired content, never both old and new.";
+/** Warning text appended when bare body rows are auto-converted to literal rows. */
+export declare const BARE_BODY_AUTO_PIPED_WARNING = "Auto-prefixed bare body row(s) with `+`. Body rows must be `+TEXT` literal lines; pasting raw code as payload is not a portable shape.";
+/** Error text emitted when a hunk body contains a unified-diff-style `-` row. */
+export declare const MINUS_ROW_REJECTED = "`-` rows are not valid; hashline ranges already name the lines being changed. To insert a literal line starting with `-`, write `+-\u2026`.";
+/** Error text emitted when a replace hunk has no body. */
+export declare const EMPTY_REPLACE = "`replace N..M:` needs at least one `+TEXT` body row. To delete lines, use `delete N..M`.";
+/** Error text emitted when a `replace block N:` hunk has no body. */
+export declare const EMPTY_BLOCK = "`replace block N:` needs at least one `+TEXT` body row. To delete a block, use `delete N..M` with the block's line range.";
+/**
+ * Error text emitted when a `replace block N:` anchor cannot be resolved to a
+ * syntactic block (unrecognized language, blank/out-of-range line, no node
+ * begins on line N such as a lone closing delimiter, or the resolved block has
+ * a syntax error). Names the offending line and steers back to an explicit
+ * `replace N..M:` range.
+ */
+export declare function blockUnresolvedMessage(line: number): string;
+/**
+ * Error text emitted when a `replace block N:` edit reaches a code path that
+ * has no {@link BlockResolver} wired in. In chances-cli this means the native
+ * tree-sitter addon is absent (capability-gated, task 02) — steer to an
+ * explicit `replace N..M:` range, which never needs native.
+ */
+export declare const BLOCK_RESOLVER_UNAVAILABLE = "`replace block N:` is not available here (the tree-sitter block resolver is unavailable \u2014 the native addon may be a slim build). Use `replace N..M:` with an explicit range.";
+/**
+ * Internal invariant error: `applyEdits` received an unresolved `replace block
+ * N:` edit. Block edits must be expanded by `resolveBlockEdits` before reaching
+ * the applier; hitting this is a wiring bug, not authored-input error.
+ */
+export declare const UNRESOLVED_BLOCK_INTERNAL = "internal error: unresolved `replace block` edit reached the applier (resolveBlockEdits was not run).";
+/** Error text emitted when a delete hunk receives a body row. */
+export declare const DELETE_TAKES_NO_BODY = "`delete N..M` does not take body rows. Remove the body, or use `replace N..M:`.";
+/** Error text emitted when a `delete block N` hunk receives a body row. */
+export declare const DELETE_BLOCK_TAKES_NO_BODY = "`delete block N` does not take body rows. Remove the body, or use `replace block N:` to replace the block.";
+/** Error text emitted when an insert hunk has no body. */
+export declare const EMPTY_INSERT = "`insert` needs at least one `+TEXT` body row.";
+/** Warning text emitted by `Recovery` when an external write fits a cached snapshot. */
+export declare const RECOVERY_EXTERNAL_WARNING = "Recovered from a stale file hash using a previous read snapshot (file changed externally between read and edit).";
+/** Warning text emitted by `Recovery` when a prior in-session edit advanced the hash. */
+export declare const RECOVERY_SESSION_CHAIN_WARNING = "Recovered from a stale file hash using an earlier in-session snapshot (the file hash advanced after a prior edit in this session).";
+/**
+ * Warning text emitted by `Recovery` when the session-chain replay
+ * fast-path was taken. Distinct from {@link RECOVERY_SESSION_CHAIN_WARNING}
+ * because replay is the less-certain mode: the structured-patch 3-way
+ * merge refused, the anchor-content gate passed, but a coincidental
+ * insert+delete pair earlier in the chain could still leave an anchor's
+ * line number pointing at a duplicated row. Surface the hedge so the
+ * model verifies before continuing.
+ */
+export declare const RECOVERY_SESSION_REPLAY_WARNING = "Recovered by replaying your edits onto the current file content \u2014 your previous edit in this session changed line(s) you re-targeted with a stale hash. Verify the diff matches your intent before continuing.";
+/**
+ * Warning emitted when an `insert head:` / `insert tail:` edit is applied to an
+ * existing file whose snapshot tag is stale (the file drifted since the read).
+ * Head/tail insert position is content-independent — "start"/"end" cannot move
+ * with drift — so this is non-fatal: the edit applies onto the live content and
+ * we surface the drift instead of hard-failing (unlike an anchored mismatch).
+ */
+export declare const HEADTAIL_DRIFT_WARNING = "Applied an `insert head:`/`insert tail:` edit onto the current file content even though the snapshot tag was stale (the file changed since your read). Head/tail position is content-independent, so the insert was not rejected \u2014 but re-read if the drift was unexpected.";
+/**
+ * Error text emitted when a hashline section omits the mandatory snapshot tag.
+ * The tag is REQUIRED on every section, enforced identically by the apply path
+ * ({@link Patcher.prepare}) and the preview/diff path, so both surfaces reuse
+ * this single builder to stay in lockstep.
+ */
+export declare function missingSnapshotTagMessage(sectionPath: string): string;
+//# sourceMappingURL=messages.d.ts.map

package/dist/hashline/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/hashline/messages.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,6DAA6D;AAC7D,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC,4EAA4E;AAC5E,eAAO,MAAM,kBAAkB,oBAAoB,CAAC;AAEpD,+EAA+E;AAC/E,eAAO,MAAM,gBAAgB,kBAAkB,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,YAAY,cAAc,CAAC;AAExC,6FAA6F;AAC7F,eAAO,MAAM,8BAA8B,0LACyI,CAAC;AAErL,qGAAqG;AACrG,eAAO,MAAM,sCAAsC,qOAC4K,CAAC;AAEhO,oFAAoF;AACpF,eAAO,MAAM,4BAA4B,2IACiG,CAAC;AAE3I,iFAAiF;AACjF,eAAO,MAAM,kBAAkB,gJAC2G,CAAC;AAE3I,0DAA0D;AAC1D,eAAO,MAAM,aAAa,6FACkE,CAAC;AAE7F,qEAAqE;AACrE,eAAO,MAAM,WAAW,8HACqG,CAAC;AAE9H;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM3D;AAED;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,sLACyI,CAAC;AAEjL;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,yGACkE,CAAC;AAEzG,iEAAiE;AACjE,eAAO,MAAM,oBAAoB,oFACkD,CAAC;AAEpF,2EAA2E;AAC3E,eAAO,MAAM,0BAA0B,+GACuE,CAAC;AAE/G,0DAA0D;AAC1D,eAAO,MAAM,YAAY,kDAAkD,CAAC;AAE5E,wFAAwF;AACxF,eAAO,MAAM,yBAAyB,qHAC8E,CAAC;AAErH,yFAAyF;AACzF,eAAO,MAAM,8BAA8B,uIAC2F,CAAC;AAEvI;;;;;;;;GAQG;AACH,eAAO,MAAM,+BAA+B,wNACsK,CAAC;AAEnN;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,qRAC4O,CAAC;AAEhR;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAErE"}