santree 0.1.4 → 0.2.0

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

@@ -0,0 +1,150 @@
+import type { PRInfo, PRCheck, PRReview } from "../github.js";
+export interface LinearAssignedIssue {
+    identifier: string;
+    title: string;
+    description: string | null;
+    url: string;
+    priority: number;
+    priorityLabel: string;
+    state: {
+        name: string;
+        type: string;
+    };
+    labels: string[];
+    projectId: string | null;
+    projectName: string | null;
+}
+export interface WorktreeInfo {
+    path: string;
+    branch: string;
+    dirty: boolean;
+    commitsAhead: number;
+    sessionId: string | null;
+    gitStatus: string;
+}
+export interface DashboardIssue {
+    issue: LinearAssignedIssue;
+    worktree: WorktreeInfo | null;
+    pr: PRInfo | null;
+    checks: PRCheck[] | null;
+    reviews: PRReview[] | null;
+}
+export interface ProjectGroup {
+    name: string;
+    id: string | null;
+    issues: DashboardIssue[];
+}
+export type ActionOverlay = "mode-select" | "confirm-delete" | "commit" | "pr-create" | null;
+export type CommitPhase = "idle" | "confirm-stage" | "awaiting-message" | "committing" | "pushing" | "done" | "error";
+export type PrCreatePhase = "idle" | "choose-mode" | "pushing" | "creating" | "done" | "error";
+export interface DashboardState {
+    groups: ProjectGroup[];
+    flatIssues: DashboardIssue[];
+    selectedIndex: number;
+    listScrollOffset: number;
+    detailScrollOffset: number;
+    loading: boolean;
+    refreshing: boolean;
+    error: string | null;
+    overlay: ActionOverlay;
+    actionMessage: string | null;
+    creatingForTicket: string | null;
+    creationLogs: string;
+    creationError: string | null;
+    deletingForTicket: string | null;
+    commitPhase: CommitPhase;
+    commitMessage: string;
+    commitError: string | null;
+    commitTicketId: string | null;
+    commitWorktreePath: string | null;
+    commitBranch: string | null;
+    commitGitStatus: string;
+    prCreatePhase: PrCreatePhase;
+    prCreateTicketId: string | null;
+    prCreateWorktreePath: string | null;
+    prCreateBranch: string | null;
+    prCreateError: string | null;
+    prCreateUrl: string | null;
+}
+export type DashboardAction = {
+    type: "SET_DATA";
+    groups: ProjectGroup[];
+    flatIssues: DashboardIssue[];
+} | {
+    type: "SELECT";
+    index: number;
+} | {
+    type: "SCROLL_LIST";
+    offset: number;
+} | {
+    type: "SCROLL_DETAIL";
+    offset: number;
+} | {
+    type: "REFRESH_START";
+} | {
+    type: "REFRESH_DONE";
+} | {
+    type: "SET_ERROR";
+    error: string;
+} | {
+    type: "SET_OVERLAY";
+    overlay: ActionOverlay;
+} | {
+    type: "SET_ACTION_MESSAGE";
+    message: string | null;
+} | {
+    type: "CLEAR_ERROR";
+} | {
+    type: "CREATION_START";
+    ticketId: string;
+} | {
+    type: "CREATION_LOG";
+    logs: string;
+} | {
+    type: "CREATION_DONE";
+} | {
+    type: "CREATION_ERROR";
+    error: string;
+} | {
+    type: "DELETE_START";
+    ticketId: string;
+} | {
+    type: "DELETE_DONE";
+} | {
+    type: "COMMIT_START";
+    ticketId: string;
+    worktreePath: string;
+    branch: string;
+    gitStatus: string;
+} | {
+    type: "COMMIT_PHASE";
+    phase: CommitPhase;
+} | {
+    type: "COMMIT_MESSAGE";
+    message: string;
+} | {
+    type: "COMMIT_ERROR";
+    error: string;
+} | {
+    type: "COMMIT_DONE";
+} | {
+    type: "COMMIT_CANCEL";
+} | {
+    type: "PR_CREATE_START";
+    ticketId: string;
+    worktreePath: string;
+    branch: string;
+} | {
+    type: "PR_CREATE_PHASE";
+    phase: PrCreatePhase;
+} | {
+    type: "PR_CREATE_ERROR";
+    error: string;
+} | {
+    type: "PR_CREATE_DONE";
+    url: string;
+} | {
+    type: "PR_CREATE_CANCEL";
+};
+export declare const initialState: DashboardState;
+export declare function reducer(state: DashboardState, action: DashboardAction): DashboardState;

package/dist/lib/dashboard/types.js

@@ -0,0 +1,151 @@
+// ── State management ──────────────────────────────────────────────────
+export const initialState = {
+    groups: [],
+    flatIssues: [],
+    selectedIndex: 0,
+    listScrollOffset: 0,
+    detailScrollOffset: 0,
+    loading: true,
+    refreshing: false,
+    error: null,
+    overlay: null,
+    actionMessage: null,
+    creatingForTicket: null,
+    creationLogs: "",
+    creationError: null,
+    deletingForTicket: null,
+    commitPhase: "idle",
+    commitMessage: "",
+    commitError: null,
+    commitTicketId: null,
+    commitWorktreePath: null,
+    commitBranch: null,
+    commitGitStatus: "",
+    prCreatePhase: "idle",
+    prCreateTicketId: null,
+    prCreateWorktreePath: null,
+    prCreateBranch: null,
+    prCreateError: null,
+    prCreateUrl: null,
+};
+export function reducer(state, action) {
+    switch (action.type) {
+        case "SET_DATA": {
+            // Preserve selection by identifier if possible
+            const prevId = state.flatIssues[state.selectedIndex]?.issue.identifier;
+            let newIndex = 0;
+            if (prevId) {
+                const found = action.flatIssues.findIndex((d) => d.issue.identifier === prevId);
+                if (found >= 0)
+                    newIndex = found;
+            }
+            return {
+                ...state,
+                groups: action.groups,
+                flatIssues: action.flatIssues,
+                selectedIndex: newIndex,
+                loading: false,
+                refreshing: false,
+                error: null,
+                detailScrollOffset: 0,
+            };
+        }
+        case "SELECT":
+            return { ...state, selectedIndex: action.index, detailScrollOffset: 0 };
+        case "SCROLL_LIST":
+            return { ...state, listScrollOffset: action.offset };
+        case "SCROLL_DETAIL":
+            return { ...state, detailScrollOffset: action.offset };
+        case "REFRESH_START":
+            return { ...state, refreshing: true };
+        case "REFRESH_DONE":
+            return { ...state, refreshing: false };
+        case "SET_ERROR":
+            return { ...state, error: action.error, loading: false, refreshing: false };
+        case "SET_OVERLAY":
+            return { ...state, overlay: action.overlay };
+        case "SET_ACTION_MESSAGE":
+            return { ...state, actionMessage: action.message };
+        case "CLEAR_ERROR":
+            return { ...state, error: null };
+        case "CREATION_START":
+            return {
+                ...state,
+                creatingForTicket: action.ticketId,
+                creationLogs: "",
+                creationError: null,
+            };
+        case "CREATION_LOG":
+            return { ...state, creationLogs: state.creationLogs + action.logs };
+        case "CREATION_DONE":
+            return { ...state, creatingForTicket: null, creationLogs: "", creationError: null };
+        case "CREATION_ERROR":
+            return { ...state, creationError: action.error, creatingForTicket: null, creationLogs: "" };
+        case "DELETE_START":
+            return { ...state, deletingForTicket: action.ticketId };
+        case "DELETE_DONE":
+            return { ...state, deletingForTicket: null };
+        case "COMMIT_START":
+            return {
+                ...state,
+                overlay: "commit",
+                commitPhase: "confirm-stage",
+                commitMessage: "",
+                commitError: null,
+                commitTicketId: action.ticketId,
+                commitWorktreePath: action.worktreePath,
+                commitBranch: action.branch,
+                commitGitStatus: action.gitStatus,
+            };
+        case "COMMIT_PHASE":
+            return { ...state, commitPhase: action.phase };
+        case "COMMIT_MESSAGE":
+            return { ...state, commitMessage: action.message };
+        case "COMMIT_ERROR":
+            return { ...state, commitPhase: "error", commitError: action.error };
+        case "COMMIT_DONE":
+            return { ...state, commitPhase: "done" };
+        case "COMMIT_CANCEL":
+            return {
+                ...state,
+                overlay: null,
+                commitPhase: "idle",
+                commitMessage: "",
+                commitError: null,
+                commitTicketId: null,
+                commitWorktreePath: null,
+                commitBranch: null,
+                commitGitStatus: "",
+            };
+        case "PR_CREATE_START":
+            return {
+                ...state,
+                overlay: "pr-create",
+                prCreatePhase: "choose-mode",
+                prCreateTicketId: action.ticketId,
+                prCreateWorktreePath: action.worktreePath,
+                prCreateBranch: action.branch,
+                prCreateError: null,
+                prCreateUrl: null,
+            };
+        case "PR_CREATE_PHASE":
+            return { ...state, prCreatePhase: action.phase };
+        case "PR_CREATE_ERROR":
+            return { ...state, prCreatePhase: "error", prCreateError: action.error };
+        case "PR_CREATE_DONE":
+            return { ...state, prCreatePhase: "done", prCreateUrl: action.url };
+        case "PR_CREATE_CANCEL":
+            return {
+                ...state,
+                overlay: null,
+                prCreatePhase: "idle",
+                prCreateTicketId: null,
+                prCreateWorktreePath: null,
+                prCreateBranch: null,
+                prCreateError: null,
+                prCreateUrl: null,
+            };
+        default:
+            return state;
+    }
+}

package/dist/lib/git.d.ts

@@ -111,6 +111,15 @@ export declare function setRepoLinearOrg(repoRoot: string, orgSlug: string): voi
  * Deletes the `_linear` key from .santree/metadata.json.
  */
 export declare function removeRepoLinearOrg(repoRoot: string): void;
+/**
+ * Get the stored session ID for a given ticket from .santree/metadata.json.
+ * Returns null if no session ID is stored.
+ */
+export declare function getSessionId(repoRoot: string, ticketId: string): string | null;
+/**
+ * Store a session ID for a given ticket in .santree/metadata.json.
+ */
+export declare function setSessionId(repoRoot: string, ticketId: string, sessionId: string): void;
 /**
  * Get the base branch for a given branch name.
  * Looks up metadata first, falls back to the default branch.
@@ -147,6 +156,11 @@ export declare function hasUnstagedChanges(): boolean;
  * Returns empty string on failure.
  */
 export declare function getGitStatus(): string;
+/**
+ * Get a short summary of the working tree status (async, with cwd).
+ * Returns empty string on failure.
+ */
+export declare function getGitStatusAsync(cwd: string): Promise<string>;
 /**
  * Get a diffstat of staged changes.
  * Runs: `git diff --cached --stat`
@@ -165,6 +179,11 @@ export declare function getCommitsBehind(baseBranch: string): number;
  * Returns 0 on failure.
  */
 export declare function getCommitsAhead(baseBranch: string): number;
+/**
+ * Count how many commits the current branch is ahead of baseBranch (async, with cwd).
+ * Returns 0 on failure.
+ */
+export declare function getCommitsAheadAsync(cwd: string, baseBranch: string): Promise<number>;
 /**
  * Check if a branch exists on the remote (origin).
  * Runs: `git ls-remote --heads origin <branchName>`

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 } from "./exec.js";
+import { run, runAsync } from "./exec.js";
 const execAsync = promisify(exec);
 /**
  * Find the toplevel directory of the current git repository.
@@ -324,6 +324,22 @@ export function removeRepoLinearOrg(repoRoot) {
     delete all._linear;
     writeAllMetadata(repoRoot, all);
 }
+/**
+ * Get the stored session ID for a given ticket from .santree/metadata.json.
+ * Returns null if no session ID is stored.
+ */
+export function getSessionId(repoRoot, ticketId) {
+    const all = readAllMetadata(repoRoot);
+    return all[ticketId]?.session_id ?? null;
+}
+/**
+ * Store a session ID for a given ticket in .santree/metadata.json.
+ */
+export function setSessionId(repoRoot, ticketId, sessionId) {
+    const all = readAllMetadata(repoRoot);
+    all[ticketId] = { ...all[ticketId], session_id: sessionId };
+    writeAllMetadata(repoRoot, all);
+}
 /**
  * Get the base branch for a given branch name.
  * Looks up metadata first, falls back to the default branch.
@@ -399,6 +415,13 @@ export function hasUnstagedChanges() {
 export function getGitStatus() {
     return run("git status --short") ?? "";
 }
+/**
+ * Get a short summary of the working tree status (async, with cwd).
+ * Returns empty string on failure.
+ */
+export async function getGitStatusAsync(cwd) {
+    return (await runAsync(`git -C "${cwd}" status --short`)) ?? "";
+}
 /**
  * Get a diffstat of staged changes.
  * Runs: `git diff --cached --stat`
@@ -425,6 +448,14 @@ export function getCommitsAhead(baseBranch) {
     const output = run(`git rev-list --count ${baseBranch}..HEAD`);
     return output ? parseInt(output, 10) || 0 : 0;
 }
+/**
+ * Count how many commits the current branch is ahead of baseBranch (async, with cwd).
+ * Returns 0 on failure.
+ */
+export async function getCommitsAheadAsync(cwd, baseBranch) {
+    const output = await runAsync(`git -C "${cwd}" rev-list --count ${baseBranch}..HEAD`);
+    return output ? parseInt(output, 10) || 0 : 0;
+}
 /**
  * Check if a branch exists on the remote (origin).
  * Runs: `git ls-remote --heads origin <branchName>`

package/dist/lib/github.d.ts

@@ -1,11 +1,12 @@
 export interface PRInfo {
     number: string;
     state: "OPEN" | "MERGED" | "CLOSED";
+    isDraft: boolean;
     url?: string;
 }
 /**
  * Get PR info for a branch using the GitHub CLI (async).
- * Runs: `gh pr view "<branchName>" --json number,state,url`
+ * Runs: `gh pr view "<branchName>" --json number,state,url,isDraft`
  * Returns null if no PR exists for the branch or gh CLI fails.
  */
 export declare function getPRInfoAsync(branchName: string): Promise<PRInfo | null>;

package/dist/lib/github.js

@@ -4,16 +4,17 @@ import { run, runAsync } from "./exec.js";
 const execAsync = promisify(exec);
 /**
  * Get PR info for a branch using the GitHub CLI (async).
- * Runs: `gh pr view "<branchName>" --json number,state,url`
+ * Runs: `gh pr view "<branchName>" --json number,state,url,isDraft`
  * Returns null if no PR exists for the branch or gh CLI fails.
  */
 export async function getPRInfoAsync(branchName) {
     try {
-        const { stdout } = await execAsync(`gh pr view "${branchName}" --json number,state,url`);
+        const { stdout } = await execAsync(`gh pr view "${branchName}" --json number,state,url,isDraft`);
         const data = JSON.parse(stdout);
         return {
             number: String(data.number ?? ""),
             state: data.state ?? "OPEN",
+            isDraft: data.isDraft ?? false,
             url: data.url,
         };
     }

package/dist/lib/linear.d.ts

@@ -54,6 +54,26 @@ export interface AuthStatus {
  * Get auth status for the current repo's Linear org (or any stored org).
  */
 export declare function getAuthStatus(repoRoot: string | null): AuthStatus;
+export interface LinearAssignedIssue {
+    identifier: string;
+    title: string;
+    description: string | null;
+    url: string;
+    priority: number;
+    priorityLabel: string;
+    state: {
+        name: string;
+        type: string;
+    };
+    labels: string[];
+    projectId: string | null;
+    projectName: string | null;
+}
+/**
+ * Fetch all active issues assigned to the current user.
+ * Returns null if not authenticated or fetch fails.
+ */
+export declare function fetchAssignedIssues(repoRoot: string): Promise<LinearAssignedIssue[] | null>;
 /**
  * Fetch full ticket content for a given ticket ID.
  * Looks up the repo's Linear org, gets valid tokens, fetches issue, downloads images.

package/dist/lib/linear.js

@@ -390,6 +390,59 @@ export function getAuthStatus(repoRoot) {
         repoLinked: false,
     };
 }
+// ── Assigned Issues Query ──────────────────────────────────────────────
+const ASSIGNED_ISSUES_QUERY = `
+query AssignedIssues {
+  viewer {
+    assignedIssues(
+      filter: { state: { type: { nin: ["completed", "cancelled"] } } }
+      orderBy: updatedAt
+      first: 100
+    ) {
+      nodes {
+        identifier
+        title
+        description
+        url
+        priority
+        state { name type }
+        labels { nodes { name } }
+        project { id name }
+      }
+    }
+  }
+}
+`;
+/**
+ * Fetch all active issues assigned to the current user.
+ * Returns null if not authenticated or fetch fails.
+ */
+export async function fetchAssignedIssues(repoRoot) {
+    const orgSlug = getRepoLinearOrg(repoRoot);
+    if (!orgSlug)
+        return null;
+    const tokens = await getValidTokens(orgSlug);
+    if (!tokens)
+        return null;
+    const data = await graphqlQuery(ASSIGNED_ISSUES_QUERY, {}, tokens.access_token);
+    if (!data?.viewer?.assignedIssues?.nodes)
+        return null;
+    return data.viewer.assignedIssues.nodes.map((issue) => ({
+        identifier: issue.identifier,
+        title: issue.title,
+        description: issue.description ?? null,
+        url: issue.url,
+        priority: issue.priority,
+        priorityLabel: PRIORITY_MAP[issue.priority] ?? "No priority",
+        state: {
+            name: issue.state?.name ?? "Unknown",
+            type: issue.state?.type ?? "unstarted",
+        },
+        labels: (issue.labels?.nodes ?? []).map((l) => l.name),
+        projectId: issue.project?.id ?? null,
+        projectName: issue.project?.name ?? null,
+    }));
+}
 // ── High-Level Entry Point ─────────────────────────────────────────────
 /**
  * Fetch full ticket content for a given ticket ID.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "santree",
-	"version": "0.1.4",
+	"version": "0.2.0",
 	"description": "Git worktree manager",
 	"license": "MIT",
 	"author": "Santiago Toscanini",
@@ -29,7 +29,7 @@
 		"node": ">=20"
 	},
 	"scripts": {
-		"build": "tsc",
+		"build": "tsc && chmod +x dist/cli.js",
 		"dev": "tsc --watch",
 		"start": "node dist/cli.js",
 		"lint": "eslint source",