dsh-diff-approval 0.36.1 → 0.37.1

package/lib/types/client/markdown-tree-match.d.ts

@@ -0,0 +1,163 @@
+/** One node of a parsed Markdown document. */
+export interface MarkdownTreeNode {
+    /** Stable path inside the document (`0.2.1`), for debugging and tests. */
+    id: string;
+    /** `marked`'s token type (`heading`, `paragraph`, `list_item`, `text`, …), or a synthetic one. */
+    type: string;
+    /** The node's own SOURCE spelling (what was written), used for span and exact-match comparisons. */
+    raw: string;
+    /** The node's plain text where the token has one (`text`, `code`, heading text, …). */
+    text: string;
+    /** The token's own attributes: heading depth, fence language, link href/title, list style, cell align. */
+    attrs: Record<string, string | number | boolean>;
+    children: MarkdownTreeNode[];
+    /** Absolute character offsets into the side's source: `[start, end)`. */
+    start: number;
+    end: number;
+    /** 1-based inclusive source lines the node covers. */
+    lines: {
+        start: number;
+        end: number;
+    };
+}
+/** One matched old/new node pair. */
+export interface TreeMatchPair {
+    old: MarkdownTreeNode;
+    new: MarkdownTreeNode;
+    /** Same source spelling for the whole node: nothing changed at or under it. */
+    exact: boolean;
+    /** How alike the two nodes' visible text is (1 = identical, 0 = nothing in common). */
+    similarity: number;
+    /** The match operations inside the pair, in reading order. */
+    children: TreeMatchOp[];
+}
+/** One alignment step: a pair, or a node that exists on one side only. */
+export type TreeMatchOp = {
+    kind: 'pair';
+    pair: TreeMatchPair;
+} | {
+    kind: 'oldOnly';
+    node: MarkdownTreeNode;
+} | {
+    kind: 'newOnly';
+    node: MarkdownTreeNode;
+};
+/** The whole-document match. */
+export interface TreeMatchResult {
+    oldRoot: MarkdownTreeNode[];
+    newRoot: MarkdownTreeNode[];
+    /** The outermost alignment, in reading order. */
+    ops: TreeMatchOp[];
+}
+/** What `flattenTreeMatch` returns: every pair and every one-sided node, pairs before their children. */
+export interface FlatTreeMatch {
+    pairs: TreeMatchPair[];
+    oldOnly: MarkdownTreeNode[];
+    newOnly: MarkdownTreeNode[];
+}
+/** Similarity of two pieces of visible text: longest common subsequence over the longer one (0..1). */
+export declare function textSimilarity(left: string, right: string): number;
+/**
+ * The visible text a node contributes: inline text and code spans verbatim, containers by their children,
+ * images by their alt, structure with no text (rules, comments) as `''`.
+ */
+export declare function nodeVisibleText(node: MarkdownTreeNode): string;
+/** The visible text of a node, whitespace-folded: what the preview's similarity compares. */
+export declare function nodeMatchText(node: MarkdownTreeNode): string;
+/** Parse one side into a forest, dropping the `space` tokens that only separate blocks. */
+export declare function parseMarkdownTree(text: string): MarkdownTreeNode[];
+/** How alike two nodes are: the similarity of their visible text (1 = identical, 0 = nothing in common). */
+export declare function nodeSimilarity(oldNode: MarkdownTreeNode, newNode: MarkdownTreeNode): number;
+/** Match two whole documents tree-first. */
+export declare function matchMarkdownTrees(oldText: string, newText: string): TreeMatchResult;
+/** Every pair and one-sided node of a match, pairs before their own children (pre-order). */
+export declare function flattenTreeMatch(ops: readonly TreeMatchOp[]): FlatTreeMatch;
+/**
+ * Whether a pair's whole subtree is UNCHANGED: the same node type and attributes, and every child fully
+ * matched (no one-sided child anywhere).
+ *
+ * This is the recursive definition the merge rules use. A table row is fully matched only when EVERY cell is;
+ * a table is fully matched only when its header cells and every body row are — so a table with one changed
+ * cell is not merged as a whole, while its matched rows still can be (see `siblingRuns`).
+ */
+export declare function pairFullyMatched(pair: TreeMatchPair): boolean;
+/**
+ * One run of adjacent siblings at ONE level, and whether the run is "merged" — i.e. every node in it is a
+ * fully-matched pair, so the reader can treat them as one unchanged stretch.
+ */
+export interface MatchedRun {
+    ops: TreeMatchOp[];
+    /** The whole run is fully-matched pairs: merge these siblings into one unchanged piece. */
+    merged: boolean;
+}
+/**
+ * Group a level's alignment into runs: adjacent FULLY-MATCHED siblings merge into one run; a run ends at any
+ * change (a modified pair, a node that exists on one side only). The caller can then treat each merged run as
+ * one unchanged piece and every other run as a difference to draw.
+ */
+export declare function siblingRuns(ops: readonly TreeMatchOp[]): MatchedRun[];
+/** One matched table's header run and body-row runs, kept apart (see `tableRowRuns`). */
+export interface TableRowRuns {
+    /** The header is ONE structural piece: merged only when EVERY header cell is fully matched. */
+    header: MatchedRun;
+    /** Body rows: adjacent fully-matched rows merge; a changed/inserted row ends the run. */
+    body: MatchedRun[];
+}
+/**
+ * A table's matched runs, HEADER and BODY kept apart.
+ *
+ * The header is one structural piece: it is either wholly matched (all cells) or not, and it never merges with
+ * the body rows into "one matched stretch" — a table whose header changed is a changed table even when every
+ * body row matches. Body rows follow the general rule: adjacent fully-matched rows merge; a row matches only
+ * when EVERY cell of it matches (a row with one changed cell is a difference row, not a merged one).
+ *
+ * @param pair - a matched `table` pair.
+ * @returns its header run and body runs, in reading order.
+ */
+export declare function tableRowRuns(pair: TreeMatchPair): TableRowRuns;
+/**
+ * Whether a node renders NOTHING at all, so a change to it can only be reported as invisible content (the
+ * eye-with-a-slash marker placed at its document position): front matter, an HTML comment, a link definition.
+ */
+export declare function isInvisibleNode(node: MarkdownTreeNode): boolean;
+/**
+ * One piece of the merge plan at one tree level: a CONTEXT stretch of fully-matched siblings (merged into one
+ * unchanged run) or a DIFFERENCE (a changed pair, or a node that exists on one side only).
+ */
+export interface MergePlanPiece {
+    kind: 'context' | 'diff';
+    /** For a context piece: the fully-matched sibling ops it merged (in order). */
+    ops?: TreeMatchOp[];
+    /** For a difference: the op it stands for. */
+    op?: TreeMatchOp;
+    /** The changes INSIDE a changed pair, as pieces of the next level down (same rules recursively). */
+    inner?: MergePlanPiece[];
+    /** The difference has no rendering (html comment, front matter, link definition): draw the icon marker. */
+    invisible?: boolean;
+    /** A node that exists on one side only. */
+    pure?: 'old' | 'new';
+}
+/**
+ * Plan the merge of one tree level: fully-matched adjacent siblings become CONTEXT runs; everything else is a
+ * DIFFERENCE piece, recursing into its type-specific internals.
+ *
+ * The rules this implements (user's decisions):
+ *  - at any level, adjacent FULLY-MATCHED siblings merge into one unchanged run;
+ *  - a fully-matched pair disappears into the context; a one-sided node is a pure deletion/addition;
+ *  - table: the header is one piece (partial header → per-cell differences), body rows merge when every cell
+ *    matches, and a row with any changed cell is a difference;
+ *  - list: a container whose own attributes changed is a difference, but its items are still matched and
+ *    planned item by item;
+ *  - code: the fence is one difference when its language or any code line changed, with its lines planned
+ *    inside (matched lines become context);
+ *  - blockquote: its children are planned with the same rules;
+ *  - an invisible node (html comment, front matter, link definition) is a difference flagged `invisible`.
+ *
+ * @param ops - the match operations of one tree level, in reading order.
+ * @returns the plan pieces of that level, in reading order.
+ */
+export declare function planMergedSiblings(ops: readonly TreeMatchOp[]): MergePlanPiece[];
+/** Whether a plan is entirely context (nothing to draw): true for a wholly unchanged tree level. */
+export declare function planIsAllContext(pieces: readonly MergePlanPiece[]): boolean;
+/** The node a character offset belongs to, deepest first: for tests and later span mapping. */
+export declare function nodeAtOffset(root: readonly MarkdownTreeNode[], offset: number): MarkdownTreeNode | undefined;

package/lib/types/client/settings.d.ts

@@ -239,6 +239,20 @@ export declare function commentModeEnabled(): boolean;
 export declare const COMMENT_MODE_CHANGED_EVENT = "diff-approval:comment-mode-changed";
 /** Persist the comment-mode preference (`'1'` on, `'0'` off — see {@link commentModeEnabled}). */
 export declare function setCommentModeEnabled(value: boolean): void;
+/** How the Markdown preview draws a diff (see `renderMarkdownPreview`). */
+export type MarkdownDiffStyle = 'structure' | 'blocks';
+/** Window event: the temporary structure-render switch was flipped (see {@link setTempPreviewV2Enabled}). */
+export declare const TEMP_PREVIEW_V2_CHANGED_EVENT = "diff-approval:temp-preview-v2-changed";
+/**
+ * Whether the temporary switch for the structure-rendered Markdown diff is on.
+ *
+ * Absent means OFF — the old preview keeps working exactly as before for a reader who never flips it.
+ *
+ * @returns whether the new preview is enabled.
+ */
+export declare function tempPreviewV2Enabled(): boolean;
+/** Persist the temporary structure-render switch, and tell the open panel to redraw. */
+export declare function setTempPreviewV2Enabled(value: boolean): void;
 /**
  * Whether the diff's code uses the font this plugin bundles.
  *

package/lib/types/comment-ask.d.ts

@@ -152,6 +152,21 @@ export declare class CommentAsker {
      * @returns what the request did.
      */
     ask(sessionId: SessionId, commentId: string, prompt: string, text: string, signal: AbortSignal, inScope: CommentScope): Promise<DiffApprovalCommentAskValue>;
+    /**
+     * Deliver one comment through the host's WAKE-UP seam, so the shell draws it as a trigger card.
+     *
+     * The seam is the one the host's own reminders use: resolve the live agent, publish a user message on
+     * it, then flush. The message's `source` is what the shell's closed switch turns into a card, and this
+     * plugin's client retitles its own source on the rendered DOM (an unknown kind falls back to a generic
+     * title). A host without the seam — or any failure asking for it — answers false, and the caller falls
+     * back to an ordinary prompt rather than losing the question.
+     *
+     * @param sessionId - the session whose live agent wakes.
+     * @param prompt - the prompt text to deliver verbatim.
+     * @param source - the comment's source marker, carried onto the message.
+     * @returns whether the message was published on the live agent.
+     */
+    private deliverAsCard;
     /**
      * One scope's questions, grouped by THE TRANSCRIPT each was submitted into.
      *

package/lib/types/types.d.ts

@@ -263,6 +263,24 @@ export interface DiffApprovalBlockRange {
     newStart: number;
     /** Last new-file line; `newStart - 1` when the block has no new side. */
     newEnd: number;
+    /**
+     * Character offsets into the two files, 0-based and end-exclusive, for a change finer than a whole line.
+     *
+     * Only the rendered-Markdown preview produces these, and only for changes that share a line with another
+     * change (a table row whose cell and whose link target both changed): such a change is kept or reverted on
+     * its own characters, while every line-based caller leaves these undefined and the host does exactly what
+     * it always did.
+     */
+    oldChars?: CharSpan;
+    /** The same change's span in the new file — see `oldChars`. */
+    newChars?: CharSpan;
+}
+/** One side's character span inside a file: `[start, end)`, 0-based. */
+export interface CharSpan {
+    /** First character offset of the change. */
+    start: number;
+    /** Offset just past the last changed character; equal to `start` for a pure insertion. */
+    end: number;
 }
 /** Target of one block-level keep/revert: the entry plus the block range. */
 export interface DiffApprovalBlockTarget {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-diff-approval",
-  "version": "0.36.1",
+  "version": "0.37.1",
   "description": "DeepSeek Harness plugin: pending-edit review with whole-file diff and Keep/Revert",
   "packageManager": "pnpm@11.21.0",
   "author": "Wu Zhiwei",
@@ -62,6 +62,7 @@
     "compat": "node scripts/dsh-compat.mjs",
     "compat:newer": "node scripts/dsh-compat.mjs --newer",
     "verify:release": "node scripts/verify-release.mjs",
+    "screenshots": "node scripts/screenshots.mjs",
     "fonts:check": "python -m scripts.fonts.build --check",
     "fonts:plan": "python -m scripts.fonts.build --plan",
     "prepare": "tsc -b tsconfig.json && tsdown --env.DSH_BUILD_FACE client",