santree 0.5.3 → 0.5.4

package/dist/lib/session-signal.js

@@ -1,6 +1,5 @@
 import * as fs from "fs";
 import * as path from "path";
-import { spawn } from "child_process";
 import { getMultiplexer } from "./multiplexer/index.js";
 export function readStdin() {
     try {
@@ -22,7 +21,7 @@ export function extractRepoAndTicket(cwd) {
         return null;
     return { repoRoot, ticketId };
 }
-export function renameTmuxWindow(ticketId, state) {
+export function renameSessionWindow(ticketId, state) {
     const mux = getMultiplexer();
     if (!mux.isActive())
         return;
@@ -40,25 +39,9 @@ export function renameTmuxWindow(ticketId, state) {
     }
     mux.renameWindow("", name);
 }
-export function runHookScript(repoRoot, state, env) {
-    const script = path.join(repoRoot, ".santree", "hooks", `on-${state}.sh`);
-    try {
-        fs.accessSync(script, fs.constants.X_OK);
-    }
-    catch {
-        return;
-    }
-    const child = spawn(script, [], {
-        cwd: env.SANTREE_WORKTREE_PATH,
-        env: { ...process.env, ...env },
-        stdio: "ignore",
-        detached: true,
-    });
-    child.unref();
-}
 /**
  * Unified helper: reads stdin, extracts repo/ticket, writes state file,
- * renames tmux window, runs hook script, then exits.
+ * renames the multiplexer window, then exits.
  */
 export function signalState(state) {
     const input = readStdin();
@@ -85,16 +68,7 @@ export function signalState(state) {
         at: new Date().toISOString(),
     };
     fs.writeFileSync(stateFile, JSON.stringify(payload, null, 2) + "\n");
-    renameTmuxWindow(ticketId, state);
-    const worktreePath = path.join(repoRoot, ".santree", "worktrees", ticketId);
-    runHookScript(repoRoot, state, {
-        SANTREE_TICKET_ID: ticketId,
-        SANTREE_SESSION_STATE: state,
-        SANTREE_SESSION_ID: data.session_id ?? "",
-        SANTREE_WORKTREE_PATH: worktreePath,
-        SANTREE_REPO_ROOT: repoRoot,
-        SANTREE_MESSAGE: payload.message ?? "",
-    });
+    renameSessionWindow(ticketId, state);
     process.exit(0);
 }
 export function getHooksJson() {

package/dist/lib/trackers/auth-store.d.ts

@@ -0,0 +1,16 @@
+export interface LinearTokens {
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+    org_name: string;
+}
+export interface AuthStoreV2 {
+    version: 2;
+    linear: Record<string, LinearTokens>;
+    github: Record<string, never>;
+}
+export declare function readAuthStore(): AuthStoreV2;
+export declare function writeAuthStore(store: AuthStoreV2): void;
+export declare function readLinearAuthStore(): Record<string, LinearTokens>;
+export declare function writeLinearTokens(orgSlug: string, tokens: LinearTokens): void;
+export declare function deleteLinearTokens(orgSlug: string): void;

package/dist/lib/trackers/auth-store.js

@@ -0,0 +1,57 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+const CONFIG_DIR = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+const AUTH_FILE_PATH = path.join(CONFIG_DIR, "santree", "auth.json");
+function emptyStore() {
+    return { version: 2, linear: {}, github: {} };
+}
+export function readAuthStore() {
+    if (!fs.existsSync(AUTH_FILE_PATH))
+        return emptyStore();
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(AUTH_FILE_PATH, "utf-8"));
+    }
+    catch {
+        return emptyStore();
+    }
+    if (raw && typeof raw === "object" && raw.version === 2) {
+        const v2 = raw;
+        return {
+            version: 2,
+            linear: v2.linear ?? {},
+            github: (v2.github ?? {}),
+        };
+    }
+    const migrated = emptyStore();
+    if (raw && typeof raw === "object") {
+        for (const [k, v] of Object.entries(raw)) {
+            if (v && typeof v === "object" && "access_token" in v) {
+                migrated.linear[k] = v;
+            }
+        }
+    }
+    writeAuthStore(migrated);
+    return migrated;
+}
+export function writeAuthStore(store) {
+    const dir = path.dirname(AUTH_FILE_PATH);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(AUTH_FILE_PATH, JSON.stringify(store, null, 2) + "\n", { mode: 0o600 });
+}
+export function readLinearAuthStore() {
+    return readAuthStore().linear;
+}
+export function writeLinearTokens(orgSlug, tokens) {
+    const store = readAuthStore();
+    store.linear[orgSlug] = tokens;
+    writeAuthStore(store);
+}
+export function deleteLinearTokens(orgSlug) {
+    const store = readAuthStore();
+    delete store.linear[orgSlug];
+    writeAuthStore(store);
+}

package/dist/lib/trackers/config.d.ts

@@ -0,0 +1,8 @@
+import type { IssueTrackerKind } from "./types.js";
+export interface TrackerConfig {
+    kind: IssueTrackerKind | null;
+    legacyLinearOrg: string | null;
+}
+export declare function readTrackerConfig(repoRoot: string): TrackerConfig;
+export declare function setRepoTracker(repoRoot: string, kind: IssueTrackerKind): void;
+export declare function removeRepoTracker(repoRoot: string): void;

package/dist/lib/trackers/config.js

@@ -0,0 +1,21 @@
+import { readAllMetadata, writeAllMetadata } from "../metadata.js";
+export function readTrackerConfig(repoRoot) {
+    const all = readAllMetadata(repoRoot);
+    const tracker = all._tracker;
+    const linear = all._linear;
+    let kind = null;
+    if (tracker?.kind === "linear" || tracker?.kind === "github") {
+        kind = tracker.kind;
+    }
+    return { kind, legacyLinearOrg: linear?.org ?? null };
+}
+export function setRepoTracker(repoRoot, kind) {
+    const all = readAllMetadata(repoRoot);
+    all._tracker = { kind };
+    writeAllMetadata(repoRoot, all);
+}
+export function removeRepoTracker(repoRoot) {
+    const all = readAllMetadata(repoRoot);
+    delete all._tracker;
+    writeAllMetadata(repoRoot, all);
+}

package/dist/lib/trackers/github/api.d.ts

@@ -0,0 +1,3 @@
+import type { AssignedIssue, Issue } from "../types.js";
+export declare function fetchAssignedIssues(repoNwo: string): Promise<AssignedIssue[] | null>;
+export declare function fetchIssue(repoNwo: string, identifier: string): Promise<Issue | null>;

package/dist/lib/trackers/github/api.js

@@ -0,0 +1,90 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+const PRIORITY_PATTERNS = [
+    { regex: /^p0(?:\b|:|-)|urgent|critical/i, rank: 1, label: "Urgent" },
+    { regex: /^p1(?:\b|:|-)|high(?:[ -]priority)?/i, rank: 2, label: "High" },
+    { regex: /^p2(?:\b|:|-)|medium(?:[ -]priority)?/i, rank: 3, label: "Medium" },
+    { regex: /^p3(?:\b|:|-)|low(?:[ -]priority)?/i, rank: 4, label: "Low" },
+];
+function priorityFromLabels(labels) {
+    for (const label of labels) {
+        for (const pat of PRIORITY_PATTERNS) {
+            if (pat.regex.test(label)) {
+                return { priority: pat.rank, priorityLabel: pat.label };
+            }
+        }
+    }
+    return { priority: 0, priorityLabel: "No priority" };
+}
+function deriveState(state, stateReason) {
+    if (state === "closed") {
+        const completed = !stateReason || stateReason === "completed";
+        return { name: completed ? "Done" : "Cancelled", type: completed ? "completed" : "canceled" };
+    }
+    return { name: "Open", type: "started" };
+}
+function ghJsonRun(cmd) {
+    return execAsync(cmd, { maxBuffer: 10 * 1024 * 1024 })
+        .then(({ stdout }) => {
+        try {
+            return JSON.parse(stdout);
+        }
+        catch {
+            return null;
+        }
+    })
+        .catch(() => null);
+}
+export async function fetchAssignedIssues(repoNwo) {
+    const cmd = `gh search issues --assignee=@me --state=open --repo ${repoNwo} --limit 100 --json number,title,body,url,state,labels,repository`;
+    const result = await ghJsonRun(cmd);
+    if (!result)
+        return null;
+    return result.map((row) => {
+        const labels = (row.labels ?? []).map((l) => l.name);
+        const { priority, priorityLabel } = priorityFromLabels(labels);
+        return {
+            identifier: String(row.number),
+            title: row.title,
+            description: row.body ?? null,
+            url: row.url,
+            priority,
+            priorityLabel,
+            state: deriveState(row.state.toLowerCase()),
+            labels,
+            projectId: null,
+            projectName: row.repository?.nameWithOwner ?? null,
+        };
+    });
+}
+export async function fetchIssue(repoNwo, identifier) {
+    const number = identifier.replace(/^#/, "");
+    if (!/^\d+$/.test(number))
+        return null;
+    const issue = await ghJsonRun(`gh api repos/${repoNwo}/issues/${number}`);
+    if (!issue)
+        return null;
+    const commentsRaw = await ghJsonRun(`gh api repos/${repoNwo}/issues/${number}/comments --paginate`);
+    const labels = issue.labels.map((l) => l.name);
+    const { priority, priorityLabel } = priorityFromLabels(labels);
+    const comments = (commentsRaw ?? []).map((c) => ({
+        author: c.user.login,
+        body: c.body,
+        createdAt: c.created_at,
+        children: [],
+    }));
+    return {
+        identifier: String(issue.number),
+        title: issue.title,
+        description: issue.body ?? null,
+        url: issue.html_url,
+        priority,
+        priorityLabel,
+        state: deriveState(issue.state, issue.state_reason ?? null),
+        labels,
+        projectId: issue.milestone?.number ? String(issue.milestone.number) : null,
+        projectName: issue.milestone?.title ?? repoNwo,
+        comments,
+    };
+}

package/dist/lib/trackers/github/auth.d.ts

@@ -0,0 +1,5 @@
+export interface GhUser {
+    login: string;
+}
+export declare function getAuthenticatedUser(): Promise<GhUser | null>;
+export declare function getCurrentRepoNwo(cwd?: string): Promise<string | null>;

package/dist/lib/trackers/github/auth.js

@@ -0,0 +1,27 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+export async function getAuthenticatedUser() {
+    try {
+        const { stdout } = await execAsync("gh api user --jq .login");
+        const login = stdout.trim();
+        if (!login)
+            return null;
+        return { login };
+    }
+    catch {
+        return null;
+    }
+}
+export async function getCurrentRepoNwo(cwd) {
+    try {
+        const { stdout } = await execAsync("gh repo view --json nameWithOwner --jq .nameWithOwner", {
+            cwd,
+        });
+        const nwo = stdout.trim();
+        return nwo || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/trackers/github/images.d.ts

@@ -0,0 +1,2 @@
+export declare function rewriteGithubImages(markdown: string, identifier: string): Promise<string>;
+export declare function cleanupGithubImages(identifier: string): void;

package/dist/lib/trackers/github/images.js

@@ -0,0 +1,42 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+function getTempImageDir(identifier) {
+    return path.join(os.tmpdir(), `santree-images-gh-${identifier}`);
+}
+export async function rewriteGithubImages(markdown, identifier) {
+    const imageRegex = /!\[([^\]]*)\]\((https:\/\/(?:user-images\.githubusercontent\.com|github\.com\/[^)]*\/assets|private-user-images\.githubusercontent\.com)[^)]+)\)/g;
+    const matches = [...markdown.matchAll(imageRegex)];
+    if (matches.length === 0)
+        return markdown;
+    const tempDir = getTempImageDir(identifier);
+    if (!fs.existsSync(tempDir)) {
+        fs.mkdirSync(tempDir, { recursive: true });
+    }
+    let result = markdown;
+    for (let i = 0; i < matches.length; i++) {
+        const match = matches[i];
+        const [fullMatch, altText, url] = match;
+        try {
+            const res = await fetch(url);
+            if (!res.ok)
+                continue;
+            const buffer = Buffer.from(await res.arrayBuffer());
+            const ext = path.extname(new URL(url).pathname) || ".png";
+            const filename = `image-${i}${ext}`;
+            const filePath = path.join(tempDir, filename);
+            fs.writeFileSync(filePath, buffer);
+            result = result.replace(fullMatch, `![${altText}](${filePath})`);
+        }
+        catch {
+            // keep original URL on failure
+        }
+    }
+    return result;
+}
+export function cleanupGithubImages(identifier) {
+    const tempDir = getTempImageDir(identifier);
+    if (fs.existsSync(tempDir)) {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+}

package/dist/lib/trackers/github/index.d.ts

@@ -0,0 +1,2 @@
+import type { IssueTracker } from "../types.js";
+export declare const githubTracker: IssueTracker;

package/dist/lib/trackers/github/index.js

@@ -0,0 +1,78 @@
+import { getAuthenticatedUser, getCurrentRepoNwo } from "./auth.js";
+import { fetchAssignedIssues, fetchIssue } from "./api.js";
+import { cleanupGithubImages, rewriteGithubImages } from "./images.js";
+async function getAuthStatus(_repoRoot) {
+    const user = await getAuthenticatedUser();
+    if (!user) {
+        return { authenticated: false, hint: "Run: santree github auth (or: gh auth login)" };
+    }
+    return {
+        authenticated: true,
+        accountLabel: `@${user.login}`,
+        repoLinked: true,
+    };
+}
+async function signOut(_repoRoot) {
+    // gh CLI owns the token. No santree-side credential to clear.
+}
+function extractIdFromBranch(branch) {
+    // Require an explicit prefix so commit-style branches like `fix-typo-1`
+    // don't match. Recognized: `gh-NN`, `issue-NN`, `#NN`, or a slash-separated
+    // number segment (e.g. `feature/123-foo`, `123-foo`).
+    const explicit = branch.match(/(?:^|[/_-])(?:gh-|issue-|#)(\d+)/i);
+    if (explicit?.[1])
+        return explicit[1];
+    const slashLed = branch.match(/(?:^|\/)(\d+)(?:-|$)/);
+    if (slashLed?.[1])
+        return slashLed[1];
+    return null;
+}
+async function listAssigned(repoRoot) {
+    const user = await getAuthenticatedUser();
+    if (!user) {
+        return {
+            ok: false,
+            reason: "unauthenticated",
+            message: "Run: santree github auth (or: gh auth login)",
+        };
+    }
+    const nwo = await getCurrentRepoNwo(repoRoot);
+    if (!nwo) {
+        return { ok: false, reason: "network", message: "Could not resolve GitHub repo" };
+    }
+    const issues = await fetchAssignedIssues(nwo);
+    if (issues === null) {
+        return { ok: false, reason: "network", message: "GitHub API request failed" };
+    }
+    return { ok: true, value: issues };
+}
+async function getIssue(identifier, repoRoot) {
+    const nwo = await getCurrentRepoNwo(repoRoot);
+    if (!nwo) {
+        return { ok: false, reason: "network", message: "Could not resolve GitHub repo" };
+    }
+    const issue = await fetchIssue(nwo, identifier);
+    if (!issue) {
+        return { ok: false, reason: "not-found", message: `Issue #${identifier} not found` };
+    }
+    if (issue.description) {
+        issue.description = await rewriteGithubImages(issue.description, identifier);
+    }
+    for (const comment of issue.comments) {
+        if (comment.body) {
+            comment.body = await rewriteGithubImages(comment.body, identifier);
+        }
+    }
+    return { ok: true, value: issue };
+}
+export const githubTracker = {
+    kind: "github",
+    displayName: "GitHub",
+    issueNoun: "issue",
+    getAuthStatus,
+    signOut,
+    extractIdFromBranch,
+    cleanupCache: cleanupGithubImages,
+    listAssigned,
+    getIssue,
+};

package/dist/lib/trackers/index.d.ts

@@ -0,0 +1,12 @@
+import type { IssueTracker, IssueTrackerKind } from "./types.js";
+export type { AssignedIssue, AuthStatus, Comment, Issue, IssueTracker, IssueTrackerKind, IssueTrackerResult, State, } from "./types.js";
+export { setRepoTracker, removeRepoTracker, readTrackerConfig } from "./config.js";
+/**
+ * Resolve the active IssueTracker for a given repo. Selection order:
+ *   1. SANTREE_TRACKER env override (matches SANTREE_MULTIPLEXER pattern).
+ *   2. Per-repo `_tracker.kind` in .santree/metadata.json.
+ *   3. Legacy `_linear.org` (treated as kind: "linear" so existing repos keep working).
+ *   4. Auto-detect: any stored Linear creds → Linear, else GitHub (gh is always available).
+ */
+export declare function getIssueTracker(repoRoot: string | null): IssueTracker;
+export declare function getActiveTrackerKind(repoRoot: string | null): IssueTrackerKind;

package/dist/lib/trackers/index.js

@@ -0,0 +1,34 @@
+import { linearTracker } from "./linear/index.js";
+import { githubTracker } from "./github/index.js";
+import { readTrackerConfig } from "./config.js";
+import { readLinearAuthStore } from "./auth-store.js";
+export { setRepoTracker, removeRepoTracker, readTrackerConfig } from "./config.js";
+/**
+ * Resolve the active IssueTracker for a given repo. Selection order:
+ *   1. SANTREE_TRACKER env override (matches SANTREE_MULTIPLEXER pattern).
+ *   2. Per-repo `_tracker.kind` in .santree/metadata.json.
+ *   3. Legacy `_linear.org` (treated as kind: "linear" so existing repos keep working).
+ *   4. Auto-detect: any stored Linear creds → Linear, else GitHub (gh is always available).
+ */
+export function getIssueTracker(repoRoot) {
+    const explicit = process.env["SANTREE_TRACKER"]?.toLowerCase();
+    if (explicit === "linear")
+        return linearTracker;
+    if (explicit === "github")
+        return githubTracker;
+    if (repoRoot) {
+        const cfg = readTrackerConfig(repoRoot);
+        if (cfg.kind === "linear")
+            return linearTracker;
+        if (cfg.kind === "github")
+            return githubTracker;
+        if (cfg.legacyLinearOrg)
+            return linearTracker;
+    }
+    if (Object.keys(readLinearAuthStore()).length > 0)
+        return linearTracker;
+    return githubTracker;
+}
+export function getActiveTrackerKind(repoRoot) {
+    return getIssueTracker(repoRoot).kind;
+}

package/dist/lib/trackers/linear/api.d.ts

@@ -0,0 +1,4 @@
+import type { AssignedIssue, Issue } from "../types.js";
+export declare const PRIORITY_MAP: Record<number, string>;
+export declare function fetchIssue(ticketId: string, accessToken: string): Promise<Issue | null>;
+export declare function fetchAssignedIssues(accessToken: string): Promise<AssignedIssue[] | null>;

package/dist/lib/trackers/linear/api.js

@@ -0,0 +1,128 @@
+const LINEAR_GRAPHQL_URL = "https://api.linear.app/graphql";
+export const PRIORITY_MAP = {
+    0: "No priority",
+    1: "Urgent",
+    2: "High",
+    3: "Medium",
+    4: "Low",
+};
+async function graphqlQuery(query, variables, accessToken) {
+    const res = await fetch(LINEAR_GRAPHQL_URL, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${accessToken}`,
+        },
+        body: JSON.stringify({ query, variables }),
+    });
+    if (!res.ok)
+        return null;
+    const json = (await res.json());
+    if (json.errors) {
+        console.error("Linear GraphQL errors:", JSON.stringify(json.errors, null, 2));
+    }
+    return json.data ?? null;
+}
+const ISSUE_QUERY = `
+query GetIssue($id: String!) {
+  issue(id: $id) {
+    identifier
+    title
+    description
+    url
+    state { name type }
+    priority
+    labels { nodes { name } }
+    project { id name }
+    comments {
+      nodes {
+        body
+        createdAt
+        parent { id }
+        user { displayName }
+        children {
+          nodes {
+            body
+            createdAt
+            user { displayName }
+          }
+        }
+      }
+    }
+  }
+}
+`;
+const ASSIGNED_ISSUES_QUERY = `
+query AssignedIssues {
+  viewer {
+    assignedIssues(
+      filter: { state: { type: { nin: ["completed", "canceled"] } } }
+      orderBy: updatedAt
+      first: 100
+    ) {
+      nodes {
+        identifier
+        title
+        description
+        url
+        priority
+        state { name type }
+        labels { nodes { name } }
+        project { id name }
+      }
+    }
+  }
+}
+`;
+function mapAssigned(issue) {
+    return {
+        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,
+    };
+}
+function mapComments(nodes) {
+    return nodes
+        .filter((c) => !c.parent)
+        .sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime())
+        .map((c) => ({
+        author: c.user?.displayName ?? "Unknown",
+        body: c.body,
+        createdAt: c.createdAt,
+        children: (c.children?.nodes ?? [])
+            .sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime())
+            .map((r) => ({
+            author: r.user?.displayName ?? "Unknown",
+            body: r.body,
+            createdAt: r.createdAt,
+            children: [],
+        })),
+    }));
+}
+export async function fetchIssue(ticketId, accessToken) {
+    const data = (await graphqlQuery(ISSUE_QUERY, { id: ticketId }, accessToken));
+    if (!data?.issue)
+        return null;
+    const base = mapAssigned(data.issue);
+    return {
+        ...base,
+        comments: mapComments(data.issue.comments?.nodes ?? []),
+    };
+}
+export async function fetchAssignedIssues(accessToken) {
+    const data = (await graphqlQuery(ASSIGNED_ISSUES_QUERY, {}, accessToken));
+    const nodes = data?.viewer?.assignedIssues?.nodes;
+    if (!nodes)
+        return null;
+    return nodes.map(mapAssigned);
+}

package/dist/lib/trackers/linear/auth.d.ts

@@ -0,0 +1,11 @@
+import { type LinearTokens } from "../auth-store.js";
+export type { LinearTokens } from "../auth-store.js";
+export declare function startOAuthFlow(): Promise<{
+    orgSlug: string;
+    orgName: string;
+} | null>;
+export declare function revokeTokens(orgSlug: string): Promise<boolean>;
+export declare function getValidTokens(orgSlug: string): Promise<LinearTokens | null>;
+export declare function getRepoLinearOrg(repoRoot: string): string | null;
+export declare function setRepoLinearOrg(repoRoot: string, orgSlug: string): void;
+export declare function removeRepoLinearOrg(repoRoot: string): void;