santree 0.5.1 → 0.5.3

package/dist/commands/dashboard.js

@@ -9,7 +9,7 @@ import * as fs from "fs";
 import * as path from "path";
 const require = createRequire(import.meta.url);
 const { version } = require("../../package.json");
-import { findMainRepoRoot, createWorktree, getDefaultBranch, getBaseBranch, hasInitScript, getInitScriptPath, removeWorktree, getDiffTool, } from "../lib/git.js";
+import { findMainRepoRoot, createWorktree, getDefaultBranch, getBaseBranch, hasInitScript, getInitScriptPath, removeWorktree, getDiffTool, getWorktreeStatus, stageFile, unstageFile, stageAll, unstageAll, discardFile, } from "../lib/git.js";
 import { run, spawnAsync } from "../lib/exec.js";
 import { resolveAgentBinary } from "../lib/ai.js";
 import { getInstalledClaudeVersion } from "../lib/version.js";
@@ -42,17 +42,72 @@ const CLAUDE_VERSION = getInstalledClaudeVersion() ?? "";
  *   R100\told/path\tnew/path
  * For renames/copies, the status code has a similarity suffix we strip.
  */
+/**
+ * Split combined-parameter SGR sequences (e.g. `\x1b[48;2;R;G;B;38;2;R;G;B m`)
+ * into separate single-attribute SGRs (`\x1b[48;2;...m\x1b[38;2;...m`).
+ *
+ * Why: Ink uses `slice-ansi` to clip text horizontally, and `slice-ansi`
+ * miscounts visible width on combined RGB bg+fg SGRs — it cuts the line at
+ * roughly half the requested visible width. Delta emits exactly this combined
+ * form on every styled token, so the diff pane was rendering content cut at
+ * arbitrary points (e.g. `from datetime i` instead of `from datetime import
+ * timedelta`). Splitting them sidesteps the slice-ansi bug without losing any
+ * styling — the terminal renders the two SGRs identically to the combined one.
+ */
+function splitCombinedSgr(s) {
+    return s.replace(/\x1b\[([0-9;]+)m/g, (_match, params) => {
+        const tokens = params.split(";");
+        const groups = [];
+        for (let i = 0; i < tokens.length; i++) {
+            const t = tokens[i];
+            if ((t === "38" || t === "48") && tokens[i + 1] === "2") {
+                groups.push([t, "2", tokens[i + 2], tokens[i + 3], tokens[i + 4]].join(";"));
+                i += 4;
+            }
+            else if ((t === "38" || t === "48") && tokens[i + 1] === "5") {
+                groups.push([t, "5", tokens[i + 2]].join(";"));
+                i += 2;
+            }
+            else {
+                groups.push(t);
+            }
+        }
+        if (groups.length <= 1)
+            return `\x1b[${params}m`;
+        return groups.map((g) => `\x1b[${g}m`).join("");
+    });
+}
 /**
  * Pipe `git diff` output through an external tool (e.g. delta) and return the
  * combined ANSI output. Uses spawn pipes — no shell — so the tool name is safe
  * even though we already validate it in getDiffTool().
  */
-function runPipedDiff(cwd, mergeBase, filePath, tool) {
+function runPipedDiff(cwd, gitArgs, tool, themeMode) {
     return new Promise((resolve, reject) => {
-        const git = spawn("git", ["-C", cwd, "diff", "--color=always", mergeBase, "--", filePath], {
+        const git = spawn("git", ["-C", cwd, ...gitArgs], {
             stdio: ["ignore", "pipe", "pipe"],
         });
-        const pager = spawn(tool, [], { stdio: ["pipe", "pipe", "pipe"] });
+        // Delta's syntax theme defaults are tuned for dark backgrounds — pale
+        // Monokai foreground on a light terminal becomes invisible. Force the
+        // theme flag matching santree's detected mode so colors stay readable.
+        const pagerArgs = tool === "delta" ? [themeMode === "light" ? "--light" : "--dark"] : [];
+        // Disable hyperlinks for delta: OSC 8 sequences (`\x1b]8;...`) are not
+        // handled by truncateVisible() — its CSI-only regex counts the URL
+        // bytes as visible characters, mangling line truncation and breaking
+        // terminal rendering of the wrapped text. Delta's CLI rejects an
+        // inline `--hyperlinks=false`, so override via GIT_CONFIG_PARAMETERS
+        // (delta reads its config from git). Also drop line-numbers — they
+        // eat ~6 cols of an already-narrow right pane.
+        const pagerEnv = tool === "delta"
+            ? {
+                ...process.env,
+                GIT_CONFIG_PARAMETERS: "'delta.hyperlinks=false' 'delta.line-numbers=false'",
+            }
+            : process.env;
+        const pager = spawn(tool, pagerArgs, {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: pagerEnv,
+        });
         let out = "";
         let err = "";
         git.stdout.pipe(pager.stdin);
@@ -72,7 +127,7 @@ function runPipedDiff(cwd, mergeBase, filePath, tool) {
                 reject(new Error(err || `${tool} exited with code ${code}`));
             }
             else {
-                resolve(out);
+                resolve(splitCombinedSgr(out));
             }
         });
     });
@@ -200,7 +255,7 @@ function CommandBar({ showWorkspace, mode = "default", }) {
     const dot = _jsx(Text, { dimColor: true, children: "  ·  " });
     const Key = ({ k }) => (_jsx(Text, { color: "cyan", bold: true, children: k }));
     if (mode === "diff") {
-        return (_jsxs(Text, { children: [_jsx(Key, { k: "j/k" }), _jsx(Text, { dimColor: true, children: " file" }), dot, _jsx(Key, { k: "\u21E7\u2191\u2193" }), _jsx(Text, { dimColor: true, children: " scroll" }), dot, _jsx(Key, { k: "g/G" }), _jsx(Text, { dimColor: true, children: " top/bot" }), dot, _jsx(Key, { k: "q" }), _jsx(Text, { dimColor: true, children: " close" })] }));
+        return (_jsxs(Text, { children: [_jsx(Key, { k: "j/k" }), _jsx(Text, { dimColor: true, children: " file" }), dot, _jsx(Key, { k: "\u21E7\u2191\u2193" }), _jsx(Text, { dimColor: true, children: " scroll" }), dot, _jsx(Key, { k: "\u2423" }), _jsx(Text, { dimColor: true, children: " stage" }), dot, _jsx(Key, { k: "a" }), _jsx(Text, { dimColor: true, children: " all" }), dot, _jsx(Key, { k: "d" }), _jsx(Text, { dimColor: true, children: " discard" }), dot, _jsx(Key, { k: "e" }), _jsx(Text, { dimColor: true, children: " edit" }), dot, _jsx(Key, { k: "q" }), _jsx(Text, { dimColor: true, children: " close" })] }));
     }
     return (_jsxs(Text, { children: [_jsx(Key, { k: "j/k" }), _jsx(Text, { dimColor: true, children: " nav" }), dot, _jsx(Key, { k: "\u21E7\u2191\u2193" }), _jsx(Text, { dimColor: true, children: " scroll" }), dot, _jsx(Key, { k: "1/2" }), _jsx(Text, { dimColor: true, children: " tabs" }), showWorkspace ? (_jsxs(_Fragment, { children: [dot, _jsx(Key, { k: "E" }), _jsx(Text, { dimColor: true, children: " workspace" })] })) : null, dot, _jsx(Key, { k: "R" }), _jsx(Text, { dimColor: true, children: " refresh" }), dot, _jsx(Key, { k: "q" }), _jsx(Text, { dimColor: true, children: " quit" })] }));
 }
@@ -519,8 +574,16 @@ export default function Dashboard() {
             await refresh(true);
         };
         init();
-        // Auto-refresh every 30s
-        refreshTimerRef.current = setInterval(() => refresh(), 30_000);
+        // Auto-refresh every 30s. While the diff overlay is open, also bump
+        // the diff refresh tick so new/removed files (created or deleted
+        // outside the dashboard) eventually show up. Stage/unstage already
+        // patch XY in place, so this is purely about file-set drift.
+        refreshTimerRef.current = setInterval(() => {
+            refresh();
+            if (stateRef.current.overlay === "diff") {
+                dispatch({ type: "DIFF_REFRESH_FILES" });
+            }
+        }, 30_000);
         return () => {
             if (refreshTimerRef.current)
                 clearInterval(refreshTimerRef.current);
@@ -586,17 +649,49 @@ export default function Dashboard() {
     useEffect(() => {
         if (state.overlay !== "diff" || !state.diffWorktreePath || !state.diffBaseBranch)
             return;
-        if (!state.diffLoadingFiles)
-            return;
         const cwd = state.diffWorktreePath;
         const base = state.diffBaseBranch;
         void (async () => {
             try {
                 const { stdout: mergeBaseOut } = await execAsync(`git -C "${cwd}" merge-base "${base}" HEAD`);
                 const mergeBase = mergeBaseOut.trim() || base;
-                const { stdout } = await execAsync(`git -C "${cwd}" diff --name-status "${mergeBase}"`);
+                const [{ stdout }, porcelain] = await Promise.all([
+                    execAsync(`git -C "${cwd}" diff --name-status "${mergeBase}"`),
+                    getWorktreeStatus(cwd).catch(() => []),
+                ]);
                 const files = parseNameStatus(stdout);
-                const ordered = flattenTreeFiles(files);
+                // Merge porcelain (working-tree state) into the merge-base file list.
+                // XY status drives stage/unstage UX; untracked files (`??`) only show
+                // up here since `git diff` ignores them.
+                const porcelainByPath = new Map();
+                for (const p of porcelain)
+                    porcelainByPath.set(p.path, p);
+                const enriched = files.map((f) => {
+                    const p = porcelainByPath.get(f.path);
+                    if (!p)
+                        return f;
+                    porcelainByPath.delete(f.path);
+                    return {
+                        ...f,
+                        indexStatus: p.index,
+                        workingStatus: p.working,
+                        isUntracked: p.index === "?" && p.working === "?",
+                    };
+                });
+                // Untracked entries left over → add as new DiffFile rows so they
+                // appear in the tree and can be staged.
+                for (const p of porcelainByPath.values()) {
+                    if (p.index === "?" && p.working === "?") {
+                        enriched.push({
+                            path: p.path,
+                            status: "?",
+                            indexStatus: p.index,
+                            workingStatus: p.working,
+                            isUntracked: true,
+                        });
+                    }
+                }
+                const ordered = flattenTreeFiles(enriched);
                 dispatch({ type: "DIFF_FILES_LOADED", files: ordered, mergeBase });
             }
             catch (err) {
@@ -604,7 +699,7 @@ export default function Dashboard() {
                 dispatch({ type: "DIFF_FILES_ERROR", error: msg });
             }
         })();
-    }, [state.overlay, state.diffWorktreePath, state.diffBaseBranch, state.diffLoadingFiles]);
+    }, [state.overlay, state.diffWorktreePath, state.diffBaseBranch, state.diffRefreshTick]);
     // ── Diff overlay: load content for selected file ──────────────────
     // If SANTREE_DIFF_TOOL is set, pipe `git diff` output through the tool so
     // the user's preferred renderer (delta, diff-so-fancy, etc.) handles
@@ -621,11 +716,27 @@ export default function Dashboard() {
         dispatch({ type: "DIFF_CONTENT_LOADING" });
         void (async () => {
             try {
-                if (tool) {
+                if (file.isUntracked) {
+                    // Untracked files aren't in `git diff` output — fake a "full
+                    // addition" diff via --no-index against /dev/null. git exits 1
+                    // when files differ; that's expected, so we capture stdout
+                    // regardless. Pipe through the configured tool when set so
+                    // untracked files get the same syntax highlighting as tracked
+                    // ones; otherwise fall back to spawnAsync + manual colorize.
+                    if (tool) {
+                        const content = await runPipedDiff(cwd, ["diff", "--color=always", "--no-index", "--", "/dev/null", file.path], tool, theme.mode);
+                        dispatch({ type: "DIFF_CONTENT_LOADED", content });
+                    }
+                    else {
+                        const { output } = await spawnAsync("git", ["-C", cwd, "diff", "--no-color", "--no-index", "--", "/dev/null", file.path], { cwd });
+                        dispatch({ type: "DIFF_CONTENT_LOADED", content: output });
+                    }
+                }
+                else if (tool) {
                     // Pipe git diff (with colors enabled so the tool can pass them
                     // through if desired) into the configured tool. Use spawn pipes
                     // rather than shell to avoid quoting concerns.
-                    const content = await runPipedDiff(cwd, mergeBase, file.path, tool);
+                    const content = await runPipedDiff(cwd, ["diff", "--color=always", mergeBase, "--", file.path], tool, theme.mode);
                     dispatch({ type: "DIFF_CONTENT_LOADED", content });
                 }
                 else {
@@ -645,6 +756,7 @@ export default function Dashboard() {
         state.diffMergeBase,
         state.diffFileIndex,
         state.diffFiles,
+        theme.mode,
     ]);
     // ── Actions ───────────────────────────────────────────────────────
     const launchWorkInTmux = useCallback(async (di, mode, worktreePath, contextFile) => {
@@ -1307,6 +1419,42 @@ export default function Dashboard() {
         }
         // Diff overlay
         if (state.overlay === "diff") {
+            // Pending discard modal — intercepts y/n/ESC/q so they don't
+            // also close the diff overlay.
+            if (state.diffPendingDiscard) {
+                const pd = state.diffPendingDiscard;
+                if (input === "y") {
+                    const cwd = state.diffWorktreePath;
+                    if (!cwd) {
+                        dispatch({ type: "DIFF_DISCARD_CANCEL" });
+                        return;
+                    }
+                    (async () => {
+                        try {
+                            await discardFile(cwd, pd.path, pd.isUntracked);
+                            dispatch({ type: "DIFF_DISCARD_CANCEL" });
+                            dispatch({ type: "DIFF_REFRESH_FILES" });
+                            dispatch({
+                                type: "SET_ACTION_MESSAGE",
+                                message: pd.isUntracked
+                                    ? `Deleted ${pd.path}`
+                                    : `Discarded changes in ${pd.path}`,
+                            });
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            dispatch({ type: "DIFF_DISCARD_CANCEL" });
+                            dispatch({ type: "SET_ACTION_MESSAGE", message: `Discard failed: ${msg}` });
+                        }
+                    })();
+                    return;
+                }
+                if (input === "n" || key.escape || input === "q") {
+                    dispatch({ type: "DIFF_DISCARD_CANCEL" });
+                    return;
+                }
+                return;
+            }
             if (key.escape || input === "q") {
                 dispatch({ type: "DIFF_CLOSE" });
                 return;
@@ -1362,6 +1510,98 @@ export default function Dashboard() {
                 dispatch({ type: "DIFF_FILE_SELECT", index: prev });
                 return;
             }
+            // Stage / unstage / discard — only meaningful when the worktree
+            // path is known. All ops dispatch DIFF_REFRESH_FILES so the
+            // porcelain status (and selection) updates immediately.
+            const cwd = state.diffWorktreePath;
+            const currentFile = state.diffFiles[state.diffFileIndex];
+            if (input === " " && cwd && currentFile) {
+                // Toggle: if anything is staged for this file, unstage it;
+                // otherwise stage. Files with no uncommitted state (only
+                // committed changes vs base) have no XY → no-op. Updates XY
+                // in place via porcelain re-fetch — no full reload, no spinner.
+                const xRaw = currentFile.indexStatus;
+                const yRaw = currentFile.workingStatus;
+                if (xRaw === undefined && yRaw === undefined) {
+                    dispatch({
+                        type: "SET_ACTION_MESSAGE",
+                        message: "No uncommitted changes to stage on this file",
+                    });
+                    return;
+                }
+                const x = xRaw ?? " ";
+                const isStaged = x !== " " && x !== "?";
+                const path = currentFile.path;
+                (async () => {
+                    try {
+                        if (isStaged)
+                            await unstageFile(cwd, path);
+                        else
+                            await stageFile(cwd, path);
+                        const porcelain = await getWorktreeStatus(cwd);
+                        dispatch({ type: "DIFF_STATUS_UPDATED", porcelain });
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        dispatch({
+                            type: "SET_ACTION_MESSAGE",
+                            message: `${isStaged ? "Unstage" : "Stage"} failed: ${msg}`,
+                        });
+                    }
+                })();
+                return;
+            }
+            if (input === "a" && cwd) {
+                // Stage-all if anything is unstaged or untracked; otherwise
+                // unstage everything. Untracked files have Y === "?" so they
+                // fall under "unstaged" — staging them adds them to the index.
+                // Same in-place porcelain refresh as `space`.
+                const anyUnstaged = state.diffFiles.some((f) => {
+                    const y = f.workingStatus;
+                    return y !== undefined && y !== " ";
+                });
+                (async () => {
+                    try {
+                        if (anyUnstaged)
+                            await stageAll(cwd);
+                        else
+                            await unstageAll(cwd);
+                        const porcelain = await getWorktreeStatus(cwd);
+                        dispatch({ type: "DIFF_STATUS_UPDATED", porcelain });
+                        dispatch({
+                            type: "SET_ACTION_MESSAGE",
+                            message: anyUnstaged ? "Staged all changes" : "Unstaged all changes",
+                        });
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        dispatch({ type: "SET_ACTION_MESSAGE", message: `Failed: ${msg}` });
+                    }
+                })();
+                return;
+            }
+            if (input === "d" && currentFile) {
+                if (currentFile.indexStatus === undefined && currentFile.workingStatus === undefined) {
+                    dispatch({
+                        type: "SET_ACTION_MESSAGE",
+                        message: "No uncommitted changes to discard",
+                    });
+                    return;
+                }
+                dispatch({
+                    type: "DIFF_DISCARD_OPEN",
+                    path: currentFile.path,
+                    isUntracked: !!currentFile.isUntracked,
+                });
+                return;
+            }
+            // Open the selected file in the user's editor — useful when
+            // the diff alone isn't enough context. Editor resolution
+            // matches the rest of santree (SANTREE_EDITOR > "code").
+            if (input === "e" && cwd && currentFile) {
+                openInEditor(path.join(cwd, currentFile.path));
+                return;
+            }
             return;
         }
         // Confirm delete overlay
@@ -1884,10 +2124,10 @@ export default function Dashboard() {
                                     const defaultBranch = getDefaultBranch();
                                     const label = branch === defaultBranch ? `${branch} (default)` : branch;
                                     return (_jsx(Text, { children: _jsxs(Text, { color: selected ? "cyan" : undefined, bold: selected, children: [selected ? "> " : "  ", label] }) }, branch));
-                                }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "j/k to navigate, Enter to select, ESC to cancel" })] }) })) : state.overlay === "confirm-delete" ? (_jsx(Box, { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 3, paddingY: 1, children: [_jsx(Text, { bold: true, color: "red", children: "Remove worktree?" }), _jsx(Text, { children: " " }), _jsx(Text, { children: selectedIssue?.worktree?.branch ?? "" }), selectedIssue?.worktree?.dirty && (_jsx(Text, { color: "yellow", children: "Warning: worktree has uncommitted changes" })), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: "red", bold: true, children: "y" }), "  Confirm"] }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", bold: true, children: "n" }), "  Cancel"] })] }) })) : state.overlay === "diff" ? (_jsx(DiffOverlay, { width: innerWidth, height: contentHeight, ticketId: state.diffTicketId ?? "", baseBranch: state.diffBaseBranch ?? "", files: state.diffFiles, fileIndex: state.diffFileIndex, fileScrollOffset: state.diffFileScrollOffset, content: state.diffContent, contentScrollOffset: state.diffContentScrollOffset, loadingFiles: state.diffLoadingFiles, loadingContent: state.diffLoadingContent, error: state.diffError, selectionBg: theme.selectionBg, leftWidthOverride: diffLeftWidth ?? undefined })) : state.overlay === "confirm-setup" ? (_jsx(Box, { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 3, paddingY: 1, children: [_jsx(Text, { bold: true, children: "Run setup script?" }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: ".santree/init.sh" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: "green", bold: true, children: "y" }), "  Run setup"] }), _jsxs(Text, { children: [_jsx(Text, { color: "yellow", bold: true, children: "n" }), "  Skip"] })] }) })) : (_jsxs(Box, { flexGrow: 1, children: [_jsx(Box, { width: leftWidth, children: state.activeTab === "reviews" ? (_jsx(ReviewList, { flatReviews: state.flatReviews, selectedIndex: state.reviewSelectedIndex, scrollOffset: state.reviewListScrollOffset, height: contentHeight, width: leftWidth, selectionBg: theme.selectionBg })) : state.flatIssues.length === 0 ? (_jsx(Box, { width: leftWidth, height: contentHeight, justifyContent: "center", alignItems: "center", children: _jsx(Text, { color: "yellow", children: "No active issues" }) })) : (_jsx(IssueList, { groups: state.groups, flatIssues: state.flatIssues, selectedIndex: state.selectedIndex, scrollOffset: state.listScrollOffset, height: contentHeight, width: leftWidth, selectionBg: theme.selectionBg })) }), _jsx(Box, { flexDirection: "column", width: 3, children: Array.from({ length: contentHeight }).map((_, i) => (_jsx(Text, { dimColor: true, children: " │ " }, i))) }), _jsx(Box, { width: rightWidth, children: state.activeTab === "reviews" && state.creatingForTicket ? (_jsxs(Box, { flexDirection: "column", width: rightWidth, height: contentHeight, children: [_jsxs(Text, { color: "yellow", bold: true, children: ["Setting up worktree for ", state.creatingForTicket, "..."] }), state.creationLogs
+                                }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "j/k to navigate, Enter to select, ESC to cancel" })] }) })) : state.overlay === "confirm-delete" ? (_jsx(Box, { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 3, paddingY: 1, children: [_jsx(Text, { bold: true, color: "red", children: "Remove worktree?" }), _jsx(Text, { children: " " }), _jsx(Text, { children: selectedIssue?.worktree?.branch ?? "" }), selectedIssue?.worktree?.dirty && (_jsx(Text, { color: "yellow", children: "Warning: worktree has uncommitted changes" })), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: "red", bold: true, children: "y" }), "  Confirm"] }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", bold: true, children: "n" }), "  Cancel"] })] }) })) : state.overlay === "diff" ? (_jsx(DiffOverlay, { width: innerWidth, height: contentHeight, ticketId: state.diffTicketId ?? "", baseBranch: state.diffBaseBranch ?? "", files: state.diffFiles, fileIndex: state.diffFileIndex, fileScrollOffset: state.diffFileScrollOffset, content: state.diffContent, contentScrollOffset: state.diffContentScrollOffset, loadingFiles: state.diffLoadingFiles, loadingContent: state.diffLoadingContent, error: state.diffError, selectionBg: theme.selectionBg, leftWidthOverride: diffLeftWidth ?? undefined, pendingDiscard: state.diffPendingDiscard })) : state.overlay === "confirm-setup" ? (_jsx(Box, { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 3, paddingY: 1, children: [_jsx(Text, { bold: true, children: "Run setup script?" }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: ".santree/init.sh" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: "green", bold: true, children: "y" }), "  Run setup"] }), _jsxs(Text, { children: [_jsx(Text, { color: "yellow", bold: true, children: "n" }), "  Skip"] })] }) })) : (_jsxs(Box, { flexGrow: 1, children: [_jsx(Box, { width: leftWidth, children: state.activeTab === "reviews" ? (_jsx(ReviewList, { flatReviews: state.flatReviews, selectedIndex: state.reviewSelectedIndex, scrollOffset: state.reviewListScrollOffset, height: contentHeight, width: leftWidth, selectionBg: theme.selectionBg })) : state.flatIssues.length === 0 ? (_jsx(Box, { width: leftWidth, height: contentHeight, justifyContent: "center", alignItems: "center", children: _jsx(Text, { color: "yellow", children: "No active issues" }) })) : (_jsx(IssueList, { groups: state.groups, flatIssues: state.flatIssues, selectedIndex: state.selectedIndex, scrollOffset: state.listScrollOffset, height: contentHeight, width: leftWidth, selectionBg: theme.selectionBg })) }), _jsx(Box, { flexDirection: "column", width: 3, children: Array.from({ length: contentHeight }).map((_, i) => (_jsx(Text, { dimColor: true, children: " │ " }, i))) }), _jsx(Box, { width: rightWidth, children: state.activeTab === "reviews" && state.creatingForTicket ? (_jsxs(Box, { flexDirection: "column", width: rightWidth, height: contentHeight, children: [_jsxs(Text, { color: "yellow", bold: true, children: ["Setting up worktree for ", state.creatingForTicket, "..."] }), state.creationLogs
                                             .split("\n")
                                             .slice(-(contentHeight - 1))
-                                            .map((line, i) => (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: line }) }, i)))] })) : state.activeTab === "reviews" ? (_jsx(ReviewDetailPanel, { item: selectedReview, scrollOffset: state.reviewDetailScrollOffset, height: contentHeight, width: rightWidth })) : state.overlay === "commit" ? (_jsx(CommitOverlay, { width: rightWidth, height: contentHeight, branch: state.commitBranch, ticketId: state.commitTicketId, gitStatus: state.commitGitStatus, phase: state.commitPhase, message: state.commitMessage, error: state.commitError, dispatch: dispatch, onSubmit: handleCommitSubmit })) : state.overlay === "pr-create" ? (_jsx(PrCreateOverlay, { width: rightWidth, height: contentHeight, branch: state.prCreateBranch, ticketId: state.prCreateTicketId, phase: state.prCreatePhase, error: state.prCreateError, url: state.prCreateUrl, body: state.prCreateBody, title: state.prCreateTitle, dispatch: dispatch })) : (_jsx(DetailPanel, { issue: selectedIssue, scrollOffset: state.detailScrollOffset, height: contentHeight, width: rightWidth, creatingForTicket: state.creatingForTicket, creationLogs: state.creationLogs })) })] })), _jsxs(Box, { children: [_jsx(Box, { width: leftWidth + separatorWidth, paddingX: 1, children: _jsx(CommandBar, { showWorkspace: hasWorkspaceFile, mode: state.overlay === "diff" ? "diff" : "default" }) }), _jsx(Box, { width: rightWidth, children: _jsx(ActionRow, { activeTab: state.activeTab, selectedIssue: selectedIssue, selectedReview: selectedReview, overlay: state.overlay }) })] })] })] }));
+                                            .map((line, i) => (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: line }) }, i)))] })) : state.activeTab === "reviews" ? (_jsx(ReviewDetailPanel, { item: selectedReview, scrollOffset: state.reviewDetailScrollOffset, height: contentHeight, width: rightWidth })) : state.overlay === "commit" ? (_jsx(CommitOverlay, { width: rightWidth, height: contentHeight, branch: state.commitBranch, ticketId: state.commitTicketId, gitStatus: state.commitGitStatus, phase: state.commitPhase, message: state.commitMessage, error: state.commitError, dispatch: dispatch, onSubmit: handleCommitSubmit })) : state.overlay === "pr-create" ? (_jsx(PrCreateOverlay, { width: rightWidth, height: contentHeight, branch: state.prCreateBranch, ticketId: state.prCreateTicketId, phase: state.prCreatePhase, error: state.prCreateError, url: state.prCreateUrl, body: state.prCreateBody, title: state.prCreateTitle, dispatch: dispatch })) : (_jsx(DetailPanel, { issue: selectedIssue, scrollOffset: state.detailScrollOffset, height: contentHeight, width: rightWidth, creatingForTicket: state.creatingForTicket, creationLogs: state.creationLogs })) })] })), _jsx(Box, { children: state.overlay === "diff" ? (_jsx(Box, { width: innerWidth, paddingX: 1, children: _jsx(CommandBar, { showWorkspace: hasWorkspaceFile, mode: "diff" }) })) : (_jsxs(_Fragment, { children: [_jsx(Box, { width: leftWidth + separatorWidth, paddingX: 1, children: _jsx(CommandBar, { showWorkspace: hasWorkspaceFile, mode: "default" }) }), _jsx(Box, { width: rightWidth, children: _jsx(ActionRow, { activeTab: state.activeTab, selectedIssue: selectedIssue, selectedReview: selectedReview, overlay: state.overlay }) })] })) })] })] }));
 }
 /**
  * Renders the per-issue action key hints (Resume / Editor / View diff / …)

package/dist/lib/dashboard/DiffOverlay.d.ts

@@ -19,6 +19,14 @@ interface Props {
      * formula when undefined. Always clamped against pane minimums.
      */
     leftWidthOverride?: number;
+    /**
+     * When non-null, render a confirmation modal over the body asking the user
+     * to confirm discarding tracked changes or deleting an untracked file.
+     */
+    pendingDiscard?: {
+        path: string;
+        isUntracked: boolean;
+    } | null;
 }
 interface RenderedRow {
     prefix: string;
@@ -27,6 +35,10 @@ interface RenderedRow {
     dim?: boolean;
     bold?: boolean;
     fileIndex: number | null;
+    xy?: {
+        index: string;
+        working: string;
+    };
 }
 export declare function flattenTreeFiles(files: DiffFile[]): DiffFile[];
 export interface DiffLayout {
@@ -57,5 +69,5 @@ export declare function computeDiffLayout(opts: {
     fileScrollOffset: number;
     leftWidthOverride?: number;
 }): DiffLayout;
-export default function DiffOverlay({ width, height, ticketId, baseBranch, files, fileIndex, fileScrollOffset, content, contentScrollOffset, loadingFiles, loadingContent, error, selectionBg, leftWidthOverride, }: Props): import("react/jsx-runtime").JSX.Element;
+export default function DiffOverlay({ width, height, ticketId, baseBranch, files, fileIndex, fileScrollOffset, content, contentScrollOffset, loadingFiles, loadingContent, error, selectionBg, leftWidthOverride, pendingDiscard, }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/lib/dashboard/DiffOverlay.js

@@ -75,12 +75,37 @@ function renderTree(dir, depth, rows, fileCounter) {
         }
         else {
             const idx = fileCounter.value++;
-            rows.push({
-                prefix: indent,
-                label: `${child.file.status} ${child.name}`,
-                color: statusColor(child.file.status),
-                fileIndex: idx,
-            });
+            const file = child.file;
+            const hasUncommitted = file.indexStatus !== undefined || file.workingStatus !== undefined;
+            if (hasUncommitted) {
+                // Lazygit-style XY display — XY conveys the staged/unstaged state,
+                // so we drop the merge-base status letter from the label to avoid
+                // redundant "M  M foo.ts"-style rows. The XY chars are colored at
+                // render time (green for index, red for working).
+                rows.push({
+                    prefix: indent,
+                    label: child.name,
+                    fileIndex: idx,
+                    xy: {
+                        index: file.indexStatus ?? " ",
+                        working: file.workingStatus ?? " ",
+                    },
+                });
+            }
+            else {
+                // Committed-only files (no working-tree state vs HEAD). Dimmed
+                // so the user can tell at a glance that stage/unstage/discard
+                // don't apply — only files showing a colored XY column are
+                // actionable. The merge-base status letter still tells the
+                // reviewer what changed vs base.
+                rows.push({
+                    prefix: indent,
+                    label: `${file.status} ${child.name}`,
+                    color: statusColor(file.status),
+                    dim: true,
+                    fileIndex: idx,
+                });
+            }
         }
     }
 }
@@ -206,7 +231,7 @@ function truncateVisible(s, max) {
     return out + "…";
 }
 // ── Component ─────────────────────────────────────────────────────────
-export default function DiffOverlay({ width, height, ticketId, baseBranch, files, fileIndex, fileScrollOffset, content, contentScrollOffset, loadingFiles, loadingContent, error, selectionBg = "#1e3a5f", leftWidthOverride, }) {
+export default function DiffOverlay({ width, height, ticketId, baseBranch, files, fileIndex, fileScrollOffset, content, contentScrollOffset, loadingFiles, loadingContent, error, selectionBg = "#1e3a5f", leftWidthOverride, pendingDiscard = null, }) {
     const layout = computeDiffLayout({
         width,
         height,
@@ -245,18 +270,37 @@ export default function DiffOverlay({ width, height, ticketId, baseBranch, files
         const p = currentFile.path;
         truncatedPath = p.length > pathRoom ? "…" + p.slice(-Math.max(0, pathRoom - 1)) : p;
     }
-    return (_jsxs(Box, { flexDirection: "column", width: width, height: height, overflow: "hidden", children: [_jsxs(Box, { flexShrink: 0, width: width, children: [_jsx(Text, { bold: true, color: "cyan", children: "Diff" }), _jsx(Text, { dimColor: true, children: meta }), currentFile && pathRoom > 0 && _jsx(Text, { dimColor: true, children: sep }), currentFile && pathRoom > 0 && _jsx(Text, { children: truncatedPath })] }), _jsx(Box, { flexShrink: 0, width: width, children: _jsx(Text, { dimColor: true, wrap: "truncate", children: "─".repeat(width) }) }), _jsxs(Box, { height: bodyHeight, flexShrink: 0, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", width: leftWidth, height: bodyHeight, overflow: "hidden", paddingRight: 1, children: loadingFiles ? (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { dimColor: true, children: " Loading files..." })] })) : error ? (_jsx(Text, { color: "red", children: error })) : files.length === 0 ? (_jsx(Text, { dimColor: true, children: "No changes" })) : (visibleRows.map((row, i) => {
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: height, overflow: "hidden", children: [_jsxs(Box, { flexShrink: 0, width: width, children: [_jsx(Text, { bold: true, color: "cyan", children: "Diff" }), _jsx(Text, { dimColor: true, children: meta }), currentFile && pathRoom > 0 && _jsx(Text, { dimColor: true, children: sep }), currentFile && pathRoom > 0 && _jsx(Text, { children: truncatedPath })] }), _jsx(Box, { flexShrink: 0, width: width, children: _jsx(Text, { dimColor: true, wrap: "truncate", children: "─".repeat(width) }) }), pendingDiscard ? (_jsx(Box, { height: bodyHeight, flexShrink: 0, justifyContent: "center", alignItems: "center", children: _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 3, paddingY: 1, children: [_jsx(Text, { bold: true, color: "red", children: pendingDiscard.isUntracked ? "Delete file?" : "Discard changes?" }), _jsx(Text, { children: " " }), _jsx(Text, { children: pendingDiscard.path }), pendingDiscard.isUntracked && (_jsx(Text, { color: "yellow", children: "Warning: untracked file will be permanently deleted" })), !pendingDiscard.isUntracked && (_jsx(Text, { color: "yellow", children: "Warning: uncommitted changes will be lost" })), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: "red", bold: true, children: "y" }), "  Confirm"] }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", bold: true, children: "n" }), "  Cancel"] })] }) })) : (_jsxs(Box, { height: bodyHeight, flexShrink: 0, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", width: leftWidth, height: bodyHeight, overflow: "hidden", paddingRight: 1, children: loadingFiles ? (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { dimColor: true, children: " Loading files..." })] })) : error ? (_jsx(Text, { color: "red", children: error })) : files.length === 0 ? (_jsx(Text, { dimColor: true, children: "No changes" })) : (visibleRows.map((row, i) => {
                             const absIdx = effectiveScroll + i;
                             const isSelected = absIdx === selectedRowIdx;
+                            const bg = isSelected ? selectionBg : undefined;
+                            // Lazygit-style XY rendering — index char (green) + working
+                            // char (red), then a separator and the file name. Each
+                            // nested <Text> gets the same backgroundColor so the
+                            // selection highlight covers the whole row uniformly.
+                            if (row.xy) {
+                                const x = row.xy.index || " ";
+                                const y = row.xy.working || " ";
+                                const xColor = x.trim() ? "green" : "gray";
+                                const yColor = y.trim() ? "red" : "gray";
+                                return (_jsxs(Text, { backgroundColor: bg, bold: row.bold || isSelected, wrap: "truncate", children: [_jsx(Text, { backgroundColor: bg, children: row.prefix }), _jsx(Text, { color: xColor, backgroundColor: bg, bold: true, children: x }), _jsx(Text, { color: yColor, backgroundColor: bg, bold: true, children: y }), _jsx(Text, { backgroundColor: bg, children: ` ${row.label}` })] }, i));
+                            }
                             const text = `${row.prefix}${row.label}`;
                             // Selected row keeps its own color (file-status hue or directory
                             // blue) but gets the theme-aware selection bg + bold so it stays
                             // readable in light and dark modes alike.
-                            return (_jsx(Text, { color: row.color, backgroundColor: isSelected ? selectionBg : undefined, bold: row.bold || isSelected, dimColor: row.dim, wrap: "truncate", children: text }, i));
+                            return (_jsx(Text, { color: row.color, backgroundColor: bg, bold: row.bold || isSelected, dimColor: row.dim, wrap: "truncate", children: text }, i));
                         })) }), _jsx(Box, { flexDirection: "column", height: bodyHeight, children: Array.from({ length: bodyHeight }).map((_, i) => (_jsx(Text, { dimColor: true, children: "\u2502" }, i))) }), _jsx(Box, { flexDirection: "column", width: rightWidth, height: bodyHeight, overflow: "hidden", paddingLeft: 1, children: loadingContent ? (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { dimColor: true, children: " Loading diff..." })] })) : !currentFile ? (_jsx(Text, { dimColor: true, children: "Select a file" })) : visibleLines.length === 0 ? (_jsx(Text, { dimColor: true, children: "(empty diff)" })) : (visibleLines.map((line, i) => {
                             // rightWidth includes the paddingLeft={1} of the wrapper Box,
                             // so usable column count is rightWidth - 1.
                             const cell = truncateVisible(line.text || " ", Math.max(1, rightWidth - 1));
-                            return (_jsx(Text, { color: line.color, bold: line.bold, dimColor: line.dim, children: cell }, i));
-                        })) })] })] }));
+                            // wrap="truncate" prevents Ink from soft-wrapping. Default
+                            // `wrap` mode measures byte length (counting ANSI escape
+                            // bytes as visible chars), which makes color-heavy lines
+                            // like syntax-highlighted code wrap *very* early — visible
+                            // content gets clobbered by the next row. truncateVisible
+                            // has already sized the cell, so `truncate` is a no-op for
+                            // already-fitting lines.
+                            return (_jsx(Text, { color: line.color, bold: line.bold, dimColor: line.dim, wrap: "truncate", children: cell }, i));
+                        })) })] }))] }));
 }

package/dist/lib/dashboard/types.d.ts

@@ -69,6 +69,9 @@ export interface DiffFile {
     path: string;
     status: DiffFileStatus;
     oldPath?: string;
+    indexStatus?: string;
+    workingStatus?: string;
+    isUntracked?: boolean;
 }
 export type CommitPhase = "idle" | "confirm-stage" | "awaiting-message" | "committing" | "pushing" | "done" | "error";
 export type PrCreatePhase = "idle" | "choose-mode" | "pushing" | "filling" | "review" | "confirm" | "creating" | "done" | "error";
@@ -126,6 +129,11 @@ export interface DashboardState {
     diffLoadingFiles: boolean;
     diffLoadingContent: boolean;
     diffError: string | null;
+    diffPendingDiscard: {
+        path: string;
+        isUntracked: boolean;
+    } | null;
+    diffRefreshTick: number;
 }
 export type DashboardAction = {
     type: "SET_DATA";
@@ -286,6 +294,21 @@ export type DashboardAction = {
 } | {
     type: "DIFF_CONTENT_SCROLL";
     offset: number;
+} | {
+    type: "DIFF_REFRESH_FILES";
+} | {
+    type: "DIFF_STATUS_UPDATED";
+    porcelain: {
+        path: string;
+        index: string;
+        working: string;
+    }[];
+} | {
+    type: "DIFF_DISCARD_OPEN";
+    path: string;
+    isUntracked: boolean;
+} | {
+    type: "DIFF_DISCARD_CANCEL";
 } | {
     type: "DIFF_CLOSE";
 };

package/dist/lib/dashboard/types.js

@@ -53,6 +53,8 @@ export const initialState = {
     diffLoadingFiles: false,
     diffLoadingContent: false,
     diffError: null,
+    diffPendingDiscard: null,
+    diffRefreshTick: 0,
 };
 export function reducer(state, action) {
     switch (action.type) {
@@ -301,17 +303,73 @@ export function reducer(state, action) {
                 diffLoadingFiles: true,
                 diffLoadingContent: false,
                 diffError: null,
+                diffPendingDiscard: null,
+                diffRefreshTick: 0,
             };
-        case "DIFF_FILES_LOADED":
+        case "DIFF_FILES_LOADED": {
+            // Preserve the user's selection across reloads (after stage/unstage/
+            // discard) by matching the previously-selected file's path. Falls back
+            // to the clamped index when the path is gone (e.g. file was discarded).
+            const prevPath = state.diffFiles[state.diffFileIndex]?.path;
+            let newIndex = 0;
+            if (prevPath) {
+                const found = action.files.findIndex((f) => f.path === prevPath);
+                if (found >= 0)
+                    newIndex = found;
+                else
+                    newIndex = Math.min(state.diffFileIndex, Math.max(0, action.files.length - 1));
+            }
             return {
                 ...state,
                 diffFiles: action.files,
                 diffMergeBase: action.mergeBase,
-                diffFileIndex: 0,
-                diffFileScrollOffset: 0,
+                diffFileIndex: newIndex,
                 diffLoadingFiles: false,
                 diffError: null,
             };
+        }
+        case "DIFF_REFRESH_FILES":
+            // Silent re-fetch — bumps the tick the loader effect depends on,
+            // without flipping diffLoadingFiles. The current file list stays
+            // rendered until the new one arrives, so there's no spinner blink.
+            return { ...state, diffRefreshTick: state.diffRefreshTick + 1 };
+        case "DIFF_STATUS_UPDATED": {
+            // In-place XY patch — used by stage/unstage where the file SET
+            // doesn't change, only the per-file porcelain status. Avoids the
+            // full reload's network/git latency and the spinner that goes
+            // with it.
+            const byPath = new Map();
+            for (const p of action.porcelain)
+                byPath.set(p.path, p);
+            const next = state.diffFiles.map((f) => {
+                const p = byPath.get(f.path);
+                if (!p) {
+                    // File no longer has any working-tree state — back to
+                    // committed-only. Strip the XY fields.
+                    if (f.indexStatus === undefined && f.workingStatus === undefined)
+                        return f;
+                    const cleared = { ...f };
+                    delete cleared.indexStatus;
+                    delete cleared.workingStatus;
+                    delete cleared.isUntracked;
+                    return cleared;
+                }
+                return {
+                    ...f,
+                    indexStatus: p.index,
+                    workingStatus: p.working,
+                    isUntracked: p.index === "?" && p.working === "?",
+                };
+            });
+            return { ...state, diffFiles: next };
+        }
+        case "DIFF_DISCARD_OPEN":
+            return {
+                ...state,
+                diffPendingDiscard: { path: action.path, isUntracked: action.isUntracked },
+            };
+        case "DIFF_DISCARD_CANCEL":
+            return { ...state, diffPendingDiscard: null };
         case "DIFF_FILES_ERROR":
             return {
                 ...state,
@@ -353,6 +411,7 @@ export function reducer(state, action) {
                 diffLoadingFiles: false,
                 diffLoadingContent: false,
                 diffError: null,
+                diffPendingDiscard: null,
             };
         default:
             return state;

package/dist/lib/git.d.ts

@@ -271,6 +271,45 @@ export declare function getDiffStat(baseBranch: string): string | null;
  * Returns null if there are no changes or on failure.
  */
 export declare function getDiffContent(baseBranch: string): string | null;
+/**
+ * One entry from `git status --porcelain=v1 -z`.
+ * `index` (X) = staged state; `working` (Y) = unstaged state. Each is a single
+ * char per the porcelain format: ' ', 'M', 'A', 'D', 'R', 'C', 'U', '?', '!'.
+ */
+export interface PorcelainEntry {
+    path: string;
+    index: string;
+    working: string;
+    oldPath?: string;
+}
+/**
+ * Read working-tree status as a list of porcelain entries. Uses NUL-delimited
+ * output so paths with spaces, quotes, or newlines parse unambiguously.
+ */
+export declare function getWorktreeStatus(cwd: string): Promise<PorcelainEntry[]>;
+/**
+ * Stage a single file. Works for new (untracked) and modified files.
+ */
+export declare function stageFile(cwd: string, filePath: string): Promise<void>;
+/**
+ * Unstage a single file. Uses `git restore --staged` (porcelain command,
+ * available since git 2.23 — already required elsewhere in santree).
+ */
+export declare function unstageFile(cwd: string, filePath: string): Promise<void>;
+/**
+ * Stage every uncommitted change in the worktree (new files, modifications, deletions).
+ */
+export declare function stageAll(cwd: string): Promise<void>;
+/**
+ * Unstage everything in the index (mixed reset on HEAD; working tree untouched).
+ */
+export declare function unstageAll(cwd: string): Promise<void>;
+/**
+ * Discard uncommitted changes for a single file.
+ * - Tracked: `git checkout HEAD -- <path>` restores both index and working tree.
+ * - Untracked: deletes the file from disk via fs.unlink.
+ */
+export declare function discardFile(cwd: string, filePath: string, isUntracked: boolean): Promise<void>;
 /**
  * Read the session state file for a given ticket.
  * Returns null if missing or "exited".

package/dist/lib/git.js

@@ -2,7 +2,7 @@ import { execSync, exec } from "child_process";
 import { promisify } from "util";
 import * as path from "path";
 import * as fs from "fs";
-import { run, runAsync } from "./exec.js";
+import { run, runAsync, spawnAsync } from "./exec.js";
 import { getMultiplexer } from "./multiplexer/index.js";
 const execAsync = promisify(exec);
 /**
@@ -623,6 +623,94 @@ export function getDiffStat(baseBranch) {
 export function getDiffContent(baseBranch) {
     return run(`git diff ${baseBranch}..HEAD`, { maxBuffer: 10 * 1024 * 1024 }) || null;
 }
+/**
+ * Read working-tree status as a list of porcelain entries. Uses NUL-delimited
+ * output so paths with spaces, quotes, or newlines parse unambiguously.
+ */
+export async function getWorktreeStatus(cwd) {
+    const { code, output } = await spawnAsync("git", ["-C", cwd, "status", "--porcelain=v1", "-z"], {
+        cwd,
+    });
+    if (code !== 0) {
+        throw new Error(`git status failed: ${output.trim()}`);
+    }
+    const entries = [];
+    const records = output.split("\0");
+    for (let i = 0; i < records.length; i++) {
+        const rec = records[i];
+        if (!rec)
+            continue;
+        // Format: "XY <path>" — first 2 chars are status, then a space.
+        if (rec.length < 3)
+            continue;
+        const index = rec.charAt(0);
+        const working = rec.charAt(1);
+        const main = rec.slice(3);
+        // Renames/copies are followed by a NUL-terminated oldPath in the next record.
+        if (index === "R" || index === "C" || working === "R" || working === "C") {
+            const oldPath = records[i + 1] ?? "";
+            i += 1;
+            entries.push({ index, working, path: main, oldPath });
+        }
+        else {
+            entries.push({ index, working, path: main });
+        }
+    }
+    return entries;
+}
+/**
+ * Stage a single file. Works for new (untracked) and modified files.
+ */
+export async function stageFile(cwd, filePath) {
+    const { code, output } = await spawnAsync("git", ["-C", cwd, "add", "--", filePath], { cwd });
+    if (code !== 0) {
+        throw new Error(`git add failed: ${output.trim()}`);
+    }
+}
+/**
+ * Unstage a single file. Uses `git restore --staged` (porcelain command,
+ * available since git 2.23 — already required elsewhere in santree).
+ */
+export async function unstageFile(cwd, filePath) {
+    const { code, output } = await spawnAsync("git", ["-C", cwd, "restore", "--staged", "--", filePath], { cwd });
+    if (code !== 0) {
+        throw new Error(`git restore --staged failed: ${output.trim()}`);
+    }
+}
+/**
+ * Stage every uncommitted change in the worktree (new files, modifications, deletions).
+ */
+export async function stageAll(cwd) {
+    const { code, output } = await spawnAsync("git", ["-C", cwd, "add", "-A"], { cwd });
+    if (code !== 0) {
+        throw new Error(`git add -A failed: ${output.trim()}`);
+    }
+}
+/**
+ * Unstage everything in the index (mixed reset on HEAD; working tree untouched).
+ */
+export async function unstageAll(cwd) {
+    const { code, output } = await spawnAsync("git", ["-C", cwd, "reset"], { cwd });
+    if (code !== 0) {
+        throw new Error(`git reset failed: ${output.trim()}`);
+    }
+}
+/**
+ * Discard uncommitted changes for a single file.
+ * - Tracked: `git checkout HEAD -- <path>` restores both index and working tree.
+ * - Untracked: deletes the file from disk via fs.unlink.
+ */
+export async function discardFile(cwd, filePath, isUntracked) {
+    if (isUntracked) {
+        const absolute = path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
+        await fs.promises.unlink(absolute);
+        return;
+    }
+    const { code, output } = await spawnAsync("git", ["-C", cwd, "checkout", "HEAD", "--", filePath], { cwd });
+    if (code !== 0) {
+        throw new Error(`git checkout HEAD failed: ${output.trim()}`);
+    }
+}
 /**
  * Get the path to the .santree/session-states directory.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "santree",
-	"version": "0.5.1",
+	"version": "0.5.3",
 	"description": "Git worktree manager",
 	"license": "MIT",
 	"author": "Santiago Toscanini",