mintree 0.4.1 → 0.4.3

package/dist/commands/dashboard.js

@@ -16,6 +16,7 @@ import { buildCreateMarkers, emitMarkers } from "../lib/markers.js";
 import { readMetadata } from "../lib/metadata.js";
 import { createProvider } from "../lib/providers/index.js";
 import { loadDashboard } from "../lib/dashboard.js";
+import { priorityDisplay } from "../lib/priority.js";
 const require = createRequire(import.meta.url);
 const { version: mintreeVersion } = require("../../package.json");
 export const description = "Interactive dashboard listing open issues assigned to you with worktree + session state";
@@ -220,13 +221,17 @@ function IssueListRow({ d, selected, identifierWidth, rowWidth, }) {
     // Status-coloured leading dot — same convention as santree. Falls back to
     // gray when the issue has no project board membership.
     const dotColor = d.project?.statusColor ?? "gray";
+    // Compact priority glyph (Linear only; GitHub rows render a blank). The
+    // fixed single-width icon keeps the ids aligned whether or not a row has a
+    // priority. See lib/priority.ts.
+    const prio = priorityDisplay(d.issue.priority);
     const title = d.issue.title;
     // The leading-dot Text and the rest are nested under a single Text so the
     // selection background paints the whole row in one contiguous block.
     // `wrap="truncate"` clamps the row to a single line and Ink renders an
     // ellipsis at the cut. The outer Box has a fixed width so the wrap
     // behaviour knows where to truncate.
-    return (_jsx(Box, { width: rowWidth, children: _jsxs(Text, { wrap: "truncate", backgroundColor: selected ? "blue" : undefined, color: selected ? "white" : undefined, children: ["  ", _jsx(Text, { color: selected ? "white" : dotColor, children: "\u25CF" }), `  ${idText}  ${title}`] }) }));
+    return (_jsx(Box, { width: rowWidth, children: _jsxs(Text, { wrap: "truncate", backgroundColor: selected ? "blue" : undefined, color: selected ? "white" : undefined, children: ["  ", _jsx(Text, { color: selected ? "white" : dotColor, children: "\u25CF" }), " ", _jsx(Text, { color: selected ? "white" : prio.color, children: prio.icon }), ` ${idText}  ${title}`] }) }));
 }
 // A project board header — the top level of the grouped issue list. Mirrors
 // the bold project name + dim count seen in the santree dashboard.

package/dist/commands/update.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const description = "Update mintree to the latest version (npm i -g mintree)";
+export declare const options: z.ZodObject<{
+    force: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type Props = {
+    options: z.infer<typeof options>;
+};
+export default function Update({ options: opts }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/update.js

@@ -0,0 +1,64 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text } from "ink";
+import Spinner from "ink-spinner";
+import { option } from "pastel";
+import { z } from "zod";
+import { createRequire } from "module";
+import { getLatestVersion, isNewerVersion } from "../lib/version.js";
+import { installLatest, PACKAGE_NAME } from "../lib/update.js";
+const require = createRequire(import.meta.url);
+const { version: currentVersion } = require("../../package.json");
+export const description = "Update mintree to the latest version (npm i -g mintree)";
+export const options = z.object({
+    force: z
+        .boolean()
+        .default(false)
+        .describe(option({
+        description: "Reinstall even when you're already on the latest version",
+        alias: "f",
+    })),
+});
+export default function Update({ options: opts }) {
+    const [phase, setPhase] = useState({ kind: "checking" });
+    useEffect(() => {
+        let cancelled = false;
+        (async () => {
+            const latest = await getLatestVersion(PACKAGE_NAME);
+            if (cancelled)
+                return;
+            // Skip the reinstall only when we're provably current and the user
+            // didn't force it. A null probe (offline/private registry) falls
+            // through to the install so `mt update` still does something useful.
+            if (!opts.force && latest && !isNewerVersion(currentVersion, latest)) {
+                setPhase({ kind: "uptodate", latest });
+                return;
+            }
+            setPhase({ kind: "installing", latest });
+            const result = await installLatest();
+            if (cancelled)
+                return;
+            setPhase({ kind: "done", result, latest });
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [opts.force]);
+    if (phase.kind === "checking") {
+        return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [" Checking for updates... (current v", currentVersion, ")"] })] }));
+    }
+    if (phase.kind === "uptodate") {
+        return (_jsxs(Box, { flexDirection: "column", paddingY: 0, children: [_jsxs(Text, { color: "green", children: ["\u2713 mintree is already up to date (v", phase.latest, ")."] }), _jsx(Text, { dimColor: true, children: "Run with --force to reinstall anyway." })] }));
+    }
+    if (phase.kind === "installing") {
+        const target = phase.latest ? `v${phase.latest}` : "latest";
+        return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [" ", "Updating mintree from v", currentVersion, " to ", target, "..."] })] }));
+    }
+    // done
+    const { result, latest } = phase;
+    if (result.ok) {
+        const target = latest ? `v${latest}` : "the latest version";
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "green", children: ["\u2713 mintree updated to ", target, "."] }), _jsx(Text, { dimColor: true, children: "Open a new shell (or re-run your command) to use it." })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "\u2717 Update failed." }), _jsx(Text, { children: result.message }), result.hint ? _jsx(Text, { dimColor: true, children: result.hint }) : null] }));
+}

package/dist/lib/dashboard.js

@@ -3,6 +3,7 @@ import * as path from "path";
 import { listWorktrees, getWorktreesDir, isDirty, getAheadBehind, } from "./git.js";
 import { readMetadata } from "./metadata.js";
 import { fetchPrForBranch } from "./pr.js";
+import { prioritySortRank } from "./priority.js";
 import { createProvider } from "./providers/index.js";
 /**
  * Builds a map from issue id (the canonical string — "100" on GitHub,
@@ -95,6 +96,13 @@ function sortGroupedIssues(issues, configuredUrl) {
                 return a.project.statusOrder - b.project.statusOrder;
             }
         }
+        // Within a status group, surface higher-priority issues first
+        // (Urgent → Low; "no priority" sinks to the bottom). Orphans and
+        // GitHub rows have null priority and so fall through to the date sort.
+        const pa = prioritySortRank(a.issue.priority);
+        const pb = prioritySortRank(b.issue.priority);
+        if (pa !== pb)
+            return pa - pb;
         // Newest-first for issues — id is a numeric-or-prefixed string. Numeric
         // compare falls back to localeCompare for non-numeric ids (Linear's
         // "FE-123" form).
@@ -137,6 +145,7 @@ function buildOrphanRows(worktreesByIssue, assignedIds, sessionLookup, prByBranc
                 body: "",
                 createdAt: "",
                 updatedAt: "",
+                priority: null,
             },
             worktree,
             session: sessionLookup(issueId),

package/dist/lib/priority.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Issue priority, normalised across providers.
+ *
+ * Linear exposes a native `priority` field on the 0-4 scale:
+ *   0 = No priority, 1 = Urgent, 2 = High, 3 = Medium, 4 = Low.
+ * GitHub Issues has no native priority concept, so its provider always yields
+ * `null` here — the dashboard simply renders no priority glyph for those rows.
+ *
+ * `ProviderIssue.priority` stores the raw Linear number (or null), and these
+ * helpers turn it into a compact dashboard glyph and a sort rank. Keeping the
+ * mapping in one module means the render path (dashboard.tsx) and the sort
+ * path (dashboard.ts) stay in lock-step.
+ */
+export type PriorityValue = number | null | undefined;
+export type PriorityDisplay = {
+    /** Human label, e.g. "Urgent". Empty string when there's no priority. */
+    label: string;
+    /** Single-width glyph for the list row. A space when there's no priority. */
+    icon: string;
+    /** Ink-renderable colour name for the glyph. */
+    color: string;
+};
+/**
+ * Maps a raw priority value to its dashboard glyph. Urgent reads as a bold
+ * red bang; High/Medium/Low use arrows that step down in weight and colour.
+ * "No priority" (0) and null both render as a blank, keeping rows aligned
+ * without drawing the eye.
+ */
+export declare function priorityDisplay(priority: PriorityValue): PriorityDisplay;
+/**
+ * Sort rank for "highest priority first". Urgent (1) sorts before Low (4);
+ * "No priority" (0) and null sort last. Used as a tie-break inside a status
+ * group before the newest-first fallback.
+ */
+export declare function prioritySortRank(priority: PriorityValue): number;

package/dist/lib/priority.js

@@ -0,0 +1,44 @@
+/**
+ * Issue priority, normalised across providers.
+ *
+ * Linear exposes a native `priority` field on the 0-4 scale:
+ *   0 = No priority, 1 = Urgent, 2 = High, 3 = Medium, 4 = Low.
+ * GitHub Issues has no native priority concept, so its provider always yields
+ * `null` here — the dashboard simply renders no priority glyph for those rows.
+ *
+ * `ProviderIssue.priority` stores the raw Linear number (or null), and these
+ * helpers turn it into a compact dashboard glyph and a sort rank. Keeping the
+ * mapping in one module means the render path (dashboard.tsx) and the sort
+ * path (dashboard.ts) stay in lock-step.
+ */
+const NONE = { label: "", icon: " ", color: "gray" };
+/**
+ * Maps a raw priority value to its dashboard glyph. Urgent reads as a bold
+ * red bang; High/Medium/Low use arrows that step down in weight and colour.
+ * "No priority" (0) and null both render as a blank, keeping rows aligned
+ * without drawing the eye.
+ */
+export function priorityDisplay(priority) {
+    switch (priority) {
+        case 1:
+            return { label: "Urgent", icon: "!", color: "red" };
+        case 2:
+            return { label: "High", icon: "↑", color: "red" };
+        case 3:
+            return { label: "Medium", icon: "=", color: "yellow" };
+        case 4:
+            return { label: "Low", icon: "↓", color: "blue" };
+        default:
+            return NONE;
+    }
+}
+/**
+ * Sort rank for "highest priority first". Urgent (1) sorts before Low (4);
+ * "No priority" (0) and null sort last. Used as a tie-break inside a status
+ * group before the newest-first fallback.
+ */
+export function prioritySortRank(priority) {
+    if (priority == null || priority === 0)
+        return Number.POSITIVE_INFINITY;
+    return priority;
+}

package/dist/lib/providers/github.js

@@ -142,6 +142,8 @@ export class GithubProvider {
                 body: raw.body,
                 createdAt: raw.createdAt,
                 updatedAt: raw.updatedAt,
+                // GitHub Issues has no native priority field.
+                priority: null,
             }));
         }
         catch {

package/dist/lib/providers/linear.js

@@ -271,6 +271,7 @@ const BOOTSTRAP_QUERY = /* GraphQL */ `
 				title
 				description
 				url
+				priority
 				createdAt
 				updatedAt
 				team {
@@ -329,6 +330,10 @@ function mapIssueToProviderIssue(wi) {
         body: wi.description ?? "",
         createdAt: wi.createdAt ?? "",
         updatedAt: wi.updatedAt ?? "",
+        // Linear sends 0 for "No priority"; normalise it (and any missing
+        // value) to null so the dashboard treats it the same as GitHub's
+        // no-priority rows.
+        priority: wi.priority && wi.priority > 0 ? wi.priority : null,
     };
 }
 export class LinearProvider {

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

@@ -26,6 +26,7 @@ export type ProviderIssue = {
     body: string;
     createdAt: string;
     updatedAt: string;
+    priority: number | null;
 };
 /**
  * The issue's membership on a project board (GitHub Projects v2 / Linear

package/dist/lib/update.d.ts

@@ -0,0 +1,16 @@
+export declare const PACKAGE_NAME = "mintree";
+export type UpdateResult = {
+    ok: true;
+    output: string;
+} | {
+    ok: false;
+    message: string;
+    hint?: string;
+};
+/**
+ * Reinstalls `mintree@latest` globally via npm. Returns a discriminated result
+ * so the command can render a precise message instead of dumping a raw stack.
+ * The common failure — EACCES on a root-owned global prefix — gets a targeted
+ * hint pointing at the usual fixes.
+ */
+export declare function installLatest(): Promise<UpdateResult>;

package/dist/lib/update.js

@@ -0,0 +1,43 @@
+// Self-update: reinstall the globally-installed mintree from npm. The CLI is
+// distributed via `npm i -g mintree`, so updating is just re-running that
+// install for the `@latest` tag. We shell out to `npm` rather than reuse the
+// registry probe in version.ts because npm owns the global prefix, perms, and
+// bin-linking we can't replicate reliably here.
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+// npm global installs can be slow on a cold cache; give them room before we
+// give up. 2 minutes mirrors what a fresh `npm i -g` typically needs.
+const INSTALL_TIMEOUT_MS = 120_000;
+export const PACKAGE_NAME = "mintree";
+/**
+ * Reinstalls `mintree@latest` globally via npm. Returns a discriminated result
+ * so the command can render a precise message instead of dumping a raw stack.
+ * The common failure — EACCES on a root-owned global prefix — gets a targeted
+ * hint pointing at the usual fixes.
+ */
+export async function installLatest() {
+    try {
+        const { stdout, stderr } = await execAsync(`npm install -g ${PACKAGE_NAME}@latest`, {
+            timeout: INSTALL_TIMEOUT_MS,
+        });
+        return { ok: true, output: (stdout || stderr || "").trim() };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, message, hint: hintForError(message) };
+    }
+}
+function hintForError(message) {
+    const m = message.toLowerCase();
+    if (m.includes("eacces") || m.includes("permission denied")) {
+        return "npm couldn't write to its global prefix. Either fix the prefix ownership (npm docs: 'resolving EACCES permissions errors') or re-run with sudo.";
+    }
+    if (m.includes("command not found") || m.includes("not recognized")) {
+        return "npm wasn't found on your PATH. Install Node.js (which bundles npm) and try again.";
+    }
+    if (m.includes("etimedout") || m.includes("network") || m.includes("enotfound")) {
+        return "Looks like a network problem reaching the npm registry. Check your connection and retry.";
+    }
+    return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mintree",
-	"version": "0.4.1",
+	"version": "0.4.3",
 	"description": "Issue-driven git worktrees + Claude Code sessions for repos with an opinionated SDD+TDD flow.",
 	"license": "MIT",
 	"author": "Martin Mineo <mmineo@canarytechnologies.com>",