@abelfubu/dv 0.1.0

package/dist/components/directory-tree-view.js

@@ -0,0 +1,262 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@opentuah/react/jsx-runtime";
+// DirectoryTreeView - Renders a directory tree with file status colors and change counts.
+// Shows added files in green, modified in default text, deleted in red, renamed in yellow.
+// Change counts (+n,-n) use green/red for the numbers, brackets are muted.
+// Supports fixed-width sidebar rendering with filename-preserving truncation.
+import * as React from "react";
+import { RGBA } from "@opentuah/core";
+import { buildHierarchicalTree } from "../directory-tree.js";
+import { getResolvedTheme, rgbaToHex } from "../themes.js";
+import { FOLDER_ICON_CLOSED, FOLDER_ICON_OPEN, getFileIcon } from "../tree-icons.js";
+const ICON_WIDTH = 3; // 2-char nerd font icon + 1 space
+export const DEFAULT_SIDEBAR_WIDTH = 60;
+/**
+ * Get the color for a file based on its status
+ * Uses diff colors from theme: green (added), red (deleted), yellow (renamed), default text (modified)
+ */
+function getStatusColor(status, theme) {
+    switch (status) {
+        case "added":
+            return rgbaToHex(theme.diffAdded); // green
+        case "deleted":
+            return rgbaToHex(theme.diffRemoved); // red
+        case "renamed":
+            return rgbaToHex(theme.warning); // yellow - renamed/moved file
+        case "modified":
+            return rgbaToHex(theme.text); // default text color, same as folders
+    }
+}
+function truncateKeepingEnd(text, maxWidth) {
+    if (maxWidth <= 0) {
+        return "";
+    }
+    if (text.length <= maxWidth) {
+        return text;
+    }
+    if (maxWidth === 1) {
+        return "…";
+    }
+    return `…${text.slice(-(maxWidth - 1))}`;
+}
+function getStatsParts(node) {
+    const additions = node.additions ?? 0;
+    const deletions = node.deletions ?? 0;
+    const hasAdditions = additions > 0;
+    const hasDeletions = deletions > 0;
+    let text = " (";
+    if (hasAdditions) {
+        text += `+${additions}`;
+    }
+    if (hasAdditions && hasDeletions) {
+        text += ",";
+    }
+    if (hasDeletions) {
+        text += `-${deletions}`;
+    }
+    text += ")";
+    return {
+        hasAdditions,
+        hasDeletions,
+        text,
+    };
+}
+/**
+ * Render a single tree node line with proper colors
+ */
+function TreeNodeLine({ node, theme, mutedColor, textColor, onSelect, width, isActive, isFocused, isCollapsed, transparentBackground, }) {
+    const [isHovered, setIsHovered] = React.useState(false);
+    const treePrefix = `${node.prefix}${node.connector}`;
+    const icon = node.isFile
+        ? getFileIcon(node.displayPath)
+        : isCollapsed
+            ? FOLDER_ICON_CLOSED
+            : FOLDER_ICON_OPEN;
+    const iconFg = isFocused ? rgbaToHex(theme.primary) : mutedColor;
+    if (node.isFile) {
+        // File node - colorize based on status
+        const pathColor = node.status ? getStatusColor(node.status, theme) : textColor;
+        const addColor = rgbaToHex(theme.diffAdded); // green
+        const delColor = rgbaToHex(theme.diffRemoved); // red
+        const stats = getStatsParts(node);
+        const availablePathWidth = Math.max(1, width - ICON_WIDTH - treePrefix.length - stats.text.length);
+        const truncatedPath = truncateKeepingEnd(node.displayPath, availablePathWidth);
+        const activeBg = isActive ? rgbaToHex(theme.primary.brighten(0.3)) : undefined;
+        const focusBg = isFocused ? rgbaToHex(theme.primary.brighten(0.15)) : undefined;
+        const hoverBg = isHovered && !transparentBackground ? rgbaToHex(theme.backgroundPanel) : RGBA.fromInts(0, 0, 0, 0);
+        const bgColor = activeBg ?? focusBg ?? hoverBg;
+        return (_jsxs("box", { style: {
+                flexDirection: "row",
+                width,
+                backgroundColor: bgColor,
+            }, onMouseMove: () => setIsHovered(true), onMouseOut: () => setIsHovered(false), children: [_jsx("text", { fg: mutedColor, children: treePrefix }), _jsxs("text", { fg: iconFg, children: [icon, " "] }), _jsx("text", { fg: pathColor, children: truncatedPath }), _jsx("text", { fg: mutedColor, children: " (" }), stats.hasAdditions && _jsxs("text", { fg: addColor, children: ["+", node.additions] }), stats.hasAdditions && stats.hasDeletions && _jsx("text", { fg: mutedColor, children: "," }), stats.hasDeletions && _jsxs("text", { fg: delColor, children: ["-", node.deletions] }), _jsx("text", { fg: mutedColor, children: ")" })] }));
+    }
+    const availablePathWidth = Math.max(1, width - ICON_WIDTH - treePrefix.length);
+    const truncatedPath = truncateKeepingEnd(node.displayPath, availablePathWidth);
+    // Directory node - use muted color for everything
+    const dirActiveBg = isActive ? rgbaToHex(theme.primary.brighten(0.3)) : undefined;
+    const dirFocusBg = isFocused ? rgbaToHex(theme.primary.brighten(0.15)) : undefined;
+    return (_jsxs("box", { style: { flexDirection: "row", width, backgroundColor: dirActiveBg ?? dirFocusBg }, children: [_jsx("text", { fg: mutedColor, children: treePrefix }), _jsxs("text", { fg: iconFg, children: [icon, " "] }), _jsx("text", { fg: textColor, children: truncatedPath })] }));
+}
+/**
+ * DirectoryTreeView component
+ * Renders a directory tree with file status colors and fixed-width truncation for sidebar layout.
+ */
+function flattenVisible(nodes, collapsedPaths, prefix = "") {
+    const result = [];
+    nodes.forEach((node) => {
+        result.push({
+            displayPath: node.displayPath,
+            fullPath: node.fullPath,
+            isFile: node.isFile,
+            fileIndex: node.fileIndex,
+            status: node.status,
+            additions: node.additions,
+            deletions: node.deletions,
+            prefix,
+            connector: "  ",
+        });
+        if (!node.isFile && !collapsedPaths.has(node.displayPath)) {
+            result.push(...flattenVisible(node.children, collapsedPaths, prefix + "  "));
+        }
+    });
+    return result;
+}
+export const DirectoryTreeView = React.forwardRef(function DirectoryTreeView({ files, onFileSelect, onFolderSelect, onFocusRowChange, themeName, width = DEFAULT_SIDEBAR_WIDTH, activeFileIndex, activeFolderPath, initialCollapsedPaths = [], transparentBackground, }, ref) {
+    const [collapsedPaths, setCollapsedPaths] = React.useState(() => new Set(initialCollapsedPaths));
+    const [focusedRowIndex, setFocusedRowIndex] = React.useState(0);
+    const onFileSelectRef = React.useRef(onFileSelect);
+    onFileSelectRef.current = onFileSelect;
+    const onFolderSelectRef = React.useRef(onFolderSelect);
+    onFolderSelectRef.current = onFolderSelect;
+    const hierarchicalNodes = React.useMemo(() => buildHierarchicalTree(files), [files]);
+    const visibleNodes = React.useMemo(() => flattenVisible(hierarchicalNodes, collapsedPaths), [hierarchicalNodes, collapsedPaths]);
+    React.useEffect(() => {
+        setFocusedRowIndex((prev) => Math.min(prev, Math.max(0, visibleNodes.length - 1)));
+    }, [visibleNodes.length]);
+    React.useEffect(() => {
+        onFocusRowChange?.(focusedRowIndex);
+    }, [focusedRowIndex, onFocusRowChange]);
+    const activeFileFolders = React.useMemo(() => {
+        const result = new Set();
+        if (activeFileIndex === undefined)
+            return result;
+        function walk(nodes) {
+            for (const node of nodes) {
+                if (node.isFile && node.fileIndex === activeFileIndex) {
+                    return true;
+                }
+                if (!node.isFile) {
+                    const hasActiveFile = walk(node.children);
+                    if (hasActiveFile) {
+                        result.add(node.displayPath);
+                    }
+                }
+            }
+            return false;
+        }
+        walk(hierarchicalNodes);
+        return result;
+    }, [hierarchicalNodes, activeFileIndex]);
+    React.useEffect(() => {
+        if (activeFolderPath) {
+            const idx = visibleNodes.findIndex((n) => !n.isFile && n.fullPath === activeFolderPath);
+            if (idx >= 0) {
+                setFocusedRowIndex(idx);
+                return;
+            }
+        }
+        if (activeFileIndex === undefined)
+            return;
+        const idx = visibleNodes.findIndex((n) => n.isFile && n.fileIndex === activeFileIndex);
+        if (idx >= 0) {
+            setFocusedRowIndex(idx);
+            return;
+        }
+        // Active file is hidden in a collapsed folder — focus the containing folder
+        for (let i = 0; i < visibleNodes.length; i++) {
+            const node = visibleNodes[i];
+            if (node && !node.isFile && collapsedPaths.has(node.displayPath) && activeFileFolders.has(node.displayPath)) {
+                setFocusedRowIndex(i);
+                return;
+            }
+        }
+    }, [activeFileIndex, activeFolderPath, visibleNodes, activeFileFolders, collapsedPaths]);
+    React.useImperativeHandle(ref, () => ({
+        focusNext() {
+            setFocusedRowIndex((prev) => {
+                const next = Math.min(visibleNodes.length - 1, prev + 1);
+                const node = visibleNodes[next];
+                if (node?.isFile && node.fileIndex !== undefined) {
+                    onFileSelectRef.current?.(node.fileIndex);
+                }
+                else if (node && !node.isFile) {
+                    onFolderSelectRef.current?.(node.fullPath);
+                }
+                return next;
+            });
+        },
+        focusPrev() {
+            setFocusedRowIndex((prev) => {
+                const next = Math.max(0, prev - 1);
+                const node = visibleNodes[next];
+                if (node?.isFile && node.fileIndex !== undefined) {
+                    onFileSelectRef.current?.(node.fileIndex);
+                }
+                else if (node && !node.isFile) {
+                    onFolderSelectRef.current?.(node.fullPath);
+                }
+                return next;
+            });
+        },
+        toggleCollapse() {
+            setFocusedRowIndex((prev) => {
+                const node = visibleNodes[prev];
+                if (!node || node.isFile)
+                    return prev;
+                const path = node.displayPath;
+                setCollapsedPaths((current) => {
+                    const next = new Set(current);
+                    if (next.has(path))
+                        next.delete(path);
+                    else
+                        next.add(path);
+                    return next;
+                });
+                return prev;
+            });
+        },
+        getActiveRowIndex() {
+            if (activeFolderPath) {
+                const idx = visibleNodes.findIndex((n) => !n.isFile && n.fullPath === activeFolderPath);
+                if (idx >= 0)
+                    return idx;
+            }
+            const idx = visibleNodes.findIndex((n) => n.isFile && n.fileIndex === activeFileIndex);
+            if (idx >= 0)
+                return idx;
+            for (let i = 0; i < visibleNodes.length; i++) {
+                const node = visibleNodes[i];
+                if (node && !node.isFile && collapsedPaths.has(node.displayPath) && activeFileFolders.has(node.displayPath)) {
+                    return i;
+                }
+            }
+            return 0;
+        },
+    }), [visibleNodes, activeFileFolders, activeFileIndex, activeFolderPath, collapsedPaths]);
+    const resolvedTheme = getResolvedTheme(themeName);
+    const mutedColor = rgbaToHex(resolvedTheme.textMuted);
+    const textColor = rgbaToHex(resolvedTheme.text);
+    if (visibleNodes.length === 0) {
+        return null;
+    }
+    return (_jsx("box", { style: {
+            flexDirection: "column",
+            width,
+        }, children: visibleNodes.map((node, idx) => (_jsx(TreeNodeLine, { node: node, theme: resolvedTheme, mutedColor: mutedColor, textColor: textColor, width: width, isActive: (node.isFile && node.fileIndex === activeFileIndex) ||
+                (!node.isFile && (node.fullPath === activeFolderPath ||
+                    (collapsedPaths.has(node.displayPath) && activeFileFolders.has(node.displayPath)))), isFocused: idx === focusedRowIndex, isCollapsed: !node.isFile && collapsedPaths.has(node.displayPath), transparentBackground: transparentBackground, onSelect: node.isFile && node.fileIndex !== undefined && onFileSelect
+                ? () => onFileSelect(node.fileIndex)
+                : !node.isFile && onFolderSelect
+                    ? () => onFolderSelect(node.fullPath)
+                    : undefined }, idx))) }));
+});

package/dist/components/index.d.ts

@@ -0,0 +1,4 @@
+export { DiffView, type DiffViewProps, type DiffViewRef } from "./diff-view.js";
+export { DEFAULT_SIDEBAR_WIDTH, DirectoryTreeView, type DirectoryTreeViewProps, type DirectoryTreeViewRef, } from "./directory-tree-view.js";
+export { Toast, type ToastProps } from "./toast.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/components/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC/E,OAAO,EACN,qBAAqB,EAAE,iBAAiB,EAAE,KAAK,sBAAsB,EAAE,KAAK,oBAAoB,GAChG,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAE,KAAK,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAA"}

package/dist/components/index.js

@@ -0,0 +1,5 @@
+// Shared React components for the TUI interface.
+// Exports reusable components used across main diff view and review mode.
+export { DiffView } from "./diff-view.js";
+export { DEFAULT_SIDEBAR_WIDTH, DirectoryTreeView, } from "./directory-tree-view.js";
+export { Toast } from "./toast.js";

package/dist/components/toast.d.ts

@@ -0,0 +1,21 @@
+import * as React from "react";
+import { type ResolvedTheme } from "../themes.js";
+export interface ToastProps {
+    /** Toast message body. */
+    message: string;
+    /** Visual style — success (green) or error (red). */
+    type: "success" | "error";
+    /** Optional title shown above the message. */
+    title?: string;
+    /** Current resolved theme for colors. */
+    theme: ResolvedTheme;
+    /** Whether the app is using a transparent background. */
+    transparentBackground?: boolean;
+}
+/**
+ * Render a floating toast notification directly onto the renderer's root
+ * using a post-render callback. This lets the toast overlay all other content
+ * without taking part in layout.
+ */
+export declare function Toast({ message, type, title, theme, transparentBackground }: ToastProps): React.ReactNode;
+//# sourceMappingURL=toast.d.ts.map

package/dist/components/toast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toast.d.ts","sourceRoot":"","sources":["../../src/components/toast.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD,MAAM,WAAW,UAAU;IACzB,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,qDAAqD;IACrD,IAAI,EAAE,SAAS,GAAG,OAAO,CAAA;IACzB,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,yCAAyC;IACzC,KAAK,EAAE,aAAa,CAAA;IACpB,yDAAyD;IACzD,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC;AAGD;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,qBAAqB,EAAE,EAAE,UAAU,GAAG,KAAK,CAAC,SAAS,CAwCzG"}

package/dist/components/toast.js

@@ -0,0 +1,47 @@
+// Floating toast notification used for transient copy feedback.
+import { RGBA, TextAttributes } from "@opentuah/core";
+import * as React from "react";
+import { useRenderer } from "@opentuah/react";
+import {} from "../themes.js";
+/**
+ * Render a floating toast notification directly onto the renderer's root
+ * using a post-render callback. This lets the toast overlay all other content
+ * without taking part in layout.
+ */
+export function Toast({ message, type, title, theme, transparentBackground }) {
+    const renderer = useRenderer();
+    React.useEffect(() => {
+        const borderColor = RGBA.fromHex(type === "success" ? "#2d8a47" : "#c53b53");
+        const bgColor = transparentBackground ? RGBA.fromInts(0, 0, 0, 0) : theme.background;
+        const fgColor = theme.text;
+        const icon = type === "success" ? "✓" : "✗";
+        const fullText = title ? `${icon} ${title} ${message}` : `${icon} ${message}`;
+        const toastWidth = Math.min(60, Math.max(20, fullText.length + 4));
+        const toastHeight = 3;
+        const x = Math.max(0, Math.floor((renderer.width - toastWidth) / 2));
+        const y = Math.max(0, Math.min(2, renderer.height - toastHeight));
+        const postProcess = (buffer, _deltaTime) => {
+            buffer.drawBox({
+                x,
+                y,
+                width: toastWidth,
+                height: toastHeight,
+                border: true,
+                borderStyle: "rounded",
+                borderColor,
+                backgroundColor: bgColor,
+                shouldFill: true,
+                title: undefined,
+                titleAlignment: "left",
+            });
+            buffer.drawText(fullText, x + 2, y + 1, fgColor, bgColor, TextAttributes.BOLD);
+        };
+        renderer.addPostProcessFn(postProcess);
+        renderer.requestRender();
+        return () => {
+            renderer.removePostProcessFn(postProcess);
+            renderer.requestRender();
+        };
+    }, [message, type, title, theme, transparentBackground, renderer]);
+    return null;
+}

package/dist/diff-cursor-utils.d.ts

@@ -0,0 +1,20 @@
+export interface DiffLogicalLine {
+    type: "hunk-header" | "context" | "add" | "remove" | "empty";
+    content: string;
+    oldLineNum?: number;
+    newLineNum?: number;
+}
+/**
+ * Rebuild the logical line order that DiffRenderable uses for its unified view.
+ * Each returned item corresponds to one row in the internal CodeRenderable content,
+ * so line indices match what DiffRenderable.highlightLines() expects.
+ *
+ * This mirrors opentuah's DiffRenderable.buildUnifiedView: consecutive removed
+ * and added lines are grouped into one change block, with all removed lines
+ * emitted before all added lines.
+ *
+ * Hunk headers are included as rows so cursor alignment stays correct, but they
+ * are skipped when extracting code.
+ */
+export declare function buildUnifiedLogicalLines(rawDiff: string): DiffLogicalLine[];
+//# sourceMappingURL=diff-cursor-utils.d.ts.map

package/dist/diff-cursor-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-cursor-utils.d.ts","sourceRoot":"","sources":["../src/diff-cursor-utils.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,aAAa,GAAG,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAA;IAC5D,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAoBD;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,EAAE,CA2E3E"}

package/dist/diff-cursor-utils.js

@@ -0,0 +1,105 @@
+// Utilities for keyboard-driven cursor/selection in the diff view.
+// Maps between logical diff lines (as rendered by DiffRenderable in unified view)
+// and user selections, so we can copy selected new content in markdown format.
+const HUNK_HEADER_RE = /^@@\s+-(\d+)(?:,\d+)?\s+\+(\d+)(?:,\d+)?\s+@@(.*)/;
+function isFileMetaLine(line) {
+    return (line.startsWith("diff --git") ||
+        line.startsWith("index ") ||
+        line.startsWith("--- ") ||
+        line.startsWith("+++ ") ||
+        line.startsWith("similarity index") ||
+        line.startsWith("rename from") ||
+        line.startsWith("rename to") ||
+        line.startsWith("copy from") ||
+        line.startsWith("copy to") ||
+        line.startsWith("new file mode") ||
+        line.startsWith("deleted file mode"));
+}
+/**
+ * Rebuild the logical line order that DiffRenderable uses for its unified view.
+ * Each returned item corresponds to one row in the internal CodeRenderable content,
+ * so line indices match what DiffRenderable.highlightLines() expects.
+ *
+ * This mirrors opentuah's DiffRenderable.buildUnifiedView: consecutive removed
+ * and added lines are grouped into one change block, with all removed lines
+ * emitted before all added lines.
+ *
+ * Hunk headers are included as rows so cursor alignment stays correct, but they
+ * are skipped when extracting code.
+ */
+export function buildUnifiedLogicalLines(rawDiff) {
+    const lines = [];
+    let oldLineNum = 0;
+    let newLineNum = 0;
+    const rawLines = rawDiff.split("\n");
+    let i = 0;
+    while (i < rawLines.length) {
+        const line = rawLines[i];
+        if (line === undefined || line.length === 0) {
+            i++;
+            continue;
+        }
+        if (line.startsWith("@@")) {
+            const match = HUNK_HEADER_RE.exec(line);
+            if (match) {
+                oldLineNum = parseInt(match[1], 10);
+                newLineNum = parseInt(match[2], 10);
+                const context = match[3].trimStart();
+                lines.push({ type: "hunk-header", content: context });
+            }
+            i++;
+            continue;
+        }
+        if (isFileMetaLine(line)) {
+            i++;
+            continue;
+        }
+        const firstChar = line[0];
+        const content = line.slice(1);
+        if (firstChar === " ") {
+            lines.push({ type: "context", content, oldLineNum, newLineNum });
+            oldLineNum++;
+            newLineNum++;
+            i++;
+        }
+        else if (firstChar === "\\") {
+            // "" marker — skip
+            i++;
+        }
+        else if (firstChar === "-" || firstChar === "+") {
+            // Collect a contiguous change block of removes and adds, then emit all
+            // removes followed by all adds (matching DiffRenderable grouping).
+            const removes = [];
+            const adds = [];
+            while (i < rawLines.length) {
+                const currentLine = rawLines[i];
+                if (currentLine === undefined || currentLine.length === 0)
+                    break;
+                const currentChar = currentLine[0];
+                if (currentChar === " " || currentChar === "\\")
+                    break;
+                const currentContent = currentLine.slice(1);
+                if (currentChar === "-") {
+                    removes.push({ content: currentContent, oldLineNum });
+                    oldLineNum++;
+                }
+                else if (currentChar === "+") {
+                    adds.push({ content: currentContent, newLineNum });
+                    newLineNum++;
+                }
+                i++;
+            }
+            for (const remove of removes) {
+                lines.push({ type: "remove", content: remove.content, oldLineNum: remove.oldLineNum });
+            }
+            for (const add of adds) {
+                lines.push({ type: "add", content: add.content, newLineNum: add.newLineNum });
+            }
+        }
+        else {
+            // Unknown line prefix — skip
+            i++;
+        }
+    }
+    return lines;
+}

package/dist/diff-cursor-utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=diff-cursor-utils.test.d.ts.map

package/dist/diff-cursor-utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-cursor-utils.test.d.ts","sourceRoot":"","sources":["../src/diff-cursor-utils.test.ts"],"names":[],"mappings":""}

package/dist/diff-cursor-utils.test.js

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "bun:test";
+import { buildUnifiedLogicalLines } from "./diff-cursor-utils.js";
+const sampleDiff = `diff --git a/src/utils.ts b/src/utils.ts
+index abc123..def456 100644
+--- a/src/utils.ts
++++ b/src/utils.ts
+@@ -1,4 +1,5 @@
+ function helper() {
+   const x = 1
+-  return x
++  // validate
++  return x + 1
+ }
+`;
+describe("buildUnifiedLogicalLines", () => {
+    it("builds logical lines in unified view order", () => {
+        const lines = buildUnifiedLogicalLines(sampleDiff);
+        expect(lines.map((l) => ({ type: l.type, content: l.content }))).toEqual([
+            { type: "hunk-header", content: "" },
+            { type: "context", content: "function helper() {" },
+            { type: "context", content: "  const x = 1" },
+            { type: "remove", content: "  return x" },
+            { type: "add", content: "  // validate" },
+            { type: "add", content: "  return x + 1" },
+            { type: "context", content: "}" },
+        ]);
+    });
+    it("tracks new and old line numbers", () => {
+        const lines = buildUnifiedLogicalLines(sampleDiff);
+        expect(lines[2].newLineNum).toBe(2);
+        expect(lines[3].oldLineNum).toBe(3);
+        expect(lines[4].newLineNum).toBe(3);
+        expect(lines[5].newLineNum).toBe(4);
+    });
+    it("ignores file metadata lines", () => {
+        const lines = buildUnifiedLogicalLines(sampleDiff);
+        expect(lines.some((l) => l.content.startsWith("diff --git"))).toBe(false);
+        expect(lines.some((l) => l.content.startsWith("index "))).toBe(false);
+    });
+});

package/dist/diff-surface-copy.d.ts

@@ -0,0 +1,23 @@
+import type { DiffRenderable } from "@opentuah/core";
+export interface CaptureSelectedDiffTextResult {
+    /** The captured text, or null if the renderable could not be read. */
+    text: string | null;
+    /** The first new line number in the selection, if available. */
+    startLineNum?: number;
+}
+/**
+ * Read the text currently shown on the selected logical rows of a DiffRenderable.
+ *
+ * - Unified view: returns the rendered unified diff rows.
+ * - Split view: returns the new (right-hand) side rows.
+ *
+ * The helper reaches into DiffRenderable private internals; callers should treat
+ * it as tightly coupled to the current opentuah implementation.
+ */
+export declare function captureSelectedDiffText(diffRenderable: DiffRenderable | null | undefined, selection: {
+    start: number;
+    end: number;
+}): CaptureSelectedDiffTextResult;
+/** Return the number of logical rows rendered by a DiffRenderable. */
+export declare function getDiffRenderableLineCount(diffRenderable: DiffRenderable | null | undefined): number;
+//# sourceMappingURL=diff-surface-copy.d.ts.map

package/dist/diff-surface-copy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-surface-copy.d.ts","sourceRoot":"","sources":["../src/diff-surface-copy.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD,MAAM,WAAW,6BAA6B;IAC5C,sEAAsE;IACtE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,gEAAgE;IAChE,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAgCD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,cAAc,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,EACjD,SAAS,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GACxC,6BAA6B,CAiC/B;AAED,sEAAsE;AACtE,wBAAgB,0BAA0B,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAOpG"}

package/dist/diff-surface-copy.js

@@ -0,0 +1,64 @@
+// Capture selected diff text directly from the rendered DiffRenderable surface.
+// This avoids reconstructing the patch from file.rawDiff and is immune to
+// balanceDelimiters drift because it copies exactly what is on screen.
+function getCodeRenderable(diff, view) {
+    const d = diff;
+    if (view === "split") {
+        return d.rightCodeRenderable;
+    }
+    return d.leftCodeRenderable;
+}
+function getLineNumbers(diff, view) {
+    const d = diff;
+    const side = view === "split" ? d.rightSide : d.leftSide;
+    return side?._lineNumbers;
+}
+/**
+ * Read the text currently shown on the selected logical rows of a DiffRenderable.
+ *
+ * - Unified view: returns the rendered unified diff rows.
+ * - Split view: returns the new (right-hand) side rows.
+ *
+ * The helper reaches into DiffRenderable private internals; callers should treat
+ * it as tightly coupled to the current opentuah implementation.
+ */
+export function captureSelectedDiffText(diffRenderable, selection) {
+    if (!diffRenderable) {
+        return { text: null };
+    }
+    const view = diffRenderable.view ?? "unified";
+    const codeRenderable = getCodeRenderable(diffRenderable, view);
+    if (!codeRenderable) {
+        return { text: null };
+    }
+    const allLines = codeRenderable.plainText.split("\n");
+    const startLogical = Math.min(selection.start, selection.end);
+    const endLogical = Math.max(selection.start, selection.end);
+    const selectedLines = [];
+    for (let i = startLogical; i <= endLogical; i++) {
+        if (i >= 0 && i < allLines.length) {
+            selectedLines.push(allLines[i]);
+        }
+    }
+    const lineNumbers = getLineNumbers(diffRenderable, view);
+    let startLineNum;
+    for (let i = startLogical; i <= endLogical; i++) {
+        const num = lineNumbers?.get(i);
+        if (num !== undefined) {
+            startLineNum = num;
+            break;
+        }
+    }
+    return { text: selectedLines.join("\n"), startLineNum };
+}
+/** Return the number of logical rows rendered by a DiffRenderable. */
+export function getDiffRenderableLineCount(diffRenderable) {
+    if (!diffRenderable)
+        return 0;
+    const view = diffRenderable.view ?? "unified";
+    const codeRenderable = getCodeRenderable(diffRenderable, view);
+    if (!codeRenderable)
+        return 0;
+    const text = codeRenderable.plainText;
+    return text.length === 0 ? 0 : text.split("\n").length;
+}

package/dist/diff-surface-copy.test.d.ts

@@ -0,0 +1,5 @@
+declare global {
+    var IS_REACT_ACT_ENVIRONMENT: boolean | undefined;
+}
+export {};
+//# sourceMappingURL=diff-surface-copy.test.d.ts.map

package/dist/diff-surface-copy.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-surface-copy.test.d.ts","sourceRoot":"","sources":["../src/diff-surface-copy.test.tsx"],"names":[],"mappings":"AASA,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,wBAAwB,EAAE,OAAO,GAAG,SAAS,CAAA;CAClD"}