santree 0.0.1

package/dist/commands/work.js

@@ -0,0 +1,169 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Text, Box } from "ink";
+import Spinner from "ink-spinner";
+import { z } from "zod";
+import { spawn } from "child_process";
+import { getCurrentBranch, extractTicketId, findRepoRoot } from "../lib/git.js";
+export const options = z.object({
+    plan: z.boolean().optional().describe("Only create implementation plan"),
+    review: z.boolean().optional().describe("Review changes against ticket"),
+    "fix-pr": z.boolean().optional().describe("Fetch PR comments and fix them"),
+});
+const TEMPLATES = {
+    implement: `Fetch Linear ticket {{ticket_id}} using MCP (including issue comments) and analyze what needs to be done.
+
+If a PR URL is linked in the ticket, use \`gh\` CLI to fetch PR details, comments, and review feedback.
+
+Review the codebase to understand the relevant areas and existing patterns.
+
+Create an implementation plan, then implement the changes.
+
+After implementation:
+- Run tests if applicable
+- Ensure code follows existing patterns`,
+    plan: `Fetch Linear ticket {{ticket_id}} using MCP (including issue comments) and analyze what needs to be done.
+
+If a PR URL is linked in the ticket, use \`gh\` CLI to fetch PR details, comments, and review feedback for additional context.
+
+Review the codebase to understand:
+- Relevant files and modules
+- Existing patterns and conventions
+- Dependencies and potential impact areas
+
+Create a detailed implementation plan with:
+- Step-by-step approach
+- Files to modify
+- Potential risks or edge cases
+
+Do NOT implement yet - just plan. Wait for approval before making changes.`,
+    review: `Fetch Linear ticket {{ticket_id}} using MCP (including issue comments) to understand the requirements and acceptance criteria.
+
+If a PR URL is linked in the ticket, use \`gh\` CLI to fetch PR details and any existing review comments.
+
+Review the current changes by running \`git diff\` against the base branch.
+
+Analyze:
+- Do the changes fully address the ticket requirements?
+- Are there any missing acceptance criteria?
+- Any potential bugs or edge cases?
+- Code quality and adherence to patterns?
+
+Provide a summary of findings and any recommended changes.`,
+    "fix-pr": `Fetch Linear ticket {{ticket_id}} using MCP (including issue comments) to understand the original requirements.
+
+If a PR URL is linked in the ticket, use \`gh\` CLI to fetch the latest PR comments and review feedback.
+
+## PR Comments to Address
+
+{{pr_comments}}
+
+## Task
+
+1. Review each comment and understand what changes are requested
+2. Make the necessary code changes to address each comment
+3. Ensure the changes align with the original ticket requirements
+4. Run tests if applicable to verify the fixes
+
+Address all comments systematically, starting from the most critical ones.`,
+};
+function getMode(opts) {
+    if (opts["fix-pr"])
+        return "fix-pr";
+    if (opts.review)
+        return "review";
+    if (opts.plan)
+        return "plan";
+    return "implement";
+}
+function getModeLabel(mode) {
+    switch (mode) {
+        case "implement":
+            return "implement";
+        case "plan":
+            return "plan only";
+        case "review":
+            return "review";
+        case "fix-pr":
+            return "fix PR";
+    }
+}
+function getModeColor(mode) {
+    switch (mode) {
+        case "implement":
+            return "green";
+        case "plan":
+            return "blue";
+        case "review":
+            return "yellow";
+        case "fix-pr":
+            return "magenta";
+    }
+}
+export default function Work({ options }) {
+    const [status, setStatus] = useState("loading");
+    const [branch, setBranch] = useState(null);
+    const [ticketId, setTicketId] = useState(null);
+    const [error, setError] = useState(null);
+    const [mode, setMode] = useState("implement");
+    useEffect(() => {
+        async function init() {
+            // Small delay to allow spinner to render
+            await new Promise((r) => setTimeout(r, 100));
+            const repoRoot = findRepoRoot();
+            if (!repoRoot) {
+                setStatus("error");
+                setError("Not inside a git repository");
+                return;
+            }
+            const currentBranch = getCurrentBranch();
+            if (!currentBranch) {
+                setStatus("error");
+                setError("Could not determine current branch");
+                return;
+            }
+            setBranch(currentBranch);
+            const ticket = extractTicketId(currentBranch);
+            if (!ticket) {
+                setStatus("error");
+                setError("Could not extract ticket ID from branch name. Expected format: user/TEAM-123-description");
+                return;
+            }
+            setTicketId(ticket);
+            setMode(getMode(options));
+            setStatus("ready");
+        }
+        init();
+    }, [options]);
+    useEffect(() => {
+        if (status !== "ready" || !ticketId)
+            return;
+        setStatus("launching");
+        const template = TEMPLATES[mode];
+        const prompt = template.replace(/\{\{ticket_id\}\}/g, ticketId);
+        const happyCmd = "happy";
+        // Build args array
+        const args = [];
+        // Allow Linear MCP tools without prompting
+        args.push("--allowedTools", "mcp__linear__list_comments mcp__linear__get_issue");
+        // Add plan mode flag (Claude's native plan mode)
+        if (mode === "plan") {
+            args.push("--permission-mode", "plan");
+        }
+        // Add the prompt
+        args.push(prompt);
+        // Spawn happy directly with prompt as argument (no shell)
+        const child = spawn(happyCmd, args, {
+            stdio: "inherit",
+        });
+        child.on("error", (err) => {
+            setStatus("error");
+            setError(`Failed to launch happy: ${err.message}`);
+        });
+        child.on("close", () => {
+            process.exit(0);
+        });
+    }, [status, ticketId, mode]);
+    const isLoading = status === "loading";
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "\uD83E\uDD16 Work" }) }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: status === "error" ? "red" : getModeColor(mode), paddingX: 1, width: "100%", children: [branch && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "branch:" }), _jsx(Text, { color: "cyan", bold: true, children: branch })] })), ticketId && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "ticket:" }), _jsx(Text, { color: "blue", bold: true, children: ticketId })] })), _jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "mode:" }), _jsx(Text, { backgroundColor: getModeColor(mode), color: "white", bold: true, children: ` ${getModeLabel(mode)} ` })] })] }), _jsxs(Box, { marginTop: 1, children: [isLoading && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: " Loading..." })] })), status === "launching" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "green", bold: true, children: "\u2713 Launching Claude (through Happy)..." }), _jsxs(Text, { dimColor: true, children: [" ", "happy", mode === "plan" ? " --permission-mode plan" : "", " ", `"<${getModeLabel(mode)} prompt for ${ticketId}>"`] })] })), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", error] }))] })] }));
+}

package/dist/lib/git.d.ts

@@ -0,0 +1,47 @@
+export interface Worktree {
+    path: string;
+    branch: string;
+    commit: string;
+    isBare: boolean;
+}
+export declare function findRepoRoot(): string | null;
+export declare function findMainRepoRoot(): string | null;
+export declare function isInWorktree(): boolean;
+export declare function isWorktreePath(wtPath: string): boolean;
+export declare function getCurrentBranch(): string | null;
+export declare function getDefaultBranch(): string;
+export declare function listWorktrees(): Worktree[];
+export declare function getSantreeDir(repoRoot: string): string;
+export declare function getWorktreesDir(repoRoot: string): string;
+export declare function createWorktree(branchName: string, baseBranch: string, repoRoot: string): Promise<{
+    success: boolean;
+    path?: string;
+    error?: string;
+}>;
+export declare function removeWorktree(branchName: string, repoRoot: string, force?: boolean): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+export declare function extractTicketId(branch: string): string | null;
+export declare function getWorktreePath(branchName: string): string | null;
+export declare function getWorktreeMetadata(worktreePath: string): {
+    branch_name?: string;
+    base_branch?: string;
+    created_at?: string;
+} | null;
+export declare function hasUncommittedChanges(): boolean;
+export declare function hasStagedChanges(): boolean;
+export declare function hasUnstagedChanges(): boolean;
+export declare function getGitStatus(): string;
+export declare function getStagedDiffStat(): string;
+export declare function getCommitsBehind(baseBranch: string): number;
+export declare function getCommitsAhead(baseBranch: string): number;
+export declare function remoteBranchExists(branchName: string): boolean;
+export declare function getUnpushedCommits(branchName: string): number;
+export declare function pullLatest(baseBranch: string, repoRoot: string): {
+    success: boolean;
+    message: string;
+};
+export declare function hasInitScript(repoRoot: string): boolean;
+export declare function getInitScriptPath(repoRoot: string): string;
+export declare function getLatestCommitMessage(): string | null;

package/dist/lib/git.js

@@ -0,0 +1,393 @@
+import { execSync, exec } from "child_process";
+import { promisify } from "util";
+import * as path from "path";
+import * as fs from "fs";
+const execAsync = promisify(exec);
+export function findRepoRoot() {
+    try {
+        return execSync("git rev-parse --show-toplevel", {
+            encoding: "utf-8",
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+export function findMainRepoRoot() {
+    try {
+        const gitCommonDir = execSync("git rev-parse --git-common-dir", {
+            encoding: "utf-8",
+        }).trim();
+        return path.dirname(path.resolve(gitCommonDir));
+    }
+    catch {
+        return null;
+    }
+}
+export function isInWorktree() {
+    try {
+        const gitDir = execSync("git rev-parse --git-dir", {
+            encoding: "utf-8",
+        }).trim();
+        const gitCommonDir = execSync("git rev-parse --git-common-dir", {
+            encoding: "utf-8",
+        }).trim();
+        // If they differ, we're in a worktree
+        return path.resolve(gitDir) !== path.resolve(gitCommonDir);
+    }
+    catch {
+        return false;
+    }
+}
+export function isWorktreePath(wtPath) {
+    try {
+        const gitDir = execSync("git rev-parse --git-dir", {
+            encoding: "utf-8",
+            cwd: wtPath,
+        }).trim();
+        const gitCommonDir = execSync("git rev-parse --git-common-dir", {
+            encoding: "utf-8",
+            cwd: wtPath,
+        }).trim();
+        // If they differ, it's a worktree (not the main repo)
+        return path.resolve(wtPath, gitDir) !== path.resolve(wtPath, gitCommonDir);
+    }
+    catch {
+        return false;
+    }
+}
+export function getCurrentBranch() {
+    try {
+        return execSync("git rev-parse --abbrev-ref HEAD", {
+            encoding: "utf-8",
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+export function getDefaultBranch() {
+    try {
+        const ref = execSync("git symbolic-ref refs/remotes/origin/HEAD", {
+            encoding: "utf-8",
+        }).trim();
+        return ref.replace("refs/remotes/origin/", "");
+    }
+    catch {
+        // Fall back to checking if main/master exists
+        for (const branch of ["main", "master"]) {
+            try {
+                execSync(`git rev-parse --verify refs/heads/${branch}`, {
+                    stdio: "ignore",
+                });
+                return branch;
+            }
+            catch {
+                continue;
+            }
+        }
+        return "main";
+    }
+}
+export function listWorktrees() {
+    try {
+        const output = execSync("git worktree list --porcelain", {
+            encoding: "utf-8",
+        });
+        const worktrees = [];
+        let current = {};
+        for (const line of output.split("\n")) {
+            if (line.startsWith("worktree ")) {
+                current.path = line.replace("worktree ", "");
+            }
+            else if (line.startsWith("HEAD ")) {
+                current.commit = line.replace("HEAD ", "").slice(0, 8);
+            }
+            else if (line.startsWith("branch ")) {
+                current.branch = line.replace("branch refs/heads/", "");
+            }
+            else if (line === "bare") {
+                current.isBare = true;
+            }
+            else if (line === "" && current.path) {
+                worktrees.push(current);
+                current = {};
+            }
+        }
+        if (current.path) {
+            worktrees.push(current);
+        }
+        return worktrees;
+    }
+    catch {
+        return [];
+    }
+}
+export function getSantreeDir(repoRoot) {
+    return path.join(repoRoot, ".santree");
+}
+export function getWorktreesDir(repoRoot) {
+    return path.join(getSantreeDir(repoRoot), "worktrees");
+}
+export async function createWorktree(branchName, baseBranch, repoRoot) {
+    const dirName = branchName.replace(/\//g, "__");
+    const worktreesDir = getWorktreesDir(repoRoot);
+    const worktreePath = path.join(worktreesDir, dirName);
+    if (fs.existsSync(worktreePath)) {
+        return {
+            success: false,
+            error: `Worktree already exists at ${worktreePath}`,
+        };
+    }
+    // Ensure worktrees directory exists
+    fs.mkdirSync(worktreesDir, { recursive: true });
+    // Check if branch exists
+    let branchExists = false;
+    try {
+        execSync(`git rev-parse --verify refs/heads/${branchName}`, {
+            cwd: repoRoot,
+            stdio: "ignore",
+        });
+        branchExists = true;
+    }
+    catch {
+        branchExists = false;
+    }
+    try {
+        if (branchExists) {
+            await execAsync(`git worktree add "${worktreePath}" "${branchName}"`, {
+                cwd: repoRoot,
+            });
+        }
+        else {
+            await execAsync(`git worktree add -b "${branchName}" "${worktreePath}" "${baseBranch}"`, { cwd: repoRoot });
+        }
+        // Save metadata
+        const metadata = {
+            branch_name: branchName,
+            base_branch: baseBranch,
+            created_at: new Date().toISOString(),
+        };
+        fs.writeFileSync(path.join(worktreePath, ".santree_metadata.json"), JSON.stringify(metadata, null, 2));
+        return { success: true, path: worktreePath };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e.message : "Unknown error",
+        };
+    }
+}
+export async function removeWorktree(branchName, repoRoot, force = false) {
+    // Find the worktree by branch name using git's worktree tracking
+    const worktreePath = getWorktreePath(branchName);
+    if (!worktreePath) {
+        return { success: false, error: `Worktree not found: ${branchName}` };
+    }
+    try {
+        const forceFlag = force ? "--force" : "";
+        await execAsync(`git worktree remove ${forceFlag} "${worktreePath}"`, {
+            cwd: repoRoot,
+        });
+        // Clean up any remaining files (untracked files, node_modules, etc.)
+        // git worktree remove doesn't delete untracked files
+        if (fs.existsSync(worktreePath)) {
+            // Fix permissions first (node_modules often has restricted perms)
+            try {
+                execSync(`chmod -R u+w "${worktreePath}"`, { stdio: "ignore" });
+            }
+            catch {
+                // Ignore chmod errors
+            }
+            fs.rmSync(worktreePath, { recursive: true, force: true });
+        }
+        // Also delete the branch
+        const deleteFlag = force ? "-D" : "-d";
+        try {
+            await execAsync(`git branch ${deleteFlag} "${branchName}"`, {
+                cwd: repoRoot,
+            });
+        }
+        catch {
+            // Branch deletion failed, but worktree was removed
+        }
+        return { success: true };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e instanceof Error ? e.message : "Unknown error",
+        };
+    }
+}
+export function extractTicketId(branch) {
+    const match = branch.match(/([a-zA-Z]+)-(\d+)/);
+    if (match) {
+        return `${match[1].toUpperCase()}-${match[2]}`;
+    }
+    return null;
+}
+export function getWorktreePath(branchName) {
+    const worktrees = listWorktrees();
+    const wt = worktrees.find((w) => w.branch === branchName);
+    return wt?.path ?? null;
+}
+export function getWorktreeMetadata(worktreePath) {
+    const metadataPath = path.join(worktreePath, ".santree_metadata.json");
+    if (!fs.existsSync(metadataPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(metadataPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function hasUncommittedChanges() {
+    try {
+        const output = execSync("git status --porcelain", { encoding: "utf-8" });
+        return Boolean(output.trim());
+    }
+    catch {
+        return false;
+    }
+}
+export function hasStagedChanges() {
+    try {
+        execSync("git diff --cached --quiet", { stdio: "ignore" });
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+export function hasUnstagedChanges() {
+    try {
+        // Check for modified files
+        try {
+            execSync("git diff --quiet", { stdio: "ignore" });
+        }
+        catch {
+            return true;
+        }
+        // Check for untracked files
+        const output = execSync("git ls-files --others --exclude-standard", {
+            encoding: "utf-8",
+        });
+        return Boolean(output.trim());
+    }
+    catch {
+        return false;
+    }
+}
+export function getGitStatus() {
+    try {
+        return execSync("git status --short", { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+export function getStagedDiffStat() {
+    try {
+        return execSync("git diff --cached --stat", { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+export function getCommitsBehind(baseBranch) {
+    try {
+        const output = execSync(`git rev-list --count HEAD..origin/${baseBranch}`, {
+            encoding: "utf-8",
+        });
+        return parseInt(output.trim(), 10) || 0;
+    }
+    catch {
+        return 0;
+    }
+}
+export function getCommitsAhead(baseBranch) {
+    try {
+        const output = execSync(`git rev-list --count ${baseBranch}..HEAD`, {
+            encoding: "utf-8",
+        });
+        return parseInt(output.trim(), 10) || 0;
+    }
+    catch {
+        return 0;
+    }
+}
+export function remoteBranchExists(branchName) {
+    try {
+        const output = execSync(`git ls-remote --heads origin ${branchName}`, {
+            encoding: "utf-8",
+        });
+        return output.includes(branchName);
+    }
+    catch {
+        return false;
+    }
+}
+export function getUnpushedCommits(branchName) {
+    try {
+        // Check if remote tracking branch exists
+        try {
+            execSync(`git rev-parse --verify origin/${branchName}`, {
+                stdio: "ignore",
+            });
+        }
+        catch {
+            // No remote branch, count all local commits
+            const output = execSync("git rev-list --count HEAD", {
+                encoding: "utf-8",
+            });
+            return parseInt(output.trim(), 10) || 0;
+        }
+        // Count commits ahead of remote
+        const output = execSync(`git rev-list --count origin/${branchName}..HEAD`, {
+            encoding: "utf-8",
+        });
+        return parseInt(output.trim(), 10) || 0;
+    }
+    catch {
+        return 0;
+    }
+}
+export function pullLatest(baseBranch, repoRoot) {
+    try {
+        // Fetch from origin
+        execSync("git fetch origin", { cwd: repoRoot, stdio: "ignore" });
+        // Update the base branch
+        execSync(`git checkout ${baseBranch}`, { cwd: repoRoot, stdio: "ignore" });
+        execSync(`git pull origin ${baseBranch}`, {
+            cwd: repoRoot,
+            stdio: "ignore",
+        });
+        return { success: true, message: "Fetched latest changes" };
+    }
+    catch (e) {
+        return {
+            success: false,
+            message: e instanceof Error ? e.message : "Failed to pull latest",
+        };
+    }
+}
+export function hasInitScript(repoRoot) {
+    const initScript = path.join(getSantreeDir(repoRoot), "init.sh");
+    return fs.existsSync(initScript);
+}
+export function getInitScriptPath(repoRoot) {
+    return path.join(getSantreeDir(repoRoot), "init.sh");
+}
+export function getLatestCommitMessage() {
+    try {
+        return execSync("git log -1 --format=%s", {
+            encoding: "utf-8",
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/github.d.ts

@@ -0,0 +1,11 @@
+export interface PRInfo {
+    number: string;
+    state: "OPEN" | "MERGED" | "CLOSED";
+    url?: string;
+}
+export declare function getPRInfo(branchName: string): PRInfo | null;
+export declare function getPRInfoAsync(branchName: string): Promise<PRInfo | null>;
+export declare function ghCliAvailable(): boolean;
+export declare function pushBranch(branchName: string, force?: boolean): boolean;
+export declare function createPR(title: string, baseBranch: string, headBranch: string, draft: boolean): number;
+export declare function getPRComments(prNumber: string): string;

package/dist/lib/github.js

@@ -0,0 +1,71 @@
+import { execSync, exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+export function getPRInfo(branchName) {
+    try {
+        const output = execSync(`gh pr view "${branchName}" --json number,state,url`, { encoding: "utf-8" });
+        const data = JSON.parse(output);
+        return {
+            number: String(data.number ?? ""),
+            state: data.state ?? "OPEN",
+            url: data.url,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function getPRInfoAsync(branchName) {
+    try {
+        const { stdout } = await execAsync(`gh pr view "${branchName}" --json number,state,url`);
+        const data = JSON.parse(stdout);
+        return {
+            number: String(data.number ?? ""),
+            state: data.state ?? "OPEN",
+            url: data.url,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function ghCliAvailable() {
+    try {
+        execSync("which gh", { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function pushBranch(branchName, force = false) {
+    try {
+        const forceFlag = force ? "--force-with-lease" : "";
+        execSync(`git push -u origin "${branchName}" ${forceFlag}`.trim(), {
+            stdio: "inherit",
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function createPR(title, baseBranch, headBranch, draft) {
+    try {
+        const draftFlag = draft ? "--draft" : "";
+        execSync(`gh pr create --title "${title}" --base "${baseBranch}" --head "${headBranch}" --web ${draftFlag}`.trim(), { stdio: "inherit" });
+        return 0;
+    }
+    catch {
+        return 1;
+    }
+}
+export function getPRComments(prNumber) {
+    try {
+        const output = execSync(`gh pr view ${prNumber} --json comments --jq '.comments[] | "- \\(.author.login): \\(.body)"'`, { encoding: "utf-8" });
+        return output.trim();
+    }
+    catch {
+        return "";
+    }
+}