@armanckeser/downstream 0.0.0-stage → 0.1.0

package/dist/server/analyze/ts-project.js

@@ -0,0 +1,212 @@
+// A TypeScript language service over one side of the change. Used for call
+// resolution, "who calls this", and IDE-grade hover in the review surface.
+import ts from "typescript";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { WORKTREE } from "./git.js";
+import { extractDecls, isTsLike } from "./ts-decls.js";
+const DEFAULTS = {
+    allowJs: true,
+    checkJs: false,
+    jsx: ts.JsxEmit.Preserve,
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    allowImportingTsExtensions: true,
+    resolveJsonModule: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    noEmit: true,
+    strict: false,
+};
+const MAX_PROJECT_FILES = 4000;
+/** Disk outside the reviewed side (lib, node_modules) doesn't change during a review; probe it once. */
+const fsCache = {
+    files: new Map(),
+    dirs: new Map(),
+    subdirs: new Map(),
+    real: new Map(),
+    text: new Map(),
+};
+function memo(m, k, f) {
+    if (m.has(k))
+        return m.get(k);
+    const v = f();
+    m.set(k, v);
+    return v;
+}
+export function clearFsCache() {
+    for (const m of Object.values(fsCache))
+        m.clear();
+}
+export class TsProject {
+    service;
+    declCache = new Map();
+    files;
+    root;
+    source;
+    constructor(root, source, rootFiles, configPath, registry = ts.createDocumentRegistry()) {
+        this.root = root;
+        this.source = source;
+        let options = DEFAULTS;
+        let names = rootFiles.map((f) => this.abs(f));
+        if (configPath) {
+            const parsed = parseConfig(configPath, (p) => this.readAbs(p));
+            if (parsed) {
+                options = { ...DEFAULTS, ...parsed.options, noEmit: true, allowJs: true };
+                if (parsed.fileNames.length > 0 && parsed.fileNames.length <= MAX_PROJECT_FILES) {
+                    names = [...new Set([...parsed.fileNames.map((f) => path.normalize(f)), ...names])];
+                }
+            }
+        }
+        this.files = names;
+        const host = {
+            getScriptFileNames: () => this.files,
+            getScriptVersion: () => "1",
+            getScriptSnapshot: (f) => {
+                const text = this.readAbs(f);
+                return text === undefined ? undefined : ts.ScriptSnapshot.fromString(text);
+            },
+            getCurrentDirectory: () => root,
+            getCompilationSettings: () => options,
+            getDefaultLibFileName: (o) => ts.getDefaultLibFilePath(o),
+            fileExists: (f) => this.fileExists(f),
+            readFile: (f) => this.readAbs(f),
+            readDirectory: ts.sys.readDirectory,
+            directoryExists: (d) => memo(fsCache.dirs, d, () => ts.sys.directoryExists(d)),
+            getDirectories: (d) => memo(fsCache.subdirs, d, () => ts.sys.getDirectories(d)),
+            realpath: (f) => memo(fsCache.real, f, () => ts.sys.realpath?.(f) ?? f),
+            useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames,
+        };
+        this.service = ts.createLanguageService(host, registry);
+    }
+    abs(rel) {
+        return path.normalize(path.join(this.root, rel));
+    }
+    rel(abs) {
+        const r = path.relative(this.root, path.normalize(abs)).split(path.sep).join("/");
+        if (r.startsWith("..") || path.isAbsolute(r) || r.includes("node_modules/"))
+            return null;
+        return r;
+    }
+    /** Repo files come from the reviewed side; everything else (lib, node_modules) from disk. */
+    fileExists(abs) {
+        const rel = this.rel(abs);
+        if (rel !== null && this.source.label !== WORKTREE)
+            return this.source.exists(rel) || memo(fsCache.files, abs, () => ts.sys.fileExists(abs));
+        return memo(fsCache.files, abs, () => ts.sys.fileExists(abs));
+    }
+    readAbs(abs) {
+        const rel = this.rel(abs);
+        if (rel !== null && this.source.label !== WORKTREE) {
+            const text = this.source.read(rel);
+            if (text !== null)
+                return text;
+        }
+        const load = () => {
+            try {
+                return existsSync(abs) ? readFileSync(abs, "utf8") : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        };
+        // Repo files in the working tree can change mid-review (fixes); only cache the rest.
+        return rel === null ? memo(fsCache.text, abs, load) : load();
+    }
+    program() {
+        return this.service.getProgram();
+    }
+    sourceFile(rel) {
+        return this.program().getSourceFile(this.abs(rel));
+    }
+    /** Declarations for a repo file, extracted from the program's own AST so checker lookups line up. */
+    declsFor(rel) {
+        const hit = this.declCache.get(rel);
+        if (hit)
+            return hit;
+        const sf = this.sourceFile(rel);
+        if (!sf)
+            return null;
+        const entry = { sf, decls: extractDecls(sf) };
+        this.declCache.set(rel, entry);
+        return entry;
+    }
+    position(rel, line, col) {
+        const sf = this.sourceFile(rel);
+        if (!sf)
+            return null;
+        const lineCount = sf.getLineStarts().length;
+        if (line < 1 || line > lineCount)
+            return null;
+        const start = sf.getLineStarts()[line - 1];
+        const lineEnd = line < lineCount ? sf.getLineStarts()[line] - 1 : sf.text.length;
+        return Math.min(start + col, lineEnd);
+    }
+}
+function parseConfig(configPath, read) {
+    const raw = ts.readConfigFile(configPath, (p) => read(p));
+    if (raw.error)
+        return null;
+    return ts.parseJsonConfigFileContent(raw.config, ts.sys, path.dirname(configPath), undefined, configPath);
+}
+/** The tsconfig that actually includes a file: walk up, try the common names, honor `references`. */
+export function findConfig(root, rel) {
+    const absFile = path.normalize(path.join(root, rel));
+    let dir = path.dirname(absFile);
+    const rootNorm = path.normalize(root);
+    while (dir.startsWith(rootNorm)) {
+        for (const name of ["tsconfig.json", "tsconfig.app.json", "jsconfig.json"]) {
+            const candidate = path.join(dir, name);
+            if (!existsSync(candidate))
+                continue;
+            const parsed = parseConfig(candidate, (p) => (existsSync(p) ? readFileSync(p, "utf8") : undefined));
+            if (!parsed)
+                continue;
+            if (parsed.fileNames.some((f) => path.normalize(f) === absFile))
+                return candidate;
+            for (const ref of parsed.projectReferences ?? []) {
+                const refPath = ref.path.endsWith(".json") ? ref.path : path.join(ref.path, "tsconfig.json");
+                const sub = parseConfig(refPath, (p) => (existsSync(p) ? readFileSync(p, "utf8") : undefined));
+                if (sub?.fileNames.some((f) => path.normalize(f) === absFile))
+                    return refPath;
+            }
+        }
+        const up = path.dirname(dir);
+        if (up === dir)
+            break;
+        dir = up;
+    }
+    return null;
+}
+/** One project per tsconfig, so monorepos resolve each package with its own settings. */
+export class TsProjects {
+    byConfig = new Map();
+    configOf = new Map();
+    /** Shared so packages in one repo parse node_modules types once. */
+    registry = ts.createDocumentRegistry();
+    root;
+    source;
+    seedFiles;
+    constructor(root, source, seedFiles) {
+        this.root = root;
+        this.source = source;
+        this.seedFiles = seedFiles;
+    }
+    for(rel) {
+        if (!isTsLike(rel))
+            return null;
+        let key = this.configOf.get(rel);
+        if (!key) {
+            key = findConfig(this.root, rel) ?? "<none>";
+            this.configOf.set(rel, key);
+        }
+        let project = this.byConfig.get(key);
+        if (!project) {
+            const seeds = this.seedFiles.filter((f) => isTsLike(f) && this.source.exists(f));
+            project = new TsProject(this.root, this.source, seeds.length ? seeds : [rel], key === "<none>" ? null : key, this.registry);
+            this.byConfig.set(key, project);
+        }
+        return project;
+    }
+}

package/dist/server/gh.js

@@ -0,0 +1,51 @@
+// Every GitHub CLI call goes through here, so each one runs as the account it
+// belongs to. People with a work and a personal account have both logged in to
+// gh; the active one flips, so nothing may rely on it.
+import { execFileSync, execFile } from "node:child_process";
+import { tmpdir } from "node:os";
+import { promisify } from "node:util";
+/**
+ * Always from a neutral directory, with the repository passed as `--repo`:
+ * directory-aware gh wrappers pick an account from the working directory and
+ * would override the token we set.
+ */
+const NEUTRAL = tmpdir();
+const run = promisify(execFile);
+const tokens = new Map();
+/** `gh auth token --user <login>`: the account's own token, whichever account is active. */
+export function tokenFor(account) {
+    let token = tokens.get(account);
+    if (!token) {
+        token = execFileSync("gh", ["auth", "token", "--user", account], { cwd: NEUTRAL, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+        tokens.set(account, token);
+    }
+    return token;
+}
+export function ghEnv(account) {
+    return account ? { ...process.env, GH_TOKEN: tokenFor(account) } : process.env;
+}
+export function gh(args, opts = {}) {
+    return execFileSync("gh", args, {
+        cwd: NEUTRAL,
+        env: ghEnv(opts.account ?? null),
+        input: opts.input,
+        encoding: "utf8",
+        stdio: [opts.input === undefined ? "ignore" : "pipe", "pipe", "pipe"],
+        maxBuffer: 64 * 1024 * 1024,
+    });
+}
+export async function ghAsync(args, opts = {}) {
+    const { stdout } = await run("gh", args, { cwd: NEUTRAL, env: ghEnv(opts.account ?? null), encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+    return stdout;
+}
+/** The github.com accounts gh is logged in to, active one first. */
+export function accounts() {
+    try {
+        const out = JSON.parse(gh(["auth", "status", "--json", "hosts"]));
+        const list = (out.hosts["github.com"] ?? []).filter((a) => a.state === "success");
+        return [...list].sort((a, b) => Number(b.active) - Number(a.active)).map((a) => a.login);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/server/github.js

@@ -0,0 +1,264 @@
+// The open pull requests an account is part of, read from GitHub in one round
+// of searches and reduced to PrFacts, plus what the account itself has been
+// doing lately (its event feed), which is the best read of what it's focused on.
+import { z } from "zod";
+import { PrFacts } from "../domain/inbox.js";
+import { ghAsync } from "./gh.js";
+const PR_FIELDS = `
+  number title url updatedAt isDraft
+  repository { nameWithOwner }
+  baseRefName headRefName headRefOid
+  reviewDecision mergeable
+  author { __typename login avatarUrl(size: 48) ... on User { name } }
+  stack { number size }
+  stackEntry { position }
+  commits(last: 1) { nodes { commit { statusCheckRollup { state } } } }
+  reviewThreads(first: 100) { nodes { isResolved } }
+  latestReviews(first: 30) { nodes { author { login } state submittedAt } }
+  timelineItems(last: 40, itemTypes: [PULL_REQUEST_COMMIT, HEAD_REF_FORCE_PUSHED_EVENT, ISSUE_COMMENT, PULL_REQUEST_REVIEW]) { nodes {
+    __typename
+    ... on PullRequestCommit { commit { committedDate } }
+    ... on HeadRefForcePushedEvent { createdAt actor { login } }
+    ... on IssueComment { createdAt author { login } }
+    ... on PullRequestReview { submittedAt state author { login } }
+  } }
+`;
+const QUERY = `query($q: String!) { search(query: $q, type: ISSUE, first: 100) { nodes { ... on PullRequest { ${PR_FIELDS} } } } }`;
+/**
+ * Direct review requests only (`user-review-requested`): team and CODEOWNERS
+ * requests are mostly noise, and an action list is only useful while it's short.
+ * `reviewed-by` catches PRs you reviewed that changed since.
+ */
+const SEARCHES = [
+    { q: "is:pr is:open archived:false user-review-requested:@me", requested: true },
+    { q: "is:pr is:open archived:false reviewed-by:@me -author:@me", requested: false },
+    { q: "is:pr is:open archived:false author:@me", requested: false },
+];
+const Login = z.object({ login: z.string() });
+const TimelineItem = z.discriminatedUnion("__typename", [
+    z.object({ __typename: z.literal("PullRequestCommit"), commit: z.object({ committedDate: z.string() }) }),
+    z.object({ __typename: z.literal("HeadRefForcePushedEvent"), createdAt: z.string(), actor: Login.nullable() }),
+    z.object({ __typename: z.literal("IssueComment"), createdAt: z.string(), author: Login.nullable() }),
+    z.object({ __typename: z.literal("PullRequestReview"), submittedAt: z.string().nullable(), state: z.string(), author: Login.nullable() }),
+]);
+const Node = z.object({
+    number: z.number(),
+    title: z.string(),
+    url: z.string(),
+    updatedAt: z.string(),
+    isDraft: z.boolean(),
+    repository: z.object({ nameWithOwner: z.string() }),
+    baseRefName: z.string(),
+    headRefName: z.string(),
+    headRefOid: z.string(),
+    reviewDecision: z.enum(["APPROVED", "CHANGES_REQUESTED", "REVIEW_REQUIRED"]).nullable(),
+    mergeable: z.enum(["MERGEABLE", "CONFLICTING", "UNKNOWN"]),
+    author: z.object({ __typename: z.string(), login: z.string(), avatarUrl: z.string(), name: z.string().nullable().optional() }).nullable(),
+    stack: z.object({ number: z.number(), size: z.number() }).nullable().optional(),
+    stackEntry: z.object({ position: z.number() }).nullable().optional(),
+    commits: z.object({ nodes: z.array(z.object({ commit: z.object({ statusCheckRollup: z.object({ state: z.string() }).nullable() }) })) }),
+    reviewThreads: z.object({ nodes: z.array(z.object({ isResolved: z.boolean() })) }),
+    latestReviews: z.object({ nodes: z.array(z.object({ author: Login.nullable(), state: z.string(), submittedAt: z.string().nullable() })) }),
+    timelineItems: z.object({ nodes: z.array(TimelineItem) }),
+});
+const Response = z.object({ data: z.object({ search: z.object({ nodes: z.array(z.unknown()) }) }) });
+const CHECKS = { SUCCESS: "passing", FAILURE: "failing", ERROR: "failing", PENDING: "pending", EXPECTED: "pending" };
+const MERGEABLE = { MERGEABLE: "mergeable", CONFLICTING: "conflicting", UNKNOWN: "unknown" };
+const DECISION = { APPROVED: "approved", CHANGES_REQUESTED: "changes_requested", REVIEW_REQUIRED: "review_required" };
+function toFacts(node, account, requested) {
+    const me = account.toLowerCase();
+    const myReviewAt = lastReviewBy(node, me);
+    const rollup = node.commits.nodes[0]?.commit.statusCheckRollup?.state ?? null;
+    return PrFacts.parse({
+        repo: node.repository.nameWithOwner,
+        number: node.number,
+        title: node.title,
+        url: node.url,
+        author: node.author?.login ?? "ghost",
+        authorKind: node.author?.__typename === "Bot" ? "bot" : "person",
+        authorName: node.author?.name || null,
+        authorAvatar: node.author?.avatarUrl ?? null,
+        touched: null,
+        isDraft: node.isDraft,
+        updatedAt: node.updatedAt,
+        baseRef: node.baseRefName,
+        headRef: node.headRefName,
+        headSha: node.headRefOid,
+        reviewDecision: node.reviewDecision ? DECISION[node.reviewDecision] : null,
+        checks: rollup ? (CHECKS[rollup] ?? "pending") : "none",
+        mergeable: MERGEABLE[node.mergeable],
+        unresolvedThreads: node.reviewThreads.nodes.filter((t) => !t.isResolved).length,
+        role: node.author?.login.toLowerCase() === me ? "author" : "reviewer",
+        reviewRequested: requested,
+        myReviewAt,
+        authorSince: myReviewAt ? authorActAfter(node, myReviewAt) : null,
+        stack: node.stack && node.stackEntry ? { number: node.stack.number, size: node.stack.size, position: node.stackEntry.position } : null,
+    });
+}
+/**
+ * When `me` last reviewed. `latestReviews` drops dismissed reviews, and repos
+ * that dismiss stale approvals on push would make a reviewed PR look unread, so
+ * the timeline's reviews count too.
+ */
+function lastReviewBy(node, me) {
+    const latest = node.latestReviews.nodes.filter((r) => r.author?.login.toLowerCase() === me && r.state !== "PENDING").map((r) => r.submittedAt);
+    const timeline = node.timelineItems.nodes.map((item) => item.__typename === "PullRequestReview" && item.author?.login.toLowerCase() === me && item.state !== "PENDING" ? item.submittedAt : null);
+    return [...latest, ...timeline].filter((at) => at !== null).sort().at(-1) ?? null;
+}
+const isAuthor = (node, who) => !!who && who.login === node.author?.login;
+/**
+ * The author's latest push or reply after `after`. A force-push event carries
+ * the push time; a plain push only shows as commits, whose committed date is the
+ * best GraphQL offers, so a commit made before your review and pushed after it
+ * is missed.
+ */
+function authorActAfter(node, after) {
+    const acts = node.timelineItems.nodes.flatMap((item) => {
+        switch (item.__typename) {
+            case "PullRequestCommit":
+                return [{ how: "pushed", at: item.commit.committedDate }];
+            case "HeadRefForcePushedEvent":
+                return isAuthor(node, item.actor) ? [{ how: "pushed", at: item.createdAt }] : [];
+            case "IssueComment":
+                return isAuthor(node, item.author) ? [{ how: "replied", at: item.createdAt }] : [];
+            case "PullRequestReview":
+                return isAuthor(node, item.author) && item.submittedAt ? [{ how: "replied", at: item.submittedAt }] : [];
+        }
+    });
+    return acts.filter((a) => Date.parse(a.at) > Date.parse(after)).sort((a, b) => b.at.localeCompare(a.at))[0] ?? null;
+}
+export async function fetchPrs(account) {
+    const results = await Promise.all(SEARCHES.map(async ({ q, requested }) => {
+        const out = await once(() => ghAsync(["api", "graphql", "-f", `q=${q}`, "-f", `query=${QUERY}`], { account }));
+        return Response.parse(JSON.parse(out))
+            .data.search.nodes.filter((n) => n && typeof n === "object" && "number" in n)
+            .map((n) => toFacts(Node.parse(n), account, requested));
+    }));
+    return results.flat();
+}
+/** GitHub search fails now and then for no reason it reports; one more try clears nearly all of them. */
+async function once(run) {
+    try {
+        return await run();
+    }
+    catch {
+        return run();
+    }
+}
+const Event = z.object({
+    type: z.string(),
+    created_at: z.string(),
+    repo: z.object({ name: z.string() }),
+    payload: z.object({
+        ref: z.string().nullable().optional(),
+        pull_request: z.object({ number: z.number() }).optional(),
+        issue: z.object({ number: z.number(), pull_request: z.unknown().optional() }).optional(),
+    }),
+});
+const TOUCH_HOW = {
+    PullRequestReviewEvent: "reviewed",
+    PullRequestReviewCommentEvent: "commented",
+    IssueCommentEvent: "commented",
+    PullRequestEvent: "opened",
+    PushEvent: "pushed",
+};
+/** What the account did on GitHub in roughly the last week: up to 300 events, newest first. */
+export async function fetchTouches(account) {
+    const out = await once(() => ghAsync(["api", `/users/${account}/events?per_page=100`, "--paginate", "--slurp"], { account }));
+    const events = z.array(z.array(Event)).parse(JSON.parse(out)).flat();
+    const touches = events.flatMap((e) => {
+        const how = TOUCH_HOW[e.type];
+        if (!how)
+            return [];
+        const number = e.payload.pull_request?.number ?? (e.payload.issue?.pull_request ? e.payload.issue.number : undefined);
+        const branch = e.type === "PushEvent" ? e.payload.ref?.replace(/^refs\/heads\//, "") : undefined;
+        if (number === undefined && !branch)
+            return [];
+        return [{ repo: e.repo.name, number: number ?? null, branch: branch ?? null, at: e.created_at, how, author: null }];
+    });
+    return withAuthors(touches, account);
+}
+/** The event feed leaves out whose PR it was; one query fills that in, so "who you're working with" includes merged PRs. */
+async function withAuthors(touches, account) {
+    const prs = [...new Map(touches.filter((t) => t.number !== null).map((t) => [`${t.repo}#${t.number}`, t])).values()].slice(0, 60);
+    if (prs.length === 0)
+        return touches;
+    const fields = prs.map((t, i) => {
+        const [owner, name] = t.repo.split("/");
+        return `p${i}: repository(owner: ${JSON.stringify(owner)}, name: ${JSON.stringify(name)}) { pullRequest(number: ${t.number}) { author { login } } }`;
+    });
+    const out = await ghAsync(["api", "graphql", "-f", `query=query { ${fields.join("\n")} }`], { account }).catch(() => null);
+    if (!out)
+        return touches;
+    const data = JSON.parse(out).data ?? {};
+    const authors = new Map(prs.map((t, i) => [`${t.repo}#${t.number}`, data[`p${i}`]?.pullRequest?.author?.login ?? null]));
+    return touches.map((t) => (t.number === null ? t : { ...t, author: authors.get(`${t.repo}#${t.number}`) ?? null }));
+}
+/** The account's avatar, for the account menu. */
+export async function fetchAvatar(account) {
+    const out = await ghAsync(["api", "user", "--jq", ".avatar_url"], { account }).catch(() => "");
+    return out.trim() || null;
+}
+const PERSON = "login avatarUrl(size: 40) ... on User { name }";
+const DETAIL_QUERY = `query($owner: String!, $name: String!, $number: Int!) { repository(owner: $owner, name: $name) { pullRequest(number: $number) {
+  body additions deletions changedFiles createdAt
+  commitCount: commits { totalCount }
+  files(first: 100) { nodes { path additions deletions changeType } }
+  latestReviews(first: 30) { nodes { author { ${PERSON} } state } }
+  reviewRequests(first: 30) { nodes { requestedReviewer { __typename ... on User { login name avatarUrl(size: 40) } ... on Bot { login avatarUrl(size: 40) } ... on Team { name } } } }
+  lastCommit: commits(last: 1) { nodes { commit { statusCheckRollup { contexts(first: 100) { nodes { __typename ... on CheckRun { name conclusion status } ... on StatusContext { context state } } } } } } }
+} } }`;
+const Author = z.object({ login: z.string(), avatarUrl: z.string().optional(), name: z.string().nullable().optional() });
+const Detail = z.object({
+    body: z.string(),
+    additions: z.number(),
+    deletions: z.number(),
+    changedFiles: z.number(),
+    createdAt: z.string(),
+    commitCount: z.object({ totalCount: z.number() }),
+    files: z.object({ nodes: z.array(z.object({ path: z.string(), additions: z.number(), deletions: z.number(), changeType: z.string() })) }).nullable(),
+    latestReviews: z.object({ nodes: z.array(z.object({ author: Author.nullable(), state: z.string() })) }),
+    reviewRequests: z.object({ nodes: z.array(z.object({ requestedReviewer: z.object({ __typename: z.string(), login: z.string().optional(), name: z.string().nullable().optional(), avatarUrl: z.string().optional() }).nullable() })) }).nullable(),
+    lastCommit: z.object({ nodes: z.array(z.object({ commit: z.object({ statusCheckRollup: z.object({ contexts: z.object({ nodes: z.array(z.object({ __typename: z.string(), name: z.string().optional(), conclusion: z.string().nullable().optional(), status: z.string().optional(), context: z.string().optional(), state: z.string().optional() })) }) }).nullable() }) })) }),
+});
+const REVIEW_STATE = { APPROVED: "approved", CHANGES_REQUESTED: "changes_requested", COMMENTED: "commented", DISMISSED: "dismissed" };
+const CHANGE = { ADDED: "added", DELETED: "deleted", MODIFIED: "modified", RENAMED: "renamed", COPIED: "copied" };
+const FAILED = new Set(["FAILURE", "TIMED_OUT", "ACTION_REQUIRED", "STARTUP_FAILURE", "ERROR"]);
+const PASSED = new Set(["SUCCESS", "NEUTRAL"]);
+/** One PR in full, for the preview. */
+export async function fetchDetail(account, repo, number) {
+    const [owner, name] = repo.split("/");
+    const out = await once(() => ghAsync(["api", "graphql", "-F", `owner=${owner}`, "-F", `name=${name}`, "-F", `number=${number}`, "-f", `query=${DETAIL_QUERY}`], { account }));
+    const pr = Detail.parse(JSON.parse(out).data.repository.pullRequest);
+    const checks = { passing: 0, failing: [], pending: [] };
+    for (const c of pr.lastCommit.nodes[0]?.commit.statusCheckRollup?.contexts.nodes ?? []) {
+        const label = c.name ?? c.context ?? "check";
+        const outcome = c.__typename === "CheckRun" ? (c.status === "COMPLETED" ? (c.conclusion ?? "") : "PENDING") : (c.state ?? "");
+        if (FAILED.has(outcome))
+            checks.failing.push(label);
+        else if (PASSED.has(outcome))
+            checks.passing++;
+        else if (outcome === "PENDING" || outcome === "EXPECTED")
+            checks.pending.push(label);
+    }
+    const requested = (pr.reviewRequests?.nodes ?? []).flatMap((r) => {
+        const who = r.requestedReviewer;
+        if (!who)
+            return [];
+        if (who.__typename === "Team")
+            return [{ kind: "team", name: who.name ?? "team" }];
+        return [{ kind: "person", login: who.login ?? "ghost", name: who.name ?? null, avatar: who.avatarUrl ?? null }];
+    });
+    return {
+        body: pr.body,
+        createdAt: pr.createdAt,
+        additions: pr.additions,
+        deletions: pr.deletions,
+        changedFiles: pr.changedFiles,
+        commits: pr.commitCount.totalCount,
+        files: (pr.files?.nodes ?? []).map((f) => ({ path: f.path, additions: f.additions, deletions: f.deletions, change: CHANGE[f.changeType] ?? "changed" })),
+        reviews: pr.latestReviews.nodes.flatMap((r) => (r.author && REVIEW_STATE[r.state] ? [{ login: r.author.login, name: r.author.name ?? null, avatar: r.author.avatarUrl ?? null, state: REVIEW_STATE[r.state] }] : [])),
+        requested,
+        checks,
+    };
+}

package/dist/server/home-store.js

@@ -0,0 +1,127 @@
+// What Downstream remembers across repositories: which repos it knows and where
+// they're cloned, which account you're looking through, where you moved PRs in
+// the matrix, and the agent sessions it started for you.
+import { DatabaseSync } from "node:sqlite";
+import { EventEmitter } from "node:events";
+import { homedir } from "node:os";
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import { Quadrant } from "../domain/inbox.js";
+import { now } from "./store.js";
+/** Everything global lives here; `DOWNSTREAM_HOME` moves it (tests, a second install). */
+export function downstreamHome() {
+    const dir = process.env.DOWNSTREAM_HOME ?? path.join(homedir(), ".downstream");
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+const PLACEMENTS = [...Quadrant.options, "hidden"];
+const TRIAGE = (table) => `CREATE TABLE IF NOT EXISTS ${table} (account TEXT NOT NULL, item_key TEXT NOT NULL, quadrant TEXT NOT NULL CHECK (quadrant IN (${PLACEMENTS.map((p) => `'${p}'`).join(", ")})), at TEXT NOT NULL, PRIMARY KEY (account, item_key));`;
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS repos (id TEXT PRIMARY KEY, root TEXT NOT NULL UNIQUE, name_with_owner TEXT, seen_at TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS settings (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+${TRIAGE("triage")}
+CREATE TABLE IF NOT EXISTS launches (account TEXT NOT NULL, repo TEXT NOT NULL, pr INTEGER NOT NULL, root TEXT NOT NULL, session_id TEXT, at TEXT NOT NULL, PRIMARY KEY (repo, pr));
+`;
+export class HomeStore {
+    db;
+    /** "changed" whenever anything the home page shows may differ. */
+    bus = new EventEmitter();
+    constructor(file = path.join(downstreamHome(), "home.db")) {
+        this.db = new DatabaseSync(file);
+        this.db.exec("PRAGMA journal_mode = WAL;");
+        this.db.exec(SCHEMA);
+        this.renameQuadrants();
+        this.allowEveryPlacement();
+        this.bus.setMaxListeners(100);
+    }
+    changed() {
+        this.bus.emit("changed");
+    }
+    // -- repositories ---------------------------------------------------------
+    repos() {
+        return this.db.prepare("SELECT id, root, name_with_owner FROM repos ORDER BY seen_at DESC").all().map((r) => ({ id: r.id, root: r.root, nameWithOwner: r.name_with_owner }));
+    }
+    putRepo(row) {
+        this.db
+            .prepare("INSERT INTO repos (id, root, name_with_owner, seen_at) VALUES (?, ?, ?, ?) ON CONFLICT(root) DO UPDATE SET name_with_owner = COALESCE(excluded.name_with_owner, repos.name_with_owner), seen_at = excluded.seen_at")
+            .run(row.id, row.root, row.nameWithOwner, now());
+    }
+    rootFor(nameWithOwner) {
+        const row = this.db.prepare("SELECT root FROM repos WHERE lower(name_with_owner) = lower(?) ORDER BY seen_at DESC LIMIT 1").get(nameWithOwner);
+        return row?.root ?? null;
+    }
+    // -- the account you look through ------------------------------------------------
+    account() {
+        const row = this.db.prepare("SELECT value FROM settings WHERE key = 'account'").get();
+        return row?.value ?? null;
+    }
+    setAccount(login) {
+        this.db.prepare("INSERT INTO settings (key, value) VALUES ('account', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(login);
+        this.changed();
+    }
+    // -- where you moved things in the matrix ------------------------------------------
+    choices(account) {
+        const rows = this.db.prepare("SELECT item_key, quadrant, at FROM triage WHERE account = ?").all(account);
+        return Object.fromEntries(rows.map((r) => [r.item_key, { quadrant: r.quadrant, at: r.at }]));
+    }
+    /** Choices made before Schedule and Later became Next and Someday keep their meaning. */
+    renameQuadrants() {
+        const old = this.db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'choices'").get();
+        if (!old)
+            return;
+        this.tx(() => {
+            this.db.exec(`INSERT OR IGNORE INTO triage (account, item_key, quadrant, at)
+        SELECT account, item_key, CASE quadrant WHEN 'schedule' THEN 'next' WHEN 'later' THEN 'someday' ELSE quadrant END, at FROM choices`);
+            this.db.exec("DROP TABLE choices");
+        });
+    }
+    /**
+     * SQLite can't change a CHECK in place: a triage table made before a placement
+     * existed ("hidden") is rebuilt with today's list, keeping every choice.
+     */
+    allowEveryPlacement() {
+        const row = this.db.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'triage'").get();
+        if (!row || PLACEMENTS.every((p) => row.sql.includes(`'${p}'`)))
+            return;
+        this.tx(() => {
+            this.db.exec(TRIAGE("triage_next"));
+            this.db.exec("INSERT INTO triage_next (account, item_key, quadrant, at) SELECT account, item_key, quadrant, at FROM triage");
+            this.db.exec("DROP TABLE triage");
+            this.db.exec("ALTER TABLE triage_next RENAME TO triage");
+        });
+    }
+    /** `null` hands the item back to Downstream's read; "hidden" hides it from every list until it changes. */
+    choose(account, key, quadrant) {
+        if (quadrant === null)
+            this.db.prepare("DELETE FROM triage WHERE account = ? AND item_key = ?").run(account, key);
+        else
+            this.db.prepare("INSERT INTO triage (account, item_key, quadrant, at) VALUES (?, ?, ?, ?) ON CONFLICT (account, item_key) DO UPDATE SET quadrant = excluded.quadrant, at = excluded.at").run(account, key, quadrant, now());
+        this.changed();
+    }
+    // -- sessions Downstream started ----------------------------------------------------
+    launch(repo, pr) {
+        const row = this.db.prepare("SELECT account, repo, pr, root, session_id, at FROM launches WHERE lower(repo) = lower(?) AND pr = ?").get(repo, pr);
+        return row ? { account: row.account, repo: row.repo, pr: row.pr, root: row.root, sessionId: row.session_id, at: row.at } : null;
+    }
+    putLaunch(l) {
+        this.db
+            .prepare("INSERT INTO launches (account, repo, pr, root, session_id, at) VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT(repo, pr) DO UPDATE SET account = excluded.account, root = excluded.root, session_id = COALESCE(excluded.session_id, launches.session_id), at = excluded.at")
+            .run(l.account, l.repo, l.pr, l.root, l.sessionId, now());
+    }
+    /** The account a PR's session was started with, so its gh calls (and the review it sends) use the same one. */
+    accountFor(root, pr) {
+        const row = this.db.prepare("SELECT account FROM launches WHERE root = ? AND pr = ?").get(root, pr);
+        return row?.account ?? null;
+    }
+    tx(fn) {
+        this.db.exec("BEGIN");
+        try {
+            fn();
+            this.db.exec("COMMIT");
+        }
+        catch (e) {
+            this.db.exec("ROLLBACK");
+            throw e;
+        }
+    }
+}