santree 0.5.3 → 0.5.5

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.
+ *   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.
+ *   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;

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

@@ -0,0 +1,206 @@
+import * as http from "http";
+import * as crypto from "crypto";
+import { exec } from "child_process";
+import { readAllMetadata, writeAllMetadata } from "../../metadata.js";
+import { readLinearAuthStore, writeLinearTokens, deleteLinearTokens, } from "../auth-store.js";
+const CLIENT_ID = "4be2738749371d7d3401061aabe2d11b";
+const LINEAR_AUTHORIZE_URL = "https://linear.app/oauth/authorize";
+const LINEAR_TOKEN_URL = "https://api.linear.app/oauth/token";
+const LINEAR_REVOKE_URL = "https://api.linear.app/oauth/revoke";
+const LINEAR_GRAPHQL_URL = "https://api.linear.app/graphql";
+const OAUTH_PORT = 8420;
+const REDIRECT_URI = `http://localhost:${OAUTH_PORT}`;
+function generateCodeVerifier() {
+    return crypto.randomBytes(32).toString("base64url");
+}
+function generateCodeChallenge(verifier) {
+    return crypto.createHash("sha256").update(verifier).digest("base64url");
+}
+export async function startOAuthFlow() {
+    const codeVerifier = generateCodeVerifier();
+    const codeChallenge = generateCodeChallenge(codeVerifier);
+    const state = crypto.randomBytes(16).toString("hex");
+    return new Promise((resolve) => {
+        let handled = false;
+        const server = http.createServer(async (req, res) => {
+            const url = new URL(req.url, `http://localhost`);
+            const code = url.searchParams.get("code");
+            const returnedState = url.searchParams.get("state");
+            if (!code || returnedState !== state) {
+                res.writeHead(404);
+                res.end();
+                return;
+            }
+            if (handled) {
+                res.writeHead(200);
+                res.end();
+                return;
+            }
+            handled = true;
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end("<html><body><h2>Authentication successful!</h2><p>You can close this tab.</p></body></html>");
+            try {
+                const tokens = await exchangeCode(code, REDIRECT_URI, codeVerifier);
+                const orgInfo = await fetchViewerOrg(tokens.access_token);
+                if (!orgInfo) {
+                    server.close();
+                    resolve(null);
+                    return;
+                }
+                writeLinearTokens(orgInfo.urlKey, {
+                    access_token: tokens.access_token,
+                    refresh_token: tokens.refresh_token,
+                    expires_at: tokens.expires_at,
+                    org_name: orgInfo.name,
+                });
+                server.close();
+                resolve({ orgSlug: orgInfo.urlKey, orgName: orgInfo.name });
+            }
+            catch {
+                server.close();
+                resolve(null);
+            }
+        });
+        server.listen(OAUTH_PORT, () => {
+            const params = new URLSearchParams({
+                client_id: CLIENT_ID,
+                redirect_uri: REDIRECT_URI,
+                response_type: "code",
+                scope: "read",
+                state,
+                code_challenge: codeChallenge,
+                code_challenge_method: "S256",
+            });
+            const authUrl = `${LINEAR_AUTHORIZE_URL}?${params.toString()}`;
+            const openCmd = process.platform === "darwin"
+                ? "open"
+                : process.platform === "win32"
+                    ? "start"
+                    : "xdg-open";
+            exec(`${openCmd} "${authUrl}"`, (err) => {
+                if (err) {
+                    console.error(`\nCouldn't open browser automatically. Open this URL manually:\n${authUrl}\n`);
+                }
+            });
+        });
+        setTimeout(() => {
+            server.close();
+            resolve(null);
+        }, 120_000);
+    });
+}
+async function exchangeCode(code, redirectUri, codeVerifier) {
+    const res = await fetch(LINEAR_TOKEN_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            grant_type: "authorization_code",
+            client_id: CLIENT_ID,
+            code,
+            redirect_uri: redirectUri,
+            code_verifier: codeVerifier,
+        }),
+    });
+    if (!res.ok) {
+        throw new Error(`Token exchange failed: ${res.status}`);
+    }
+    const data = (await res.json());
+    return {
+        access_token: data.access_token,
+        refresh_token: data.refresh_token,
+        expires_at: Date.now() + data.expires_in * 1000,
+    };
+}
+async function fetchViewerOrg(accessToken) {
+    const res = await fetch(LINEAR_GRAPHQL_URL, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${accessToken}`,
+        },
+        body: JSON.stringify({
+            query: `query { viewer { organization { urlKey name } } }`,
+        }),
+    });
+    if (!res.ok)
+        return null;
+    const json = (await res.json());
+    const org = json.data?.viewer?.organization;
+    return org ?? null;
+}
+function isTokenExpired(tokens) {
+    return Date.now() >= tokens.expires_at - 5 * 60 * 1000;
+}
+async function refreshTokens(orgSlug, tokens) {
+    try {
+        const res = await fetch(LINEAR_TOKEN_URL, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({
+                grant_type: "refresh_token",
+                client_id: CLIENT_ID,
+                refresh_token: tokens.refresh_token,
+            }),
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        const updated = {
+            access_token: data.access_token,
+            refresh_token: data.refresh_token,
+            expires_at: Date.now() + data.expires_in * 1000,
+            org_name: tokens.org_name,
+        };
+        writeLinearTokens(orgSlug, updated);
+        return updated;
+    }
+    catch {
+        return null;
+    }
+}
+export async function revokeTokens(orgSlug) {
+    const store = readLinearAuthStore();
+    const tokens = store[orgSlug];
+    if (!tokens)
+        return false;
+    try {
+        await fetch(LINEAR_REVOKE_URL, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({
+                client_id: CLIENT_ID,
+                token: tokens.access_token,
+            }),
+        });
+    }
+    catch {
+        // best effort
+    }
+    deleteLinearTokens(orgSlug);
+    return true;
+}
+export async function getValidTokens(orgSlug) {
+    const store = readLinearAuthStore();
+    const tokens = store[orgSlug];
+    if (!tokens)
+        return null;
+    if (isTokenExpired(tokens)) {
+        return refreshTokens(orgSlug, tokens);
+    }
+    return tokens;
+}
+export function getRepoLinearOrg(repoRoot) {
+    const all = readAllMetadata(repoRoot);
+    const linear = all._linear;
+    return linear?.org ?? null;
+}
+export function setRepoLinearOrg(repoRoot, orgSlug) {
+    const all = readAllMetadata(repoRoot);
+    all._linear = { org: orgSlug };
+    writeAllMetadata(repoRoot, all);
+}
+export function removeRepoLinearOrg(repoRoot) {
+    const all = readAllMetadata(repoRoot);
+    delete all._linear;
+    writeAllMetadata(repoRoot, all);
+}

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

@@ -0,0 +1,2 @@
+export declare function rewriteLinearImages(markdown: string, ticketId: string, accessToken: string): Promise<string>;
+export declare function cleanupLinearImages(ticketId: string): void;