@hanzo/build 0.2.52 → 0.2.54

package/lib/landing.js

@@ -3,8 +3,9 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * New: the empty state. A heading at the top of the column, and at the foot of
  * the pane the composer — where the run goes (Cloud: the sandbox with the
  * codebase's environment; or one of the org's machines, under remote control),
- * which repository and branch it starts from, and the ask itself.
- * Under it: attach, dictate, the mode, and the model and effort on the right.
+ * which repository and branch it starts from, and the ask itself — the one
+ * composer Chat draws too (prompt.tsx): attach and the mode at its start, the
+ * model and effort, dictation and send at its end.
  *
  * Sending starts a coding run on a project and opens it. A project is a
  * repository — the org's on the forge, or one its GitHub grants — so a run
@@ -16,39 +17,36 @@ import { SizableText, XStack, YStack } from '@hanzo/gui';
 import { Cloud, Monitor } from '@hanzogui/lucide-icons-2';
 import { Button } from '@hanzo/ui';
 import { ModeSelect } from '@hanzo/ui/agents';
-import { Composer } from '@hanzo/ui/chat';
-import { BranchSelect, ChipSelect, FooterLink, HanzoMark, RepoSelect } from '@hanzo/ui/product';
-import { ModelPicker } from '@hanzo/ui/models';
+import { BranchSelect, ChipSelect, FooterLink, RepoSelect } from '@hanzo/ui/product';
 import { useLimits } from '@hanzo/ui/product/useLimits';
+import { useDictation, useVoice } from '@hanzo/voice';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { start, unhonoured } from './api/coding.js';
 import { asRepo, chosen, codebases, one } from './api/codebases.js';
 import { repos as githubRepos } from './api/github.js';
-import { read, SETUP } from './api/environment.js';
+import { plain, read, SETUP, unset } from './api/environment.js';
+import { homes as readHomes } from './api/work.js';
 import { SetupDialog } from './environment.js';
-import { ENSO, limits as readLimits, models } from './api/models.js';
-import { usePick } from './pick.js';
+import { limits as readLimits } from './api/models.js';
 import { ready, SANDBOX } from './api/places.js';
-import { asHub, isForge, isHub } from './choice.js';
-import { useKept, usePlaces, useRead } from './data.js';
+import { asHub, isForge, isHub, settle } from './choice.js';
+import { useCached, useKept, usePlaces, useRead } from './data.js';
 import { useHost, useTarget } from './host.js';
-import { pane } from './pane.js';
+import { useMind } from './mind.js';
 import { usePrefs } from './prefs.js';
 import { Publish } from './publish.js';
 import { path } from './route.js';
-import { Attach, compose, Dictate, Files } from './tools.js';
+import { MEASURE, Prompt, useEar } from './prompt.js';
+import { compose, Files, pick } from './tools.js';
+import { useSpoken } from './voice.js';
 /** One vocabulary for the mode, on New and in a workspace. */
 export const MODES = [
     { id: 'build', label: 'Build', hint: 'Edits, commits and pushes a branch' },
     { id: 'plan', label: 'Plan', hint: 'Plans the change and writes nothing' },
 ];
-export const EFFORTS = [
-    { id: 'low', label: 'Low' },
-    { id: 'medium', label: 'Medium' },
-    { id: 'high', label: 'High' },
-];
-const FIRST = { repo: null, branch: '', place: '', mode: 'build', model: ENSO, effort: 'medium', ask: '' };
-const COLUMN = 768;
+/** The org's repositories before they have been read: no answer, so nothing is judged from it. */
+const NOHOMES = { homes: [], whole: false };
+const FIRST = { repo: null, branch: '', place: '', mode: 'build', ask: '', issue: 0 };
 const UNSENT = 'hanzo.build.unsent';
 let held = { draft: '', files: [] };
 function unsent() {
@@ -81,11 +79,15 @@ export function Landing({ onStarted }) {
     const signed = Boolean(host.person);
     const { prefs } = usePrefs();
     const [stored, keep] = useKept(`hanzo.build.new.${host.org ?? 'none'}`, null);
-    // Nothing chosen here yet: start from the person's coding defaults (Settings → Code).
-    const kept = stored ?? { ...FIRST, ...prefs.code };
+    // What was chosen here, over the person's coding defaults (Settings → Code), over
+    // the first run's. Field by field: a codebase or an issue handed over from its own
+    // screen keeps only the codebase and the words, and the rest still has a value.
+    const kept = settle(FIRST, prefs.code, stored);
     const set = (patch) => keep({ ...kept, ...patch });
     const [was] = useState(unsent);
     const [draft, setDraft] = useState(kept.ask || was.draft);
+    // The issue handed over with the words, while the run is still on its repository.
+    const [issue, setIssue] = useState(kept.ask ? kept.issue : 0);
     const [files, setFiles] = useState(was.files);
     useEffect(() => hold({ draft, files }), [draft, files]);
     const [busy, setBusy] = useState(false);
@@ -98,18 +100,27 @@ export function Landing({ onStarted }) {
     // A codebase or an issue hands its words over once. Left in the kept choice,
     // every later visit to New would put them back.
     useEffect(() => {
-        if (kept.ask)
-            set({ ask: '' });
+        if (kept.ask || kept.issue)
+            set({ ask: '', issue: 0 });
         // The handover is read on this mount only.
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, []);
     const places = usePlaces(t, signed);
-    const catalog = useRead(signed ? () => models(t) : null, [], [t, signed]);
+    // The model and effort Chat shares, and dictation into the ask.
+    const mind = useMind(t);
     const { limits } = useLimits(signed ? (signal) => readLimits(t, signal) : null, t);
-    const [model, pickModel] = usePick(kept.model, (id) => set({ model: id }), catalog.value);
+    const voice = useVoice({ speech: useEar(t), language: useSpoken(), ...useDictation(draft, setDraft) });
     // The chosen codebase's environment, so New can say when it has none yet.
     const codebase = isForge(kept.repo) ? kept.repo.name : '';
-    const env = useRead(signed && codebase ? () => read(t, codebase) : null, null, [t, signed, codebase]);
+    // The org's repositories on the forge: what a run and an environment can name.
+    const homes = useCached(signed ? `${host.org}:homes` : null, (signal) => readHomes(t, signal), NOHOMES);
+    // A kept codebase the org's whole list does not hold — a board's key once handed over as one — is not offered as one.
+    const stranger = codebase !== '' && homes.value.whole && !homes.value.homes.some((h) => h.name.toLowerCase() === codebase.toLowerCase());
+    // Read once the list has answered (or failed), so a name that is not the org's is never asked for.
+    const settled = homes.value !== NOHOMES || homes.error !== null;
+    const found = useRead(signed && codebase && settled && !stranger ? () => read(t, codebase) : null, null, [t, signed, codebase, settled, stranger]);
+    // A read kept from the codebase before is not this one's.
+    const env = { ...found, value: found.value && found.value.repo === codebase && !stranger ? found.value : null };
     const place = places.value.find((p) => p.id === kept.place) ?? SANDBOX;
     const known = useRef(new Map());
     const hubs = useRef(new Map());
@@ -130,9 +141,9 @@ export function Landing({ onStarted }) {
     // Drawn only once a forge codebase is chosen; one the forge no longer lists offers its default branch.
     const home = kept.repo?.default_branch || 'main';
     const loadBranches = useCallback(async (q) => {
-        const found = await one(t, codebase);
+        const got = await one(t, codebase);
         const needle = q.trim().toLowerCase();
-        const names = (found?.branches ?? [home]).filter((b) => !needle || b.toLowerCase().includes(needle));
+        const names = (got?.branches ?? [home]).filter((b) => !needle || b.toLowerCase().includes(needle));
         return { branches: names.map((name) => ({ name })), next: null };
     }, [t, codebase, home]);
     // The composer sends only a draft with words in it, and not while a send is out.
@@ -149,6 +160,17 @@ export function Landing({ onStarted }) {
             setPicking(true);
             return;
         }
+        // A plan or a setup routed to a machine is refused here, in its own words, before it leaves the page.
+        const why = unhonoured(kept.mode, place.id);
+        if (why) {
+            setNote(why);
+            return;
+        }
+        if (stranger) {
+            setNote(`${codebase} is not one of this organization’s repositories. Choose one, or leave it empty to start a new project.`);
+            setPicking(true);
+            return;
+        }
         setBusy(true);
         setNote('');
         try {
@@ -160,15 +182,17 @@ export function Landing({ onStarted }) {
                 base: repo ? kept.branch : hub ? kept.branch || hub.default_branch : undefined,
                 targetId: place.id,
                 mode: kept.mode,
-                model: model === ENSO ? undefined : model,
-                effort: kept.effort,
+                model: mind.model,
+                effort: mind.effort,
+                issue,
             });
             setDraft('');
             setFiles([]);
+            setIssue(0);
             onStarted(run.session);
         }
         catch (e) {
-            setNote(e.message);
+            setNote(plain(e, repo?.name ?? hub?.full_name ?? 'a new project', 'run'));
         }
         finally {
             setBusy(false);
@@ -184,18 +208,26 @@ export function Landing({ onStarted }) {
         // Sent once, on the sign-in that it waited for.
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [signed]);
-    /** Start the agent that finds this codebase's environment, and open it. A refusal is the dialog's to say. */
-    const setup = async () => {
-        const run = await start(t, { prompt: SETUP, repo: codebase, mode: 'setup' });
+    /** Start the agent that finds a codebase's environment, and open it: its run is the progress. A refusal is the dialog's to say. */
+    const setup = async (repo) => {
+        const run = await start(t, { prompt: SETUP, repo, mode: 'setup', model: mind.model, effort: mind.effort });
         onStarted(run.session);
     };
+    /** The codebase a dialog chose, chosen here too. */
+    const choose = (h) => {
+        const row = chosen({ owner: h.label.split('/')[0] ?? '', name: h.name, full_name: h.label, default_branch: h.branch });
+        setIssue(0);
+        set({ repo: row, branch: row.default_branch });
+    };
     // Cloud is the sandbox, set up by the chosen codebase's environment.
     const setUp = codebase && env.value
         ? env.value.state === 'ready'
             ? `${codebase} environment`
             : env.value.state === 'proposed'
                 ? `${codebase} environment proposed`
-                : `no ${codebase} environment yet`
+                : unset(env.value)
+                    ? `no ${codebase} environment yet`
+                    : `${codebase} environment, empty`
         : '';
     const placeItems = useMemo(() => (places.value.length ? places.value : [SANDBOX]).map((p) => ({
         id: p.id || 'sandbox',
@@ -207,6 +239,7 @@ export function Landing({ onStarted }) {
     const branch = kept.branch || kept.repo?.default_branch || 'main';
     const head = (_jsxs(XStack, { gap: 6, items: "center", flexWrap: "wrap", children: [_jsx(ChipSelect, { name: "Where the run runs", icon: place.id ? _jsx(Monitor, { size: 13 }) : _jsx(Cloud, { size: 13 }), label: place.id ? place.label : 'Cloud', chosen: placeItems.find((i) => i.place.id === place.id), items: placeItems, onChange: (i) => set({ place: i.place.id }), placeholder: "Search machines\u2026", loading: places.loading, error: places.error?.message ?? null, footer: _jsxs(YStack, { gap: "$0.5", children: [_jsx(SizableText, { size: "$1", color: "$ink", children: "Set up remote control" }), _jsxs(SizableText, { size: "$1", color: "$soft", children: ["Run", ' ', _jsx(SizableText, { size: "$1", color: "$ink", style: { fontFamily: 'var(--f-mono, ui-monospace, monospace)' }, children: "hanzo link" }), ' ', "on a machine: it joins this list, and a run there uses its checkout and credentials."] })] }) }), _jsx(RepoSelect, { open: picking, onOpenChange: setPicking, value: isForge(kept.repo) || isHub(kept.repo) ? kept.repo : null, onChange: (r) => {
                     const hub = r.github ? hubs.current.get((r.full_name ?? "").toLowerCase()) : undefined;
+                    setIssue(0);
                     if (hub) {
                         set({ repo: hub, branch: hub.default_branch });
                         return;
@@ -228,10 +261,9 @@ export function Landing({ onStarted }) {
                         });
                     },
                 }, placeholder: "Choose a project", disabled: !signed }, round), isForge(kept.repo) ? _jsx(BranchSelect, { value: branch, onChange: (b) => set({ branch: b }), load: loadBranches }) : null, _jsx(Files, { files: files, onFiles: setFiles })] }));
-    const foot = (_jsxs(XStack, { flex: 1, items: "center", gap: "$2", flexWrap: "wrap", rowGap: "$1", children: [_jsx(Attach, { files: files, onFiles: setFiles, onNote: setNote }), _jsx(Dictate, { onText: (said) => setDraft((d) => (d ? `${d} ${said}` : said)), onNote: setNote }), _jsx(ModeSelect, { modes: MODES, value: kept.mode, onChange: (m) => set({ mode: m }), bg: "transparent", minH: 24, px: "$1.5", self: "center" }), _jsx(XStack, { flex: 1 }), _jsx(ModelPicker, { quiet: true, size: "sm", name: "Model", models: catalog.value, scope: "chat", limits: limits, value: model, onChange: pickModel, loading: catalog.loading, error: catalog.error?.message ?? null }), _jsx(ChipSelect, { quiet: true, name: "Effort", label: EFFORTS.find((e) => e.id === kept.effort)?.label ?? 'Medium', chosen: EFFORTS.find((e) => e.id === kept.effort) ?? null, items: EFFORTS, onChange: (e) => set({ effort: e.id }), placement: "top-end", width: 180 })] }));
-    return (_jsxs(YStack, { flex: 1, minH: 0, minW: 0, items: "center", justify: "center", px: "$4", pb: "$10", overflow: "scroll", children: [_jsxs(YStack, { width: "100%", maxW: COLUMN, gap: "$5", children: [_jsxs(XStack, { role: "heading", "aria-level": 1, justify: "center", items: "center", gap: "$3", flexWrap: "wrap", children: [_jsx(HanzoMark, { size: 26 }), _jsx(SizableText, { size: "$8", color: "$ink", style: { textAlign: 'center' }, children: prefs.callName ? `What’s up next, ${prefs.callName}?` : 'What’s up next?' })] }), _jsxs(YStack, { gap: "$2", children: [env.value && env.value.state !== 'ready' && !place.id ? (_jsxs(XStack, { items: "center", justify: "space-between", gap: "$3", px: "$3", py: "$2", rounded: "$10", borderWidth: 1, borderColor: "$borderColor", children: [_jsx(SizableText, { size: "$2", color: "$ink", flex: 1, minW: 0, children: env.value.state === 'proposed'
+    return (_jsxs(YStack, { flex: 1, minH: 0, minW: 0, items: "center", justify: "center", pb: "$10", overflowY: "auto", overflowX: "hidden", children: [_jsxs(YStack, { width: "100%", maxW: MEASURE, gap: "$5", children: [_jsx(SizableText, { render: "h1", fontSize: "$7", lineHeight: "$7", fontWeight: "700", color: "$ink", style: { textAlign: 'center' }, children: prefs.callName ? `What’s up next, ${prefs.callName}?` : 'What’s up next?' }), _jsxs(YStack, { gap: "$2", children: [stranger ? (_jsxs(XStack, { items: "center", justify: "space-between", gap: "$3", px: "$3", py: "$2", rounded: "$10", borderWidth: 1, borderColor: "$borderColor", role: "alert", children: [_jsx(SizableText, { size: "$2", color: "$ink", flex: 1, minW: 0, children: `${codebase} is not one of this organization’s repositories.` }), _jsx(Button, { size: "sm", variant: "outline", onPress: () => setPicking(true), children: "Choose a repository" })] })) : env.value && (env.value.state === 'proposed' || unset(env.value)) && !place.id ? (_jsxs(XStack, { items: "center", justify: "space-between", gap: "$3", px: "$3", py: "$2", rounded: "$10", borderWidth: 1, borderColor: "$borderColor", children: [_jsx(SizableText, { size: "$2", color: "$ink", flex: 1, minW: 0, children: env.value.state === 'proposed'
                                             ? `A proposed environment for ${codebase} is waiting for review.`
-                                            : `${codebase} has no environment yet, so every run starts it bare.` }), env.value.state === 'proposed' && env.value.session ? (_jsx(Button, { size: "sm", variant: "outline", onPress: () => host.go(env.value.session), children: "Review" })) : (_jsx(Button, { size: "sm", onPress: () => setOffering(true), children: "Set up environment" }))] })) : null, note || unhonoured(kept.mode, place.id) ? (_jsx(SizableText, { size: "$1", color: "$soft", role: "status", children: note || unhonoured(kept.mode, place.id) })) : null, _jsx(Composer, { inline: true, ...pane, value: draft, onChange: setDraft, onSend: () => void send(), busy: busy, placeholder: "Describe a task or ask a question", label: "Describe a task or ask a question", head: head, foot: foot })] })] }), _jsx(Publish, { source: adding, onClose: () => setAdding(null) }), codebase ? (_jsx(SetupDialog, { repo: codebase, open: offering, onOpenChange: setOffering, onStart: setup, onSaved: () => {
+                                            : `${codebase} has no environment yet, so every run starts it bare.` }), env.value.state === 'proposed' && env.value.session ? (_jsx(Button, { size: "sm", variant: "outline", onPress: () => host.go(env.value.session), children: "Review" })) : (_jsx(Button, { size: "sm", onPress: () => setOffering(true), children: "Set up environment" }))] })) : null, note || unhonoured(kept.mode, place.id) || mind.note ? (_jsx(SizableText, { size: "$1", color: "$soft", role: "status", children: note || unhonoured(kept.mode, place.id) || mind.note })) : null, _jsx(Prompt, { framed: true, value: draft, onChange: setDraft, onSend: () => void send(), busy: busy, placeholder: "Describe a task or ask a question", label: "Describe a task or ask a question", head: head, onAttach: () => pick(files, setFiles, setNote), tools: _jsx(ModeSelect, { modes: MODES, value: kept.mode, onChange: (m) => set({ mode: m }), bg: "transparent", minH: 24, px: "$1.5", self: "center" }), mind: mind, limits: limits, voice: voice })] })] }), _jsx(Publish, { source: adding, onClose: () => setAdding(null) }), codebase ? (_jsx(SetupDialog, { repo: codebase, homes: homes, open: offering, onOpenChange: setOffering, onStart: setup, onRepo: choose, onSaved: () => {
                     setOffering(false);
                     env.reload();
                 } })) : null] }));

package/lib/merge.d.ts

@@ -0,0 +1,223 @@
+/**
+ * The projects an organization works on and their issues, merged.
+ *
+ * A project is a repository: granted by the org's GitHub connection, mirrored
+ * onto the forge, or made there. The same repository arrives from several
+ * sources and is one row. An issue is read from the forge and from the task
+ * service's mirror of GitHub; the same issue (the same link) is one row with
+ * every source that carried it named.
+ *
+ * Which project an issue is for is the issue's own repository — the GitHub
+ * address its mirror records, or the forge repository it is filed on — and
+ * never the board it sits on: a board's key is not a repository.
+ *
+ * Pure: every function here takes rows and answers rows, so the screens and the
+ * tests share one reading of what is the same, what belongs where, and what
+ * comes first.
+ */
+export type Source = 'github' | 'forge' | 'linear' | 'agent' | 'board';
+export interface Project {
+    /** `owner/name`, lower case: the one address every source is matched on. */
+    key: string;
+    owner: string;
+    name: string;
+    description: string;
+    /** Null when no source said. */
+    private: boolean | null;
+    /** The default branch, or '' when no source said. */
+    branch: string;
+    /** RFC 3339: the latest push, update or issue any source reports, or ''. */
+    activity: string;
+    /** Open issues, or null when the work could not be read. */
+    issues: number | null;
+    /** Open pull requests on the forge, or null when the work could not be read. */
+    pulls: number | null;
+    /** Granted by the org's GitHub connection. */
+    linked: boolean;
+    /** On the forge: mirrored from GitHub, or made there. */
+    mirrored: boolean;
+    /** The forge's own name for it, which is what a run and an environment name; '' when it is not known to be there. */
+    forge: string;
+    /** RFC 3339: when its link last synced, or ''. */
+    synced: string;
+    /** Its link's state: `synced`, `conflict`, `pending`, `paused`, `linked` when its forge copy could not be read; '' with no link. */
+    status: string;
+    /** The org's project (GET /v1/projects) that builds from it, by slug, or ''. */
+    slug: string;
+    /** The name GitHub's listing says it takes on the forge once brought there, or ''. */
+    codebase: string;
+    /** Its page on GitHub, or ''. */
+    url: string;
+}
+export interface Issue {
+    /** What makes two rows the same issue: its link, else its handle on its board, else its id. */
+    key: string;
+    /** `owner/name` of the repository it is filed on, once known; '' until then. */
+    repo: string;
+    /** The forge repository a forge row is filed on, by name; ''. */
+    forge: string;
+    /** What an index row says its repository is, unchecked: a run's repo, or a Linear team's key. Resolved, never used raw. */
+    hint: string;
+    number: number;
+    title: string;
+    body: string;
+    state: 'open' | 'closed';
+    labels: string[];
+    assignees: string[];
+    /** The issue's own page, https only, or ''. */
+    url: string;
+    sources: Source[];
+    /** RFC 3339, or ''. */
+    updated: string;
+    /** RFC 3339: when it was opened, or ''. */
+    created: string;
+    /** What the task service files it as: `issue`, `pr`, `task`, `bug`, … */
+    kind: string;
+    /** The board's column for it as the task service names it: `backlog`, `todo`, `in_progress`, `done`, `canceled`, or its own word. */
+    status: string;
+    /** `none` unless the board says otherwise. */
+    priority: string;
+    /** A pull request, not an issue. */
+    pull: boolean;
+    /** The board it was read from. Shown, filtered on, never resolved as a repository. */
+    board: string;
+}
+/** `owner/name` as one key, whatever case either source used. */
+export declare const keyOf: (owner: string, name: string) => string;
+/**
+ * An issue's link as one key: https only, no query or fragment, no trailing
+ * slash, lower case. The same issue read twice has the same key.
+ */
+export declare function canon(url: string): string;
+/** The repository and number a GitHub or forge issue link names, or null. */
+export declare function parse(url: string): {
+    repo: string;
+    number: number;
+    pull: boolean;
+} | null;
+/** Whether every word of `q` is somewhere in `text`. */
+export declare function matches(q: string, ...text: string[]): boolean;
+/** A repository GitHub's listing grants, in the fields a project takes from it. */
+export interface Granted {
+    owner: string;
+    name: string;
+    private: boolean;
+    default_branch: string;
+    pushed_at: string;
+    codebase: string;
+}
+/** A repository the forge lists, in the fields a project takes from it. */
+export interface Held {
+    org: string;
+    name: string;
+    description: string;
+    branch: string;
+    public: boolean;
+    updated: string;
+}
+/** A repository linked from GitHub (GET /v1/sync), in the fields a project takes from it. */
+export interface Linked {
+    owner: string;
+    name: string;
+    forge: string;
+    synced: string;
+    status: string;
+    branch: string;
+}
+/** One of the org's projects (GET /v1/projects) that builds from a repository. */
+export interface Site {
+    slug: string;
+    /** Its clone address. */
+    repo: string;
+    branch: string;
+    /** RFC 3339, or ''. */
+    updated: string;
+}
+/** The account and repository an https clone address names, and whether the host is GitHub. */
+export declare function addressOf(url: string): {
+    owner: string;
+    name: string;
+    github: boolean;
+} | null;
+/**
+ * The project an issue is for, or null. Its GitHub address first, then the
+ * forge repository it is filed on, then what an index row says — matched
+ * against the org's own projects, an `owner/name` exactly, a bare name only when
+ * one project answers to it. A board's key is never consulted.
+ */
+export declare function place(i: Pick<Issue, 'repo' | 'forge' | 'hint'>, list: Project[]): Project | null;
+/** Whether a clone address is the forge's own. */
+export declare function forgeHost(url: string): boolean;
+/** What the org's projects are assembled from. */
+export interface Parts {
+    /** GitHub's grants to the org's connection: empty for anyone it does not answer. */
+    granted?: Granted[];
+    /** The repositories linked from GitHub, each with its forge copy. */
+    linked?: Linked[];
+    /** The forge's repositories. */
+    held?: Held[];
+    /** The org's projects that build from a repository. */
+    sites?: Site[];
+    /** Every issue and pull request, or null when they were not read. */
+    work?: Issue[] | null;
+}
+/**
+ * Every project the org works on, one row per repository: the repositories it
+ * linked from GitHub, GitHub's grants, the forge's repositories and the ones its
+ * issues are filed on, and the org's projects that build from one — each with
+ * its open work counted from `work` (null counts when the work was not read).
+ *
+ * A forge repository is the GitHub one it copies when a link targets it, when
+ * GitHub names it as that repository's `codebase`, or when it sits in a forge
+ * namespace named like the GitHub owner (an issue's link says which namespace).
+ */
+export declare function assemble({ granted, linked, held, sites, work }: Parts): Project[];
+/** Each issue with the project it is for named as its `repo`, where one answers. */
+export declare function attach(list: Issue[], projects: Project[]): Issue[];
+/** Most recent activity first; the unknown last; the address breaks a tie, so the order never shuffles. */
+export declare function byActivity(a: Project, b: Project): number;
+export interface ProjectFilter {
+    q?: string;
+    /** One owner, or '' for every one. */
+    owner?: string;
+    /** Only those with an open issue or pull request. */
+    open?: boolean;
+}
+export declare function pickProjects(list: Project[], f?: ProjectFilter): Project[];
+/** The owners named, once each whatever the case, in name order. */
+export declare function owners(...names: string[][]): string[];
+/**
+ * One row per issue. The same issue read from several sources is the row the
+ * most recently updated one describes, with every source named and every label
+ * and assignee any of them carries.
+ */
+export declare function issues(...lists: Issue[][]): Issue[];
+/** Every label and assignee the list carries, for its filters, in name order. */
+export declare function facets(list: Issue[]): {
+    labels: string[];
+    assignees: string[];
+};
+/**
+ * Where a run on issue `i` works, on project `p`: where the issue lives, so the
+ * run's pull request is opened beside it. A GitHub issue's run works on GitHub
+ * (a linked project's forge copy is the forge's own repository, and a pull
+ * request there would not reach GitHub's issue); a forge issue's on the forge.
+ * Any other issue (a Linear or a board's row) works wherever the project can be
+ * worked on: its forge copy, else GitHub. Null when the project is neither.
+ */
+export declare function home(i: Pick<Issue, 'sources'>, p: Pick<Project, 'linked' | 'forge'>): 'github' | 'forge' | null;
+/**
+ * The number a run on `p` closes for issue `i`, or 0: the issue's own number,
+ * when the run works where the issue lives. A board's or Linear's number closes
+ * nothing, and neither does a GitHub issue run on the forge, or the reverse.
+ */
+export declare function closes(i: Pick<Issue, 'sources' | 'number'>, p: Pick<Project, 'linked' | 'forge'>): number;
+/** How a person refers to an issue: `#N` where N is the repository's own number, else the board's handle. */
+export declare function handle(i: Pick<Issue, 'sources' | 'number' | 'board'>): string;
+/**
+ * What New's composer holds for an issue: its title and handle, its link, and
+ * its body — the ask a person would write. `#N` only when the run closes N; any
+ * other number is the board's (`LINEAR-5`), so the agent cannot mistake it for
+ * an issue on the repository it works on.
+ */
+export declare function ask(i: Pick<Issue, 'title' | 'number' | 'url' | 'body' | 'board' | 'sources'>, closing?: number): string;