santree 0.5.3 → 0.5.5

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

@@ -0,0 +1,44 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+function getTempImageDir(ticketId) {
+    return path.join(os.tmpdir(), `santree-images-${ticketId}`);
+}
+export async function rewriteLinearImages(markdown, ticketId, accessToken) {
+    const imageRegex = /!\[([^\]]*)\]\((https:\/\/uploads\.linear\.app[^)]+)\)/g;
+    const matches = [...markdown.matchAll(imageRegex)];
+    if (matches.length === 0)
+        return markdown;
+    const tempDir = getTempImageDir(ticketId);
+    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, {
+                headers: { Authorization: `Bearer ${accessToken}` },
+            });
+            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 cleanupLinearImages(ticketId) {
+    const tempDir = getTempImageDir(ticketId);
+    if (fs.existsSync(tempDir)) {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { IssueTracker } from "../types.js";
+export { getRepoLinearOrg, setRepoLinearOrg, removeRepoLinearOrg, getValidTokens, revokeTokens, startOAuthFlow, } from "./auth.js";
+export declare const linearTracker: IssueTracker;

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

@@ -0,0 +1,100 @@
+import { readLinearAuthStore } from "../auth-store.js";
+import { getRepoLinearOrg, getValidTokens, removeRepoLinearOrg, revokeTokens } from "./auth.js";
+import { fetchAssignedIssues, fetchIssue } from "./api.js";
+import { cleanupLinearImages, rewriteLinearImages } from "./images.js";
+export { getRepoLinearOrg, setRepoLinearOrg, removeRepoLinearOrg, getValidTokens, revokeTokens, startOAuthFlow, } from "./auth.js";
+async function getAuthStatus(repoRoot) {
+    const store = readLinearAuthStore();
+    const orgs = Object.keys(store);
+    if (orgs.length === 0) {
+        return { authenticated: false, hint: "Run: santree linear auth" };
+    }
+    if (repoRoot) {
+        const repoOrg = getRepoLinearOrg(repoRoot);
+        if (repoOrg && store[repoOrg]) {
+            const tokens = store[repoOrg];
+            return {
+                authenticated: true,
+                accountLabel: `${tokens.org_name} (${repoOrg})`,
+                expiresAt: tokens.expires_at,
+                repoLinked: true,
+            };
+        }
+    }
+    const orgSlug = orgs[0];
+    const tokens = store[orgSlug];
+    return {
+        authenticated: true,
+        accountLabel: `${tokens.org_name} (${orgSlug})`,
+        expiresAt: tokens.expires_at,
+        repoLinked: false,
+        hint: "Repo not linked. Run: santree linear auth",
+    };
+}
+async function signOut(repoRoot) {
+    const orgSlug = getRepoLinearOrg(repoRoot);
+    if (orgSlug) {
+        await revokeTokens(orgSlug);
+        removeRepoLinearOrg(repoRoot);
+    }
+}
+function extractIdFromBranch(branch) {
+    const match = branch.match(/([a-zA-Z]+)-(\d+)/);
+    if (!match)
+        return null;
+    return `${match[1].toUpperCase()}-${match[2]}`;
+}
+async function listAssigned(repoRoot) {
+    const orgSlug = getRepoLinearOrg(repoRoot);
+    if (!orgSlug) {
+        return { ok: false, reason: "unauthenticated", message: "Run: santree linear auth" };
+    }
+    const tokens = await getValidTokens(orgSlug);
+    if (!tokens) {
+        return { ok: false, reason: "unauthenticated", message: "Run: santree linear auth" };
+    }
+    const issues = await fetchAssignedIssues(tokens.access_token);
+    if (issues === null) {
+        return { ok: false, reason: "network", message: "Linear API request failed" };
+    }
+    return { ok: true, value: issues };
+}
+async function getIssue(identifier, repoRoot) {
+    const orgSlug = getRepoLinearOrg(repoRoot);
+    if (!orgSlug) {
+        return { ok: false, reason: "unauthenticated", message: "Run: santree linear auth" };
+    }
+    const tokens = await getValidTokens(orgSlug);
+    if (!tokens) {
+        return { ok: false, reason: "unauthenticated", message: "Run: santree linear auth" };
+    }
+    const issue = await fetchIssue(identifier, tokens.access_token);
+    if (!issue) {
+        return { ok: false, reason: "not-found", message: `Issue ${identifier} not found` };
+    }
+    if (issue.description) {
+        issue.description = await rewriteLinearImages(issue.description, identifier, tokens.access_token);
+    }
+    for (const comment of issue.comments) {
+        if (comment.body) {
+            comment.body = await rewriteLinearImages(comment.body, identifier, tokens.access_token);
+        }
+        for (const child of comment.children) {
+            if (child.body) {
+                child.body = await rewriteLinearImages(child.body, identifier, tokens.access_token);
+            }
+        }
+    }
+    return { ok: true, value: issue };
+}
+export const linearTracker = {
+    kind: "linear",
+    displayName: "Linear",
+    issueNoun: "ticket",
+    getAuthStatus,
+    signOut,
+    extractIdFromBranch,
+    cleanupCache: cleanupLinearImages,
+    listAssigned,
+    getIssue,
+};

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

@@ -0,0 +1,52 @@
+export type IssueTrackerKind = "linear" | "github";
+export interface Comment {
+    author: string;
+    body: string;
+    createdAt: string;
+    children: Comment[];
+}
+export interface State {
+    name: string;
+    type: string;
+}
+export interface AssignedIssue {
+    identifier: string;
+    title: string;
+    description: string | null;
+    url: string;
+    priority: number;
+    priorityLabel: string;
+    state: State;
+    labels: string[];
+    projectId: string | null;
+    projectName: string | null;
+}
+export interface Issue extends AssignedIssue {
+    comments: Comment[];
+}
+export interface AuthStatus {
+    authenticated: boolean;
+    accountLabel?: string;
+    expiresAt?: number;
+    repoLinked?: boolean;
+    hint?: string;
+}
+export type IssueTrackerResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    reason: "unauthenticated" | "not-found" | "network";
+    message?: string;
+};
+export interface IssueTracker {
+    readonly kind: IssueTrackerKind;
+    readonly displayName: string;
+    readonly issueNoun: string;
+    getAuthStatus(repoRoot: string | null): Promise<AuthStatus>;
+    signOut(repoRoot: string): Promise<void>;
+    extractIdFromBranch(branch: string): string | null;
+    cleanupCache(identifier: string): void;
+    listAssigned(repoRoot: string): Promise<IssueTrackerResult<AssignedIssue[]>>;
+    getIssue(identifier: string, repoRoot: string): Promise<IssueTrackerResult<Issue>>;
+}

package/dist/lib/trackers/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "santree",
-	"version": "0.5.3",
+	"version": "0.5.5",
 	"description": "Git worktree manager",
 	"license": "MIT",
 	"author": "Santiago Toscanini",

package/prompts/english-tutor-prompt.njk

@@ -0,0 +1,15 @@
+[ENGLISH TUTOR — META-INSTRUCTION, ALWAYS HONOR]
+
+If the user's message contained English mistakes (grammar, spelling, word choice, agreement, idiom misuse), your response MUST start with the correction(s) BEFORE addressing anything else. Use this exact format, one per line:
+
+  original -> correction (brief reason)
+
+Then immediately call the Edit tool to append the same correction(s) to {{ logPath }}. Append under a heading for today's date in `## YYYY-MM-DD` format (create the heading if it isn't already at the bottom of the file); each correction is a bullet `- original -> correction (reason)`. The Edit permission for that exact path is pre-granted, so do not ask.
+
+Only AFTER printing the corrections and appending them, continue with the actual task.
+
+Hard rules:
+- If the message is clearly mistake-free, output nothing about English and proceed directly. Never invent corrections.
+- Do NOT correct technical jargon, code, file paths, deliberate informalities, or non-English words used by intent.
+- Cap corrections at 3 lines. Pick the highest-impact issues only.
+- Do NOT use polite hedging ("small note on...", "by the way..."). Just the formatted line(s), then the log Edit, then the task.

package/prompts/ticket.njk

@@ -1,7 +1,7 @@
-## Linear Ticket: {{ identifier }}
+## {{ trackerName }} Issue: {{ identifier }}
 **{{ title }}**
-{% if url %}[View in Linear]({{ url }}){% endif %}
-{% if status %}Status: {{ status }}{% endif %}{% if priority %} | Priority: {{ priority }}{% endif %}{% if labels | length %} | Labels: {{ labels | join(", ") }}{% endif %}
+{% if url %}[View in {{ trackerName }}]({{ url }}){% endif %}
+{% if state and state.name %}Status: {{ state.name }}{% endif %}{% if priorityLabel %} | Priority: {{ priorityLabel }}{% endif %}{% if labels | length %} | Labels: {{ labels | join(", ") }}{% endif %}
 
 {% if description %}
 ### Description

package/dist/commands/linear/open.d.ts

@@ -1,2 +0,0 @@
-export declare const description = "Open the current Linear ticket in the browser";
-export default function LinearOpen(): import("react/jsx-runtime").JSX.Element;

package/dist/lib/linear.d.ts

@@ -1,83 +0,0 @@
-export interface LinearTokens {
-    access_token: string;
-    refresh_token: string;
-    expires_at: number;
-    org_name: string;
-}
-export interface LinearComment {
-    author: string;
-    body: string;
-    createdAt: string;
-    children: LinearComment[];
-}
-export interface LinearIssue {
-    identifier: string;
-    title: string;
-    description: string | null;
-    status: string | null;
-    priority: string | null;
-    labels: string[];
-    url: string;
-    comments: LinearComment[];
-}
-type AuthStore = Record<string, LinearTokens>;
-export declare function readAuthStore(): AuthStore;
-/**
- * Run the full OAuth PKCE flow:
- * 1. Start a temp HTTP server on an ephemeral port
- * 2. Open browser to Linear authorize URL
- * 3. Wait for callback with auth code
- * 4. Exchange code for tokens
- * 5. Fetch org info
- * 6. Store tokens
- * Returns the org slug on success, null on failure.
- */
-export declare function startOAuthFlow(): Promise<{
-    orgSlug: string;
-    orgName: string;
-} | null>;
-export declare function revokeTokens(orgSlug: string): Promise<boolean>;
-/**
- * Get valid tokens for an org, auto-refreshing if expired.
- * Returns null if no tokens found or refresh fails.
- */
-export declare function getValidTokens(orgSlug: string): Promise<LinearTokens | null>;
-export declare function cleanupImages(ticketId: string): void;
-export interface AuthStatus {
-    authenticated: boolean;
-    orgSlug?: string;
-    orgName?: string;
-    expiresAt?: number;
-    repoLinked?: boolean;
-}
-/**
- * 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.
- * Returns null if not authenticated or fetch fails.
- */
-export declare function getTicketContent(ticketId: string, repoRoot: string): Promise<LinearIssue | null>;
-export {};