santree 0.1.4 → 0.2.0

package/dist/commands/doctor.js

@@ -294,9 +294,9 @@ export default function Doctor() {
             const results = await Promise.all([
                 checkTool("git", "Version control", true, "git --version | head -1", "Install: brew install git"),
                 checkGhAuth(),
-                checkTool("tmux", "Terminal multiplexer", true, "tmux -V", "Install: brew install tmux"),
+                checkTool("tmux", "Terminal multiplexer", false, "tmux -V", "Install: brew install tmux"),
                 checkTool("claude", "Claude Code CLI", true, "claude --version 2>/dev/null | head -1", "Install: npm install -g @anthropic-ai/claude-code"),
-                checkTool("happy", "Claude CLI wrapper", true, "happy --version 2>/dev/null || echo 'installed'", "Install: npm install -g happy-coder"),
+                checkTool("happy", "Claude CLI wrapper (used over claude if installed)", false, "happy --version 2>/dev/null || echo 'installed'", "Install: npm install -g happy-coder"),
             ]);
             // Check for either code or cursor (only need one)
             const [codeCheck, cursorCheck] = await Promise.all([

package/dist/commands/helpers/template.d.ts

@@ -2,8 +2,8 @@ import { z } from "zod/v4";
 export declare const description = "Render a template to stdout";
 export declare const args: z.ZodTuple<[z.ZodEnum<{
     linear: "linear";
-    "git-changes": "git-changes";
     pr: "pr";
+    "git-changes": "git-changes";
     "fix-pr": "fix-pr";
     review: "review";
 }>], null>;

package/dist/commands/worktree/work.js

@@ -4,6 +4,8 @@ import { Text, Box } from "ink";
 import Spinner from "ink-spinner";
 import { z } from "zod";
 import { resolveAIContext, renderAIPrompt, launchAgent, cleanupImages, } from "../../lib/ai.js";
+import { randomUUID } from "crypto";
+import { getSessionId, setSessionId } from "../../lib/git.js";
 export const description = "Launch Claude to work on current ticket";
 export const options = z.object({
     plan: z.boolean().optional().describe("Only create implementation plan"),
@@ -45,8 +47,22 @@ export default function Work({ options }) {
             return;
         setStatus("launching");
         const prompt = renderAIPrompt("work", aiContext, { mode });
+        // Get or create a session ID for this ticket
+        let sessionId;
+        let isResume = false;
+        if (aiContext.ticketId) {
+            const existing = getSessionId(aiContext.mainRoot, aiContext.ticketId);
+            if (existing) {
+                sessionId = existing;
+                isResume = true;
+            }
+            else {
+                sessionId = randomUUID();
+                setSessionId(aiContext.mainRoot, aiContext.ticketId, sessionId);
+            }
+        }
         try {
-            const child = launchAgent(prompt, { planMode: mode === "plan" });
+            const child = launchAgent(prompt, { planMode: mode === "plan", sessionId, resume: isResume });
             child.on("error", (err) => {
                 setStatus("error");
                 setError(`Failed to launch agent: ${err.message}`);

package/dist/lib/ai.d.ts

@@ -36,6 +36,11 @@ export declare function fetchAndRenderPR(branch: string): Promise<string | null>
  * Returns rendered markdown.
  */
 export declare function fetchAndRenderDiff(branch: string): Promise<string>;
+/**
+ * Resolve which agent binary to use (happy if installed, otherwise claude).
+ * Returns the binary name, or null if neither is installed.
+ */
+export declare function resolveAgentBinary(): string | null;
 /**
  * Launch an interactive agent session with a prompt.
  * Resolves the agent binary (happy > claude), passes prompt directly
@@ -44,6 +49,8 @@ export declare function fetchAndRenderDiff(branch: string): Promise<string>;
  */
 export declare function launchAgent(prompt: string, opts?: {
     planMode?: boolean;
+    sessionId?: string;
+    resume?: boolean;
 }): ChildProcess;
 export interface RunAgentResult {
     success: boolean;

package/dist/lib/ai.js

@@ -105,10 +105,10 @@ export async function fetchAndRenderDiff(branch) {
     });
 }
 /**
- * Resolve which agent binary to use (happy or claude).
+ * Resolve which agent binary to use (happy if installed, otherwise claude).
  * Returns the binary name, or null if neither is installed.
  */
-function resolveAgentBinary() {
+export function resolveAgentBinary() {
     for (const bin of ["happy", "claude"]) {
         try {
             execSync(`which ${bin}`, { stdio: "ignore" });
@@ -150,6 +150,14 @@ export function launchAgent(prompt, opts) {
     if (opts?.planMode) {
         args.push("--permission-mode", "plan");
     }
+    if (opts?.sessionId) {
+        if (opts.resume) {
+            args.push("--resume", opts.sessionId);
+        }
+        else {
+            args.push("--session-id", opts.sessionId);
+        }
+    }
     args.push("--", promptArg(prompt));
     return spawn(bin, args, { stdio: "inherit" });
 }

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

@@ -0,0 +1,11 @@
+import type { DashboardIssue } from "./types.js";
+interface Props {
+    issue: DashboardIssue | null;
+    scrollOffset: number;
+    height: number;
+    width: number;
+    creatingForTicket: string | null;
+    creationLogs: string;
+}
+export default function DetailPanel({ issue, scrollOffset, height, width, creatingForTicket, creationLogs, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/dashboard/DetailPanel.js

@@ -0,0 +1,230 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+function stateColor(type) {
+    switch (type) {
+        case "started":
+            return "green";
+        case "unstarted":
+            return "blue";
+        case "backlog":
+            return "gray";
+        default:
+            return "yellow";
+    }
+}
+function parseGitStatus(raw) {
+    if (!raw)
+        return { staged: 0, unstaged: 0, untracked: 0, files: [] };
+    const lines = raw.split("\n").filter(Boolean);
+    let staged = 0;
+    let unstaged = 0;
+    let untracked = 0;
+    const files = [];
+    for (const line of lines) {
+        if (line.length < 2)
+            continue;
+        const x = line[0];
+        const y = line[1];
+        const file = line.slice(3);
+        if (x === "?") {
+            untracked++;
+        }
+        else {
+            if (x !== " ")
+                staged++;
+            if (y !== " ")
+                unstaged++;
+        }
+        files.push({ xy: line.slice(0, 2), file });
+    }
+    return { staged, unstaged, untracked, files };
+}
+function fileColor(xy) {
+    const x = xy[0];
+    if (x !== " " && x !== "?")
+        return "green";
+    if (xy.startsWith("??"))
+        return "gray";
+    return "yellow";
+}
+function buildActions(worktree, pr) {
+    const items = [];
+    // Work/Resume
+    if (worktree?.sessionId) {
+        items.push({ key: "↵", label: "Resume", color: "cyan" });
+    }
+    else if (worktree) {
+        items.push({ key: "w", label: "Work", color: "cyan" });
+        items.push({ key: "↵", label: "Switch", color: "cyan" });
+    }
+    else {
+        items.push({ key: "w", label: "Work", color: "cyan" });
+    }
+    // Editor
+    if (worktree) {
+        items.push({ key: "e", label: "Editor", color: "cyan" });
+    }
+    // Commit
+    if (worktree?.dirty) {
+        items.push({ key: "C", label: "Commit", color: "cyan" });
+    }
+    // PR actions
+    if (worktree && !pr) {
+        items.push({ key: "c", label: "Create PR", color: "cyan" });
+    }
+    if (pr) {
+        items.push({ key: "f", label: "Fix PR", color: "cyan" });
+        items.push({ key: "r", label: "Review", color: "cyan" });
+    }
+    // Links
+    items.push({ key: "o", label: "Linear", color: "gray" });
+    if (pr)
+        items.push({ key: "p", label: "Open PR", color: "gray" });
+    // Destructive
+    if (worktree) {
+        items.push({ key: "d", label: "Remove", color: "red" });
+    }
+    return [items];
+}
+export default function DetailPanel({ issue, scrollOffset, height, width, creatingForTicket, creationLogs, }) {
+    // Show creation logs when selected issue is being created
+    if (issue && issue.issue.identifier === creatingForTicket) {
+        const logLines = creationLogs.split("\n");
+        const contentRows = height - 1;
+        const startIdx = Math.max(0, logLines.length - contentRows);
+        const visible = logLines.slice(startIdx, startIdx + contentRows);
+        return (_jsxs(Box, { flexDirection: "column", width: width, height: height, children: [_jsxs(Text, { color: "yellow", bold: true, children: ["Setting up worktree for ", creatingForTicket, "..."] }), visible.map((line, i) => (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: line }) }, i)))] }));
+    }
+    if (!issue) {
+        return (_jsx(Box, { width: width, height: height, justifyContent: "center", alignItems: "center", children: _jsx(Text, { dimColor: true, children: "No issue selected" }) }));
+    }
+    const { issue: li, worktree, pr } = issue;
+    const lines = [];
+    const rule = "─".repeat(width);
+    // ── Hero: identifier + title ──────────────────────────────────────
+    lines.push({ text: `${li.identifier}  ${li.title}`, bold: true });
+    const meta = [];
+    meta.push(li.state.name);
+    meta.push(li.priorityLabel);
+    if (li.labels.length > 0)
+        meta.push(li.labels.join(", "));
+    lines.push({ text: meta.join(" · "), color: stateColor(li.state.type) });
+    // ── Description ───────────────────────────────────────────────────
+    if (li.description) {
+        lines.push({ text: rule, dim: true });
+        lines.push({ text: "" });
+        for (const dLine of li.description.trimEnd().split("\n")) {
+            lines.push({ text: dLine });
+        }
+        lines.push({ text: "" });
+    }
+    // ── Worktree (enhanced) ───────────────────────────────────────────
+    lines.push({ text: rule, dim: true });
+    lines.push({ text: "WORKTREE", dim: true });
+    if (worktree) {
+        lines.push({ text: `  ${worktree.branch}` });
+        lines.push({ text: `  ${worktree.path}`, dim: true });
+        const gs = parseGitStatus(worktree.gitStatus);
+        const statusParts = [];
+        if (gs.staged > 0)
+            statusParts.push(`+${gs.staged} staged`);
+        if (gs.unstaged > 0)
+            statusParts.push(`~${gs.unstaged} unstaged`);
+        if (gs.untracked > 0)
+            statusParts.push(`?${gs.untracked} untracked`);
+        if (worktree.commitsAhead > 0)
+            statusParts.push(`+${worktree.commitsAhead} ahead`);
+        if (statusParts.length > 0) {
+            lines.push({
+                text: `  ${statusParts.join("  ")}`,
+                color: worktree.dirty ? "yellow" : "green",
+            });
+        }
+        else {
+            lines.push({ text: "  ✓ clean", color: "green" });
+        }
+        // Show individual files (up to 8)
+        const maxFiles = 8;
+        for (let i = 0; i < Math.min(gs.files.length, maxFiles); i++) {
+            const f = gs.files[i];
+            lines.push({ text: `    ${f.xy} ${f.file}`, color: fileColor(f.xy) });
+        }
+        if (gs.files.length > maxFiles) {
+            lines.push({ text: `    +${gs.files.length - maxFiles} more`, dim: true });
+        }
+        if (worktree.sessionId) {
+            lines.push({ text: `  session: ${worktree.sessionId}`, color: "cyan" });
+        }
+        else {
+            lines.push({ text: "  session: none", color: "red" });
+        }
+    }
+    else {
+        lines.push({ text: "  –", dim: true });
+    }
+    // ── Pull Request ──────────────────────────────────────────────────
+    const { checks, reviews } = issue;
+    lines.push({ text: rule, dim: true });
+    lines.push({ text: "PULL REQUEST", dim: true });
+    if (pr) {
+        const sc = pr.state === "MERGED" ? "magenta" : pr.state === "OPEN" ? "green" : "red";
+        const draft = pr.isDraft ? " draft" : "";
+        lines.push({ text: `  #${pr.number} ${pr.state}${draft}`, color: sc });
+        if (pr.url) {
+            lines.push({ text: `  ${pr.url}`, dim: true });
+        }
+    }
+    else {
+        lines.push({ text: "  –", dim: true });
+    }
+    // ── Checks ────────────────────────────────────────────────────────
+    if (checks && checks.length > 0) {
+        const passCount = checks.filter((c) => c.bucket === "pass").length;
+        lines.push({ text: rule, dim: true });
+        lines.push({ text: `CHECKS  ${passCount}/${checks.length} passing`, dim: true });
+        for (const check of checks) {
+            if (check.bucket === "pass") {
+                lines.push({ text: `  ✓ ${check.name}`, color: "green" });
+            }
+            else if (check.bucket === "fail") {
+                const desc = check.description ? ` — ${check.description}` : "";
+                lines.push({ text: `  ✗ ${check.name}${desc}`, color: "red" });
+            }
+            else {
+                lines.push({ text: `  ● ${check.name} (pending)`, color: "yellow" });
+            }
+        }
+    }
+    // ── Reviews ───────────────────────────────────────────────────────
+    if (reviews && reviews.length > 0) {
+        lines.push({ text: rule, dim: true });
+        lines.push({ text: "REVIEWS", dim: true });
+        for (const review of reviews) {
+            const author = review.author.login;
+            const rc = review.state === "APPROVED"
+                ? "green"
+                : review.state === "CHANGES_REQUESTED"
+                    ? "red"
+                    : "yellow";
+            lines.push({ text: `  ${author}  ${review.state}`, color: rc });
+        }
+    }
+    // ── Build actions footer ──────────────────────────────────────────
+    const actionRows = buildActions(worktree, pr);
+    // +1 for the separator line
+    const actionsHeight = actionRows.length + 1;
+    const scrollableHeight = height - actionsHeight;
+    // ── Render scrollable content ─────────────────────────────────────
+    const totalLines = lines.length;
+    const canScroll = totalLines > scrollableHeight;
+    const contentRows = canScroll ? scrollableHeight - 2 : scrollableHeight;
+    const clampedOffset = Math.min(scrollOffset, Math.max(0, totalLines - contentRows));
+    const visible = lines.slice(clampedOffset, clampedOffset + contentRows);
+    let scrollArrow = null;
+    if (canScroll) {
+        const atTop = clampedOffset === 0;
+        const atBottom = clampedOffset + contentRows >= totalLines;
+        scrollArrow = atTop ? "↓ scroll" : atBottom ? "↑ scroll" : "↑↓ scroll";
+    }
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: height, children: [visible.map((line, i) => (_jsx(Box, { children: _jsx(Text, { color: line.color, bold: line.bold, dimColor: line.dim, children: line.text || " " }) }, i))), scrollArrow && (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: " " }) })), scrollArrow && (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: scrollArrow }) })), _jsx(Box, { flexGrow: 1 }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: rule }) }), actionRows.map((row, i) => (_jsx(Box, { children: row.map((item, j) => (_jsxs(Text, { children: ["  ", _jsx(Text, { color: item.color, bold: true, children: item.key }), _jsxs(Text, { color: item.color === "gray" ? "gray" : "white", children: [" ", item.label] })] }, j))) }, `a-${i}`)))] }));
+}

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

@@ -0,0 +1,13 @@
+import type { ProjectGroup, DashboardIssue } from "./types.js";
+interface Props {
+    groups: ProjectGroup[];
+    flatIssues: DashboardIssue[];
+    selectedIndex: number;
+    scrollOffset: number;
+    height: number;
+    width: number;
+    creatingForTicket: string | null;
+    deletingForTicket: string | null;
+}
+export default function IssueList({ groups, flatIssues, selectedIndex, scrollOffset, height, width, creatingForTicket, deletingForTicket, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/dashboard/IssueList.js

@@ -0,0 +1,112 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+function stateColor(type) {
+    switch (type) {
+        case "started":
+            return "green";
+        case "unstarted":
+            return "blue";
+        case "backlog":
+            return "gray";
+        default:
+            return "yellow";
+    }
+}
+function priorityIndicator(priority) {
+    switch (priority) {
+        case 1:
+            return { text: "!!!", color: "red" };
+        case 2:
+            return { text: "!! ", color: "yellow" };
+        case 3:
+            return { text: "!  ", color: "blue" };
+        case 4:
+            return { text: "·  ", color: "gray" };
+        default:
+            return { text: "   ", color: "gray" };
+    }
+}
+function checksIndicator(checks) {
+    if (!checks || checks.length === 0)
+        return { text: "-", color: "gray" };
+    if (checks.some((c) => c.bucket === "fail"))
+        return { text: "✗", color: "red" };
+    if (checks.every((c) => c.bucket === "pass"))
+        return { text: "✓", color: "green" };
+    return { text: "●", color: "yellow" };
+}
+function prIndicator(pr) {
+    if (!pr)
+        return { text: "-", color: "gray" };
+    const label = `#${pr.number}`;
+    if (pr.state === "MERGED")
+        return { text: label, color: "magenta" };
+    if (pr.state === "CLOSED")
+        return { text: label, color: "red" };
+    if (pr.isDraft)
+        return { text: label, color: "gray" };
+    return { text: label, color: "green" };
+}
+function sessionIndicator(wt, isCreating, isDeleting) {
+    if (isDeleting)
+        return { text: " deleting", color: "red" };
+    if (isCreating)
+        return { text: " creating", color: "yellow" };
+    if (!wt)
+        return { text: " -", color: "gray" };
+    if (wt.sessionId)
+        return { text: " " + wt.sessionId.slice(0, 8), color: "cyan" };
+    return { text: " none", color: "red" };
+}
+function buildRows(groups, flatIssues) {
+    const rows = [{ kind: "columns" }];
+    // Build a map from issue identifier to flat index
+    const indexMap = new Map();
+    flatIssues.forEach((di, i) => indexMap.set(di.issue.identifier, i));
+    for (const group of groups) {
+        rows.push({ kind: "header", name: group.name, count: group.issues.length });
+        for (const di of group.issues) {
+            rows.push({ kind: "issue", issue: di, flatIndex: indexMap.get(di.issue.identifier) ?? -1 });
+        }
+    }
+    return rows;
+}
+const FOOTER_HEIGHT = 2;
+export default function IssueList({ groups, flatIssues, selectedIndex, scrollOffset, height, width, creatingForTicket, deletingForTicket, }) {
+    const rows = buildRows(groups, flatIssues);
+    const listHeight = height - FOOTER_HEIGHT;
+    const visible = rows.slice(scrollOffset, scrollOffset + listHeight);
+    // 2 cursor + 2 dot + 4 priority + 11 id + title + 9 session + 1 space + 6 pr + 1 space + 2 checks
+    const prColWidth = 6;
+    const checksColWidth = 2;
+    const sessionColWidth = 9;
+    const priorityColWidth = 4;
+    const fixedWidth = 2 + 2 + priorityColWidth + 11 + sessionColWidth + 1 + prColWidth + 1 + checksColWidth;
+    const titleMaxWidth = Math.max(width - fixedWidth, 10);
+    const footerRule = "─".repeat(width);
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: height, children: [_jsx(Box, { flexDirection: "column", height: listHeight, children: visible.map((row, i) => {
+                    if (row.kind === "columns") {
+                        const labelPad = 14 + priorityColWidth + titleMaxWidth;
+                        return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "".padEnd(labelPad) }), _jsx(Text, { dimColor: true, children: "session".padStart(sessionColWidth) }), _jsx(Text, { dimColor: true, children: " " }), _jsx(Text, { dimColor: true, children: "pr".padStart(prColWidth) }), _jsx(Text, { dimColor: true, children: " " }), _jsx(Text, { dimColor: true, children: "ci".padStart(checksColWidth) })] }, "col-header"));
+                    }
+                    if (row.kind === "header") {
+                        return (_jsx(Box, { children: _jsxs(Text, { dimColor: true, bold: true, children: ["── ", row.name, " (", row.count, ")", " ──"] }) }, `h-${i}`));
+                    }
+                    const { issue, flatIndex } = row;
+                    const selected = flatIndex === selectedIndex;
+                    const di = issue;
+                    const sc = stateColor(di.issue.state.type);
+                    const isCreating = di.issue.identifier === creatingForTicket;
+                    const isDeleting = di.issue.identifier === deletingForTicket;
+                    const sess = sessionIndicator(di.worktree, isCreating, isDeleting);
+                    const ci = checksIndicator(di.checks);
+                    const pr = prIndicator(di.pr);
+                    const prio = priorityIndicator(di.issue.priority);
+                    const cursor = selected ? ">" : " ";
+                    const title = di.issue.title.length > titleMaxWidth
+                        ? di.issue.title.slice(0, titleMaxWidth - 1) + "…"
+                        : di.issue.title;
+                    const bg = selected ? "#1e3a5f" : undefined;
+                    return (_jsxs(Box, { width: width, children: [_jsxs(Text, { backgroundColor: bg, color: selected ? "cyan" : undefined, bold: selected, children: [cursor, " "] }), _jsx(Text, { backgroundColor: bg, color: sc, children: "\u25CF" }), _jsxs(Text, { backgroundColor: bg, color: prio.color, children: [" ", prio.text] }), _jsx(Text, { backgroundColor: bg, color: selected ? "cyan" : undefined, bold: selected, children: di.issue.identifier.padEnd(10) }), _jsx(Text, { backgroundColor: bg, color: selected ? "white" : undefined, bold: selected, children: title.padEnd(titleMaxWidth) }), _jsx(Text, { backgroundColor: bg, color: selected ? (sess.color === "gray" ? "gray" : sess.color) : sess.color, children: sess.text.padStart(sessionColWidth) }), _jsx(Text, { backgroundColor: bg, children: " " }), _jsx(Text, { backgroundColor: bg, color: selected ? (pr.color === "gray" ? "gray" : pr.color) : pr.color, children: pr.text.padStart(prColWidth) }), _jsx(Text, { backgroundColor: bg, children: " " }), _jsx(Text, { backgroundColor: bg, color: selected ? (ci.color === "gray" ? "gray" : ci.color) : ci.color, children: ci.text.padStart(checksColWidth) })] }, di.issue.identifier));
+                }) }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: footerRule }), _jsxs(Text, { children: ["  ", _jsx(Text, { color: "cyan", bold: true, children: "j/k" }), _jsx(Text, { color: "white", children: " Navigate" }), "   ", _jsx(Text, { color: "cyan", bold: true, children: "Shift + \u2191\u2193" }), _jsx(Text, { color: "white", children: " Scroll detail" }), "   ", _jsx(Text, { color: "cyan", bold: true, children: "E" }), _jsx(Text, { color: "white", children: " Workspace" }), "   ", _jsx(Text, { color: "cyan", bold: true, children: "R" }), _jsx(Text, { color: "white", children: " Refresh" }), "   ", _jsx(Text, { color: "cyan", bold: true, children: "q" }), _jsx(Text, { color: "white", children: " Quit" })] })] })] }));
+}

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

@@ -0,0 +1,25 @@
+import type { CommitPhase, PrCreatePhase, DashboardAction } from "./types.js";
+interface CommitOverlayProps {
+    width: number;
+    height: number;
+    branch: string | null;
+    ticketId: string | null;
+    gitStatus: string;
+    phase: CommitPhase;
+    message: string;
+    error: string | null;
+    dispatch: React.Dispatch<DashboardAction>;
+    onSubmit: (value: string) => void;
+}
+export declare function CommitOverlay({ width, height, branch, ticketId, gitStatus, phase, message, error, dispatch, onSubmit, }: CommitOverlayProps): import("react/jsx-runtime").JSX.Element;
+interface PrCreateOverlayProps {
+    width: number;
+    height: number;
+    branch: string | null;
+    ticketId: string | null;
+    phase: PrCreatePhase;
+    error: string | null;
+    url: string | null;
+}
+export declare function PrCreateOverlay({ width, height, branch, ticketId, phase, error, url, }: PrCreateOverlayProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/dashboard/Overlays.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import Spinner from "ink-spinner";
+import TextInput from "ink-text-input";
+export function CommitOverlay({ width, height, branch, ticketId, gitStatus, phase, message, error, dispatch, onSubmit, }) {
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: height, children: [_jsx(Text, { bold: true, color: "cyan", children: "Commit & Push" }), _jsx(Text, { dimColor: true, children: "─".repeat(Math.min(width, 50)) }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "branch: " }), _jsx(Text, { children: branch })] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "ticket: " }), _jsx(Text, { children: ticketId })] }), _jsx(Text, { children: " " }), gitStatus ? (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "Changes:" }), gitStatus
+                        .split("\n")
+                        .slice(0, 8)
+                        .map((line, i) => {
+                        let color;
+                        if (line.length >= 2 && line[0] !== " " && line[0] !== "?") {
+                            color = "green";
+                        }
+                        else if (line.startsWith("??")) {
+                            color = "gray";
+                        }
+                        else if (line.startsWith(" ")) {
+                            color = "yellow";
+                        }
+                        return (_jsxs(Text, { color: color, children: [" ", line] }, i));
+                    }), gitStatus.split("\n").length > 8 && (_jsxs(Text, { dimColor: true, children: [" +", gitStatus.split("\n").length - 8, " more"] }))] })) : null, _jsx(Text, { children: " " }), phase === "confirm-stage" && (_jsxs(Text, { children: ["Stage all changes?", " ", _jsx(Text, { color: "cyan", bold: true, children: "y" }), "/", _jsx(Text, { color: "cyan", bold: true, children: "n" })] })), phase === "awaiting-message" && (_jsxs(Box, { children: [_jsx(Text, { children: "Message: " }), _jsx(TextInput, { value: message, onChange: (v) => dispatch({ type: "COMMIT_MESSAGE", message: v }), onSubmit: onSubmit })] })), phase === "committing" && (_jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), " ", "Committing..."] })), phase === "pushing" && (_jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), " ", "Pushing..."] })), phase === "done" && (_jsx(Text, { color: "green", bold: true, children: "Committed and pushed!" })), phase === "error" && _jsx(Text, { color: "red", children: error }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "ESC to cancel" })] }));
+}
+export function PrCreateOverlay({ width, height, branch, ticketId, phase, error, url, }) {
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: height, children: [_jsx(Text, { bold: true, color: "cyan", children: "Create Pull Request" }), _jsx(Text, { dimColor: true, children: "─".repeat(Math.min(width, 50)) }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "branch: " }), _jsx(Text, { children: branch })] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "ticket: " }), _jsx(Text, { children: ticketId })] }), _jsx(Text, { children: " " }), phase === "choose-mode" && (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: "How do you want to create this PR?" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [" ", _jsx(Text, { color: "cyan", bold: true, children: "f" }), " ", "Fill \u2014 auto-fill title & body from commits"] }), _jsxs(Text, { children: [" ", _jsx(Text, { color: "cyan", bold: true, children: "w" }), " ", "Web \u2014 open in browser to edit manually"] })] })), phase === "pushing" && (_jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), " ", "Pushing branch..."] })), phase === "creating" && (_jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), " ", "Creating PR..."] })), phase === "done" && (_jsxs(_Fragment, { children: [_jsx(Text, { color: "green", bold: true, children: "PR created!" }), url ? _jsx(Text, { dimColor: true, children: url }) : null] })), phase === "error" && _jsx(Text, { color: "red", children: error }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "ESC to cancel" })] }));
+}

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

@@ -0,0 +1,5 @@
+import type { DashboardIssue, ProjectGroup } from "./types.js";
+export declare function loadDashboardData(repoRoot: string): Promise<{
+    groups: ProjectGroup[];
+    flatIssues: DashboardIssue[];
+}>;

package/dist/lib/dashboard/data.js

@@ -0,0 +1,75 @@
+import { listWorktrees, extractTicketId, getBaseBranch, readAllMetadata, getGitStatusAsync, getCommitsAheadAsync, } from "../git.js";
+import { getPRInfoAsync, getPRChecksAsync, getPRReviewsAsync, } from "../github.js";
+import { fetchAssignedIssues } from "../linear.js";
+export async function loadDashboardData(repoRoot) {
+    // Fetch issues and worktrees in parallel
+    const [issues, worktrees] = await Promise.all([
+        fetchAssignedIssues(repoRoot),
+        Promise.resolve(listWorktrees()),
+    ]);
+    if (!issues)
+        throw new Error("Failed to fetch Linear issues. Check authentication.");
+    // Build worktree map: ticketId -> worktree info
+    const wtMap = new Map();
+    for (const wt of worktrees) {
+        if (!wt.branch)
+            continue;
+        const tid = extractTicketId(wt.branch);
+        if (tid)
+            wtMap.set(tid, { path: wt.path, branch: wt.branch });
+    }
+    // Read metadata once for session IDs
+    const metadata = readAllMetadata(repoRoot);
+    // Enrich issues in parallel
+    const enriched = await Promise.all(issues.map(async (issue) => {
+        const wt = wtMap.get(issue.identifier);
+        let worktreeInfo = null;
+        let prInfo = null;
+        let checksInfo = null;
+        let reviewsInfo = null;
+        if (wt) {
+            const base = getBaseBranch(wt.branch);
+            const [gitStatusOutput, ahead, pr] = await Promise.all([
+                getGitStatusAsync(wt.path),
+                getCommitsAheadAsync(wt.path, base),
+                getPRInfoAsync(wt.branch),
+            ]);
+            worktreeInfo = {
+                path: wt.path,
+                branch: wt.branch,
+                dirty: Boolean(gitStatusOutput),
+                commitsAhead: ahead,
+                sessionId: metadata[issue.identifier]?.session_id ?? null,
+                gitStatus: gitStatusOutput,
+            };
+            prInfo = pr;
+            if (pr) {
+                [checksInfo, reviewsInfo] = await Promise.all([
+                    getPRChecksAsync(pr.number),
+                    getPRReviewsAsync(pr.number),
+                ]);
+            }
+        }
+        return {
+            issue,
+            worktree: worktreeInfo,
+            pr: prInfo,
+            checks: checksInfo,
+            reviews: reviewsInfo,
+        };
+    }));
+    // Group by project
+    const groupMap = new Map();
+    for (const di of enriched) {
+        const key = di.issue.projectName ?? "No Project";
+        const list = groupMap.get(key) ?? [];
+        list.push(di);
+        groupMap.set(key, list);
+    }
+    const groups = [...groupMap.entries()].map(([name, issues]) => ({
+        name,
+        id: issues[0]?.issue.projectId ?? null,
+        issues,
+    }));
+    return { groups, flatIssues: groups.flatMap((g) => g.issues) };
+}