santree 0.6.3 → 0.7.2

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

@@ -6,6 +6,13 @@ export const PRIORITY_MAP = {
     3: "Medium",
     4: "Low",
 };
+// Workflow states whose issues should never appear in the assigned-work list,
+// matched by name (case-insensitive) regardless of their configured `type`.
+// Linear ships a default "Duplicate" state, but workspaces sometimes type it
+// as non-terminal (backlog/unstarted) rather than `canceled`, so it slips past
+// the query's `type: { nin: ["completed", "canceled"] }` filter and clutters
+// the backlog. These are resolution states — hide them everywhere.
+const HIDDEN_STATE_NAMES = new Set(["duplicate"]);
 async function graphqlQuery(query, variables, accessToken) {
     const res = await fetch(LINEAR_GRAPHQL_URL, {
         method: "POST",
@@ -30,6 +37,7 @@ query GetIssue($id: String!) {
     title
     description
     url
+    dueDate
     state { name type }
     priority
     labels { nodes { name } }
@@ -65,21 +73,31 @@ query AssignedIssues {
         title
         description
         url
+        dueDate
         priority
         state { name type }
         labels { nodes { name } }
         project { id name }
+        relations(first: 10) { nodes { type relatedIssue { identifier state { type } } } }
+        inverseRelations(first: 10) { nodes { type issue { identifier state { type } } } }
       }
     }
   }
 }
 `;
+const TERMINAL_STATE_TYPES = new Set(["completed", "canceled"]);
+function refOf(issue) {
+    if (!issue?.identifier)
+        return null;
+    return { identifier: issue.identifier, done: TERMINAL_STATE_TYPES.has(issue.state?.type ?? "") };
+}
 function mapAssigned(issue) {
     return {
         identifier: issue.identifier,
         title: issue.title,
         description: issue.description ?? null,
         url: issue.url,
+        dueDate: issue.dueDate ?? null,
         priority: issue.priority,
         priorityLabel: PRIORITY_MAP[issue.priority] ?? "No priority",
         state: {
@@ -89,6 +107,23 @@ function mapAssigned(issue) {
         labels: (issue.labels?.nodes ?? []).map((l) => l.name),
         projectId: issue.project?.id ?? null,
         projectName: issue.project?.name ?? null,
+        // Dependency relations. `inverseRelations` of type "blocks" point at this
+        // issue → those are its blockers; `relations` of type "blocks" point away
+        // → those are what it blocks. Left undefined when the query didn't fetch
+        // relations (e.g. the single-issue ISSUE_QUERY) so callers can tell
+        // "no blockers" from "unknown".
+        blockedBy: issue.inverseRelations
+            ? (issue.inverseRelations.nodes ?? [])
+                .filter((r) => r.type === "blocks")
+                .map((r) => refOf(r.issue))
+                .filter((r) => r !== null)
+            : undefined,
+        blocking: issue.relations
+            ? (issue.relations.nodes ?? [])
+                .filter((r) => r.type === "blocks")
+                .map((r) => refOf(r.relatedIssue))
+                .filter((r) => r !== null)
+            : undefined,
     };
 }
 function mapComments(nodes) {
@@ -119,10 +154,111 @@ export async function fetchIssue(ticketId, accessToken) {
         comments: mapComments(data.issue.comments?.nodes ?? []),
     };
 }
+// ── Triage on-call schedules ──────────────────────────────────────────
+// Linear's "Triage responsibility" can be backed by a time schedule (a weekly
+// on-call rotation). We surface the schedules for the teams the viewer belongs
+// to. Schedule entries reference users by id only, so a follow-up `users`
+// lookup resolves display names.
+const TRIAGE_SCHEDULES_QUERY = `
+query TriageSchedules {
+  viewer {
+    id
+    teamMemberships(first: 100) {
+      nodes {
+        team {
+          key
+          name
+          triageResponsibility {
+            currentUser { id }
+            timeSchedule {
+              name
+              entries { startsAt endsAt userId userEmail }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+`;
+/** Resolve user ids → display names via a single `users` query. */
+async function resolveUserNames(ids, accessToken) {
+    if (ids.length === 0)
+        return {};
+    const query = `query ResolveUsers($ids: [ID!]!) {
+		users(filter: { id: { in: $ids } }, first: 250) { nodes { id displayName } }
+	}`;
+    const data = (await graphqlQuery(query, { ids }, accessToken));
+    const map = {};
+    for (const u of data?.users?.nodes ?? [])
+        map[u.id] = u.displayName;
+    return map;
+}
+export async function fetchTriageSchedules(accessToken) {
+    const data = (await graphqlQuery(TRIAGE_SCHEDULES_QUERY, {}, accessToken));
+    const viewerId = data?.viewer?.id ?? null;
+    const memberships = data?.viewer?.teamMemberships?.nodes ?? [];
+    // Keep only teams whose triage responsibility is backed by a time schedule
+    // with at least one entry.
+    const teams = memberships
+        .map((m) => m.team)
+        .filter((t) => !!t && (t.triageResponsibility?.timeSchedule?.entries?.length ?? 0) > 0);
+    if (teams.length === 0)
+        return [];
+    // Resolve every referenced user id in one batch.
+    const ids = new Set();
+    for (const t of teams) {
+        const tr = t.triageResponsibility;
+        if (tr.currentUser?.id)
+            ids.add(tr.currentUser.id);
+        for (const e of tr.timeSchedule?.entries ?? [])
+            if (e.userId)
+                ids.add(e.userId);
+    }
+    const names = await resolveUserNames([...ids], accessToken);
+    const now = Date.now();
+    const schedules = teams.map((t) => {
+        const tr = t.triageResponsibility;
+        const shifts = (tr.timeSchedule?.entries ?? [])
+            .map((e) => {
+            const start = Date.parse(e.startsAt);
+            const end = Date.parse(e.endsAt);
+            return {
+                startsAt: e.startsAt,
+                endsAt: e.endsAt,
+                name: (e.userId && names[e.userId]) || e.userEmail || "Unknown",
+                isCurrent: now >= start && now < end,
+                isMe: !!viewerId && e.userId === viewerId,
+            };
+        })
+            .sort((a, b) => Date.parse(a.startsAt) - Date.parse(b.startsAt));
+        const currentShift = shifts.find((s) => s.isCurrent) ?? null;
+        const currentUserId = tr.currentUser?.id ?? null;
+        const currentName = currentShift?.name ?? (currentUserId ? (names[currentUserId] ?? null) : null);
+        const currentIsMe = currentShift?.isMe ?? (!!viewerId && currentUserId === viewerId);
+        return {
+            teamKey: t.key,
+            teamName: t.name,
+            scheduleName: tr.timeSchedule?.name ?? `${t.key} triage`,
+            currentName,
+            currentIsMe,
+            shifts,
+        };
+    });
+    // Surface schedules the viewer actually participates in first.
+    schedules.sort((a, b) => {
+        const am = a.shifts.some((s) => s.isMe) ? 0 : 1;
+        const bm = b.shifts.some((s) => s.isMe) ? 0 : 1;
+        return am - bm;
+    });
+    return schedules;
+}
 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);
+    return nodes
+        .map(mapAssigned)
+        .filter((i) => !HIDDEN_STATE_NAMES.has(i.state.name.trim().toLowerCase()));
 }

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

@@ -1,6 +1,6 @@
 import { readLinearAuthStore } from "../auth-store.js";
 import { getRepoLinearOrg, getValidTokens, removeRepoLinearOrg, revokeTokens } from "./auth.js";
-import { fetchAssignedIssues, fetchIssue } from "./api.js";
+import { fetchAssignedIssues, fetchIssue, fetchTriageSchedules } from "./api.js";
 import { cleanupLinearImages, rewriteLinearImages } from "./images.js";
 export { getRepoLinearOrg, setRepoLinearOrg, removeRepoLinearOrg, getValidTokens, revokeTokens, startOAuthFlow, } from "./auth.js";
 async function getAuthStatus(repoRoot) {
@@ -59,6 +59,20 @@ async function listAssigned(repoRoot) {
     }
     return { ok: true, value: issues };
 }
+async function getTriageSchedules(repoRoot) {
+    const orgSlug = getRepoLinearOrg(repoRoot);
+    if (!orgSlug)
+        return [];
+    const tokens = await getValidTokens(orgSlug);
+    if (!tokens)
+        return [];
+    try {
+        return await fetchTriageSchedules(tokens.access_token);
+    }
+    catch {
+        return [];
+    }
+}
 async function getIssue(identifier, repoRoot) {
     const orgSlug = getRepoLinearOrg(repoRoot);
     if (!orgSlug) {
@@ -91,10 +105,12 @@ export const linearTracker = {
     kind: "linear",
     displayName: "Linear",
     issueNoun: "ticket",
+    supportsTriage: true,
     getAuthStatus,
     signOut,
     extractIdFromBranch,
     cleanupCache: cleanupLinearImages,
     listAssigned,
     getIssue,
+    getTriageSchedules,
 };

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

@@ -9,6 +9,18 @@ export interface State {
     name: string;
     type: string;
 }
+/** Readiness of an issue given its blocking dependencies:
+ *   "ready"   — no unresolved blockers (or none at all)
+ *   "blocked" — at least one blocker isn't done yet
+ *   "unknown" — the tracker doesn't expose dependency data */
+export type Readiness = "ready" | "blocked" | "unknown";
+export declare function issueReadiness(blockedBy: IssueRef[] | undefined): Readiness;
+/** A lightweight reference to a related issue, with whether it's resolved
+ * (state.type is completed/canceled). Used for dependency (blocks) relations. */
+export interface IssueRef {
+    identifier: string;
+    done: boolean;
+}
 export interface AssignedIssue {
     identifier: string;
     title: string;
@@ -20,10 +32,45 @@ export interface AssignedIssue {
     labels: string[];
     projectId: string | null;
     projectName: string | null;
+    /** Issues that block this one ("blocked by"). An issue is ready to start when
+     * every blocker is `done`. `undefined` when the tracker doesn't expose
+     * dependency relations (only Linear does); `[]` means no blockers. */
+    blockedBy?: IssueRef[];
+    /** Issues this one blocks (downstream dependents). */
+    blocking?: IssueRef[];
+    /** Due date as an ISO `YYYY-MM-DD` string, or null when none is set.
+     * Only trackers with a native due-date concept populate it (Linear today);
+     * others leave it undefined. Surfaced on the Triage tab as a colored,
+     * urgency-coded badge. */
+    dueDate?: string | null;
 }
 export interface Issue extends AssignedIssue {
     comments: Comment[];
 }
+/** One slot in a triage on-call rotation. */
+export interface TriageShift {
+    startsAt: string;
+    endsAt: string;
+    /** Resolved display name (falls back to email, then "Unknown"). */
+    name: string;
+    /** True when this shift covers the current moment. */
+    isCurrent: boolean;
+    /** True when this shift belongs to the authenticated viewer. */
+    isMe: boolean;
+}
+/** A team's triage responsibility rotation (Linear "Triage responsibility"
+ * backed by a time schedule). */
+export interface TriageSchedule {
+    teamKey: string;
+    teamName: string;
+    scheduleName: string;
+    /** Display name of whoever is on call right now, if known. */
+    currentName: string | null;
+    /** Whether the viewer is the one currently on call. */
+    currentIsMe: boolean;
+    /** Chronological list of shifts. */
+    shifts: TriageShift[];
+}
 export interface AuthStatus {
     authenticated: boolean;
     accountLabel?: string;
@@ -65,6 +112,17 @@ export interface IssueTracker {
     cleanupCache(identifier: string): void;
     listAssigned(repoRoot: string): Promise<IssueTrackerResult<AssignedIssue[]>>;
     getIssue(identifier: string, repoRoot: string): Promise<IssueTrackerResult<Issue>>;
+    /** When true, this tracker has a native triage concept (incoming issues in
+     * a `state.type === "triage"` inbox). The dashboard surfaces a dedicated
+     * Triage tab only when the active tracker sets this — feature detection,
+     * never a `kind === "linear"` string check, per the
+     * no-tracker-conditionals-outside-the-factory policy. Linear sets it;
+     * GitHub/Local leave it undefined. */
+    readonly supportsTriage?: boolean;
+    /** Triage on-call rotations for the viewer's teams. Optional — implemented
+     * only by trackers with a triage scheduling concept (Linear). Returns an
+     * empty array on failure or when no schedules exist; never throws. */
+    getTriageSchedules?(repoRoot: string): Promise<TriageSchedule[]>;
     /** When true, the tracker implements createIssue/updateIssue/deleteIssue.
      * Read-only trackers (Linear, GitHub) leave this undefined; UI surfaces
      * gate every mutation path on `tracker.canMutate === true` (feature

package/dist/lib/trackers/types.js

@@ -1 +1,5 @@
-export {};
+export function issueReadiness(blockedBy) {
+    if (blockedBy === undefined)
+        return "unknown";
+    return blockedBy.some((b) => !b.done) ? "blocked" : "ready";
+}

package/package.json

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

package/prompts/ask.njk

@@ -0,0 +1,10 @@
+You are helping triage an incoming issue. Below is the full issue with all of its comments. Answer the question that follows concisely and directly, grounded in what the issue and its discussion actually say.
+
+When the question is about whether or how the issue can be fixed, you may inspect the codebase read-only (Read/Grep/Glob) to ground your answer in the real code — name the relevant files. Do not make any changes, and do not ask the user to run commands.
+
+Keep the answer short and skimmable: a few sentences or a short bullet list. If the issue lacks the information needed to answer, say what's missing.
+
+{{ ticket_content }}
+
+## Question
+{{ user_question }}