parawatch 0.1.0 → 0.2.0

package/dist/core/desktop.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { parsePrRef } from "./github.js";
 import { sessionTitle, UserError } from "./ops.js";
 /**
  * Where the Claude desktop app keeps its Code sessions: one JSON file per session, named
@@ -60,10 +61,33 @@ export function findDesktopSession(cliSession, dir = desktopSessionsDir()) {
 export function desktopSessionUrl(s) {
     return `claude://code/continue?session=${encodeURIComponent(s.id)}&source=parawatch`;
 }
-/** Where `goto` leads for a card id or a session id (prefix). */
+/** The session that owns a pull request: by URL, `owner/repo#N`, or `#N` / `repo#N` when only one matches. */
+function prSession(target, state) {
+    const ref = parsePrRef(target);
+    if (ref) {
+        const link = state.prLinks.get(ref.key);
+        if (!link)
+            throw new UserError(`no session owns ${ref.repo}#${ref.number}; link it from that session with: parawatch pr link ${ref.url}`);
+        if (!link.session)
+            throw new UserError(`${ref.repo}#${ref.number} is linked to a project but not to a session`);
+        return link.session;
+    }
+    const m = /^(?:([^/\s#]+))?#(\d+)$/.exec(target.trim());
+    if (!m)
+        return undefined;
+    const hits = [...state.prLinks.values()].filter((l) => l.pr.number === Number(m[2]) && (!m[1] || l.pr.repo.split("/")[1] === m[1]));
+    if (!hits.length)
+        throw new UserError(`no session owns a pull request ${target}`);
+    if (hits.length > 1)
+        throw new UserError(`${target} matches ${hits.map((h) => h.pr.repo + "#" + h.pr.number).join(", ")}; give owner/repo#N`);
+    if (!hits[0].session)
+        throw new UserError(`${target} is linked to a project but not to a session`);
+    return hits[0].session;
+}
+/** Where `goto` leads for a card id, a pull request, or a session id (prefix). */
 export function resolveGoto(target, state) {
     const card = state.cards.get(target);
-    const session = card ? card.session : target;
+    const session = card ? card.session : (prSession(target, state) ?? target);
     if (!session) {
         throw new UserError(`card ${target} does not say which session opened it (set one with: parawatch edit ${target} --session <id>)`);
     }

package/dist/core/digest.js

@@ -0,0 +1,146 @@
+/**
+ * What each session did on one day, from the event log and the agent logs: the work it claimed,
+ * cards it opened and what came of them, jobs it declared, news on its pull requests, and how it
+ * said it ended.
+ */
+import { collectRuns } from "./runs.js";
+import { fold } from "./state.js";
+import { readEvents } from "./store.js";
+import { prChangeText } from "./format.js";
+/** Local midnight to local midnight. */
+export function dayRange(date) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(date))
+        throw new Error(`"${date}" is not a date (use YYYY-MM-DD)`);
+    const start = new Date(`${date}T00:00:00`).getTime();
+    const end = new Date(start);
+    end.setDate(end.getDate() + 1);
+    return [start, end.getTime()];
+}
+export function localDate(t = Date.now()) {
+    const d = new Date(t);
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+export function digest(date, now = Date.now()) {
+    const [from, to] = dayRange(date);
+    const events = readEvents();
+    const state = fold(events);
+    const inDay = (e) => {
+        const t = Date.parse(e.ts);
+        return t >= from && t < to;
+    };
+    const sessions = new Map();
+    const sessionKey = (id) => {
+        if (!id)
+            return "";
+        const c = state.claims.find((x) => id.startsWith(x.session) || x.session.startsWith(id));
+        return c?.session ?? id;
+    };
+    const get = (id) => {
+        const k = sessionKey(id);
+        let s = sessions.get(k);
+        if (!s) {
+            const c = state.claims.find((x) => x.session === k);
+            s = { session: k, title: c?.title ?? (k ? k.slice(0, 8) : "no session"), project: c?.project, task: c?.task, cards: [], runs: [], prs: [] };
+            sessions.set(k, s);
+        }
+        return s;
+    };
+    // agent logs: what was active that day
+    const sinceHours = Math.max(1, Math.ceil((now - from) / 3_600_000));
+    const observed = collectRuns(state, { sinceHours, includeEnded: true, keepRepeats: true }, now).filter((r) => r.kind === "session" && r.lastActivity && Date.parse(r.lastActivity) >= from && (!r.startedAt || Date.parse(r.startedAt) < to));
+    for (const r of observed) {
+        const s = get(r.id);
+        s.title = r.title;
+        s.project ??= r.project;
+        s.task ??= r.task;
+        s.recap = r.recap;
+        s.lastActivity = r.lastActivity;
+    }
+    for (const e of events) {
+        if (!inDay(e))
+            continue;
+        switch (e.type) {
+            case "run.claim": {
+                const s = get(e.claim.session);
+                s.project = e.claim.project;
+                s.task = e.claim.task ?? s.task;
+                if (e.claim.title)
+                    s.title = e.claim.title;
+                if (e.claim.done)
+                    s.done = e.claim.done;
+                break;
+            }
+            case "card.open":
+            case "card.answer":
+            case "card.close": {
+                const id = e.type === "card.open" ? e.card.id : e.card;
+                const card = state.cards.get(id);
+                if (!card)
+                    break;
+                const s = get(card.session);
+                s.project ??= card.project;
+                let row = s.cards.find((c) => c.id === id);
+                if (!row)
+                    s.cards.push((row = { id, title: card.title, events: [] }));
+                if (e.type === "card.open")
+                    row.events.push("opened");
+                else if (e.type === "card.answer") {
+                    const choice = e.choice !== undefined ? card.options?.[e.choice - 1] : undefined;
+                    row.events.push(`answered${choice ? `: ${choice}` : e.comment ? `: ${e.comment}` : ""}`);
+                }
+                else
+                    row.events.push(`closed${e.note ? `: ${e.note}` : ""}`);
+                break;
+            }
+            case "run.start":
+            case "run.end": {
+                const id = e.type === "run.start" ? e.run.id : e.run;
+                const run = state.runs.get(id);
+                if (!run)
+                    break;
+                const s = get(run.parent);
+                s.project ??= run.project;
+                if (!s.runs.some((x) => x.id === id))
+                    s.runs.push({ id, title: run.title, status: run.status, note: run.note });
+                break;
+            }
+            case "pr.change": {
+                const link = state.prLinks.get(e.pr.key);
+                const s = get(link?.session);
+                s.project ??= link?.project;
+                let row = s.prs.find((p) => p.key === e.pr.key);
+                if (!row)
+                    s.prs.push((row = { key: e.pr.key, url: e.pr.url, title: e.title, changes: [] }));
+                row.changes.push(prChangeText(e.change, e.by) + (e.text ? `: ${e.text}` : ""));
+                break;
+            }
+        }
+    }
+    const list = [...sessions.values()].filter((s) => s.session || s.cards.length || s.runs.length || s.prs.length);
+    list.sort((a, b) => (a.project ?? "~").localeCompare(b.project ?? "~") || (a.lastActivity ?? "").localeCompare(b.lastActivity ?? ""));
+    return { date, sessions: list };
+}
+export function digestText(d) {
+    const out = [d.date];
+    if (!d.sessions.length)
+        return `${d.date}\nNothing recorded.`;
+    let project = null;
+    for (const s of d.sessions) {
+        if (s.project !== project) {
+            project = s.project;
+            out.push("", project ?? "other");
+        }
+        out.push(`  ${s.task ? `${s.task} · ` : ""}${s.title}`);
+        const end = s.done ? `done: ${s.done}` : s.recap ? `last: ${s.recap}` : undefined;
+        if (end)
+            out.push(`    ${end}`);
+        for (const c of s.cards)
+            out.push(`    card ${c.id} "${c.title}": ${c.events.join(", ")}`);
+        for (const r of s.runs)
+            out.push(`    job ${r.id} "${r.title}": ${r.status}${r.note ? ` (${r.note})` : ""}`);
+        for (const p of s.prs)
+            out.push(`    PR ${p.key.replace(/^[^/]+\//, "")}${p.title ? ` "${p.title}"` : ""}: ${p.changes.join(", ")}`);
+    }
+    return out.join("\n");
+}
+//# sourceMappingURL=digest.js.map

package/dist/core/format.js

@@ -86,10 +86,10 @@ export function cardStart(c) {
     return c.since && c.since < c.openedAt ? c.since : c.openedAt;
 }
 /** Cards as aligned rows: id, kind, project, title, age. */
-export function cardRows(cards, v = PLAIN, now = Date.now(), indent = "") {
+export function cardRows(cards, v = PLAIN, now = Date.now(), indent = "", extra = {}) {
     const idW = Math.max(3, ...cards.map((c) => c.id.length));
     const projW = Math.min(16, Math.max(0, ...cards.map((c) => textWidth(c.project + (c.task ? `/${c.task}` : "")))));
-    const noteOf = (c) => (c.status === "answered" ? " · answered" : c.status === "closed" ? " · closed" : "");
+    const noteOf = (c) => (c.status === "answered" ? " · answered" : c.status === "closed" ? " · closed" : "") + (extra[c.id] ? ` · ${extra[c.id]}` : "");
     const fixed = textWidth(indent) + idW + 2 + 7 + 2 + projW + 2 + 2 + 4;
     const titleW = Math.min(v.width - fixed, Math.max(0, ...cards.map((c) => textWidth(c.title + noteOf(c)))));
     return cards.map((c) => {
@@ -125,6 +125,10 @@ export function cardDetail(c) {
         out.push("");
         c.options.forEach((o, i) => out.push(`  ${i + 1}. ${o}${c.recommend === i + 1 ? "  (recommended)" : ""}`));
     }
+    if (c.action)
+        out.push("", `Runs on yes: ${c.action}`);
+    if (c.preview)
+        out.push("", "Preview:", ...c.preview.split("\n").map((l) => `  ${l}`));
     if (c.look)
         out.push("", `Look at: ${c.look}`);
     for (const o of c.open ?? [])
@@ -146,8 +150,31 @@ export function cardDetail(c) {
         out.push("", `Closed: ${c.closeNote}`);
     return out.join("\n");
 }
+const PR_WORDS = {
+    review: "new review",
+    approved: "approved",
+    changes_requested: "changes requested",
+    commented: "new comment",
+    ci_failed: "CI failed",
+    ci_passed: "CI passed",
+    queued: "entered the merge queue",
+    queue_removed: "left the merge queue without merging",
+    conflict: "has a merge conflict",
+    merged: "merged",
+    closed: "closed without merging",
+    note: "note",
+};
+export function prChangeText(change, by) {
+    const w = PR_WORDS[change] ?? change;
+    return by && by !== "github" && by !== "external" ? `${w} by ${by}` : w;
+}
 export function inboxLine(i) {
-    const head = `[${i.card.project}] ${i.card.id} "${i.card.title}"`;
+    if (i.kind === "pr" && i.pr) {
+        const p = i.pr;
+        return `[${p.project ?? "?"}] PR ${p.ref.repo}#${p.ref.number}${p.title ? ` "${p.title}"` : ""}: ${prChangeText(p.change, i.by)}${p.text ? `; ${p.text}` : ""} (${p.ref.url})`;
+    }
+    const card = i.card;
+    const head = `[${card.project}] ${card.id} "${card.title}"`;
     if (i.kind === "comment")
         return `${head} comment: ${i.comment}`;
     const parts = [];
@@ -178,17 +205,77 @@ const STATE_PAINT = {
     unknown: ["dim"],
 };
 const ENDED = new Set(["done", "idle"]);
+// ------------------------------------------------------------------ pull requests
+function prLabel(p) {
+    return `${p.repo.split("/")[1]}#${p.number}`;
+}
+/** Open pull requests: what each waits on, for how long, and the session that owns it. */
+export function prRows(prs, v = PLAIN, now = Date.now(), indent = "") {
+    const idW = Math.max(4, ...prs.map((p) => textWidth(prLabel(p))));
+    const waitW = Math.min(30, Math.max(6, ...prs.map((p) => textWidth(waitText(p)))));
+    const ownW = Math.min(24, Math.max(0, ...prs.map((p) => textWidth(ownerText(p)))));
+    const fixed = textWidth(indent) + idW + 2 + waitW + 2 + 4 + 2 + (ownW ? ownW + 2 : 0);
+    const titleW = Math.max(8, v.width - fixed);
+    return prs.map((p) => {
+        const age = ago(p.since, now).padStart(4);
+        return [
+            indent,
+            paint(v, pad(prLabel(p), idW), "bold"),
+            "  ",
+            paint(v, pad(fit(waitText(p), waitW), waitW), ...(p.stalled ? ["red"] : ["yellow"])),
+            "  ",
+            paint(v, age, ...(p.stalled ? ["red"] : ["dim"])),
+            "  ",
+            ownW ? paint(v, pad(fit(ownerText(p), ownW), ownW), "dim") + "  " : "",
+            fit(p.title, titleW),
+        ].join("").trimEnd();
+    });
+}
+export function waitText(p) {
+    if (p.reviewRequested && !p.mine)
+        return `${p.stalled ? "long " : ""}waiting for your review`;
+    const who = p.who?.length && p.waitingOn === "review" ? ` (${p.who.join(", ")})` : "";
+    return `${p.stalled ? "stuck in " : ""}${p.waitingOn}${who}`;
+}
+function ownerText(p) {
+    return p.sessionTitle ?? (p.project ? p.project + (p.task ? `/${p.task}` : "") : "");
+}
+/** Sessions that asked the human something in chat instead of on a card. */
+export function askRows(runs, v = PLAIN, now = Date.now(), indent = "") {
+    const asking = runs.filter((r) => r.asks);
+    const nameW = Math.min(32, Math.max(8, ...asking.map((r) => textWidth(r.title))));
+    return asking.map((r) => {
+        const age = ago(r.asks.at ?? r.lastActivity, now).padStart(4);
+        const room = Math.max(8, v.width - textWidth(indent) - nameW - 2 - 4 - 2 - 10);
+        const where = r.project ? `${r.project}` : "other";
+        return [
+            indent,
+            paint(v, pad(fit(r.title, nameW), nameW), "bold"),
+            "  ",
+            paint(v, age, "dim"),
+            "  ",
+            paint(v, fit(clean(r.asks.text), room), ...(r.asks.blocked ? ["red"] : ["yellow"])),
+            "  ",
+            paint(v, `(${where})`, "dim"),
+        ].join("");
+    });
+}
 /** Finished subagents older than this fold into one "N finished" line. */
 const FOLD_AFTER_MS = 5 * 60_000;
 export const OTHER = "other";
 function whatText(r) {
     if (r.error)
         return `unreadable: ${r.error}`;
-    const a = clean(r.action ?? "");
+    if (r.done)
+        return `done · ${clean(r.done)}`;
+    if (r.asks)
+        return `${r.asks.blocked ? "blocked" : "asks"}: ${clean(r.asks.text)}`;
+    const a = clean((r.state === "idle" && r.recap) || r.action || "");
     if (r.state === "stalled")
         return a ? `stalled · ${a}` : "stalled";
     return a;
 }
+const SOURCE_NOTE = { edits: "~edits", prompt: "~prompt" };
 /** Runs grouped by project, children drawn as a tree under their parent, one terminal line each. */
 export function runsTree(runs, v = PLAIN, now = Date.now(), indent = "") {
     const groups = new Map();
@@ -248,11 +335,14 @@ export function runsTree(runs, v = PLAIN, now = Date.now(), indent = "") {
             const ended = ENDED.has(r.state);
             const titlePaint = r.role === "lead" ? ["bold"] : ended ? ["dim"] : [];
             const mark = paint(v, STATE_MARK[r.state], ...STATE_PAINT[r.state]);
-            const title = paint(v, pad(fit(r.title, room), room), ...titlePaint);
+            const label = r.title + (r.repeats ? ` ×${r.repeats + 1}` : "") + (r.prs?.length ? ` (${r.prs.length} PR)` : "");
+            const title = paint(v, pad(fit(label, room), room), ...titlePaint);
             const age = paint(v, ago(r.lastActivity, now).padStart(4), "dim");
-            const wide = v.wide ? "  " + paint(v, pad(`${r.kind === "subagent" ? r.model ?? "subagent" : r.runtime} ${r.id.slice(0, 8)}`, wideW - 2), "dim") : "";
+            const src = (r.projectSource && SOURCE_NOTE[r.projectSource]) || "";
+            const wide = v.wide ? "  " + paint(v, pad(fit(`${r.kind === "subagent" ? r.model ?? "subagent" : r.runtime} ${r.id.slice(0, 8)}${src ? " " + src : ""}`, wideW - 2), wideW - 2), "dim") : "";
             const restW = v.width - nameW - 2 - 4 - wideW - 2;
-            const what = restW >= 8 ? "  " + paint(v, fit(whatText(r), restW), ...(r.error || r.state === "stalled" || r.state === "failed" ? ["red"] : ended ? ["dim"] : [])) : "";
+            const whatPaint = r.error || r.state === "stalled" || r.state === "failed" || r.asks?.blocked ? ["red"] : r.asks ? ["yellow"] : ended ? ["dim"] : [];
+            const what = restW >= 8 ? "  " + paint(v, fit(whatText(r), restW), ...whatPaint) : "";
             out.push(`${lead}${mark} ${title}  ${age}${wide}${what}`.trimEnd());
         }
     }