@hanzo/build 0.2.51 → 0.2.53

package/lib/merge.js

@@ -0,0 +1,380 @@
+/**
+ * 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.
+ */
+/** `owner/name` as one key, whatever case either source used. */
+export const keyOf = (owner, name) => (owner && name ? `${owner}/${name}`.toLowerCase() : '');
+const time = (iso) => {
+    const t = Date.parse(iso);
+    return Number.isFinite(t) ? t : 0;
+};
+const later = (a, b) => (time(b) > time(a) ? b : a);
+/**
+ * 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 function canon(url) {
+    try {
+        const u = new URL(url);
+        if (u.protocol !== 'https:')
+            return '';
+        return `https://${u.host}${u.pathname.replace(/\/+$/, '')}`.toLowerCase();
+    }
+    catch {
+        return '';
+    }
+}
+/** The repository and number a GitHub or forge issue link names, or null. */
+export function parse(url) {
+    const m = canon(url).match(/^https:\/\/[^/]+\/([^/]+)\/([^/]+)\/(issues|pull|pulls)\/(\d+)$/);
+    return m ? { repo: `${m[1]}/${m[2]}`, number: Number(m[4]), pull: m[3] !== 'issues' } : null;
+}
+/** Whether every word of `q` is somewhere in `text`. */
+export function matches(q, ...text) {
+    const words = q.trim().toLowerCase().split(/\s+/).filter(Boolean);
+    if (!words.length)
+        return true;
+    const hay = text.join(' ').toLowerCase();
+    return words.every((w) => hay.includes(w));
+}
+/** The account and repository an https clone address names, and whether the host is GitHub. */
+export function addressOf(url) {
+    try {
+        const u = new URL(url.trim());
+        if (u.protocol !== 'https:')
+            return null;
+        const parts = u.pathname.replace(/\.git$/, '').split('/').filter(Boolean);
+        if (parts.length < 2)
+            return null;
+        const github = u.hostname.toLowerCase() === 'github.com';
+        if (github && parts.length !== 2)
+            return null;
+        return { owner: parts[parts.length - 2], name: parts[parts.length - 1], github };
+    }
+    catch {
+        return null;
+    }
+}
+const blank = (owner, name) => ({
+    key: keyOf(owner, name),
+    owner,
+    name,
+    description: '',
+    private: null,
+    branch: '',
+    activity: '',
+    issues: null,
+    pulls: null,
+    linked: false,
+    mirrored: false,
+    forge: '',
+    synced: '',
+    status: '',
+    slug: '',
+    codebase: '',
+    url: '',
+});
+/**
+ * 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 function place(i, list) {
+    if (i.repo)
+        return list.find((p) => p.key === i.repo.toLowerCase()) ?? null;
+    if (i.forge) {
+        const f = i.forge.toLowerCase();
+        return list.find((p) => p.forge.toLowerCase() === f) ?? list.find((p) => p.codebase === f) ?? null;
+    }
+    const hint = i.hint
+        .trim()
+        .toLowerCase()
+        .replace(/^(https?:\/\/)?github\.com\//, '')
+        .replace(/\.git$/, '');
+    if (!hint)
+        return null;
+    if (hint.includes('/'))
+        return list.find((p) => p.key === hint) ?? null;
+    const named = list.filter((p) => p.forge.toLowerCase() === hint || p.codebase === hint || p.name.toLowerCase() === hint);
+    return named.length === 1 ? named[0] : null;
+}
+/** Whether a clone address is the forge's own. */
+export function forgeHost(url) {
+    try {
+        const u = new URL(url);
+        return u.protocol === 'https:' && (u.hostname.toLowerCase() === 'git.hanzo.ai' || u.pathname.startsWith('/v1/git/'));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 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 function assemble({ granted = [], linked = [], held = [], sites = [], work = null }) {
+    const out = new Map();
+    // Each project by its forge name and by its codebase name, kept as it is put, so a forge row finds its own in one look.
+    const byForge = new Map();
+    const byCodebase = new Map();
+    const put = (p) => {
+        if (!p.key)
+            return;
+        out.set(p.key, p);
+        if (p.forge)
+            byForge.set(p.forge.toLowerCase(), p.key);
+        if (p.codebase)
+            byCodebase.set(p.codebase, p.key);
+    };
+    const at = (owner, name) => out.get(keyOf(owner, name)) ?? blank(owner, name);
+    for (const l of linked) {
+        const p = at(l.owner, l.name);
+        put({
+            ...p,
+            branch: p.branch || l.branch,
+            activity: later(p.activity, l.synced),
+            linked: true,
+            mirrored: p.mirrored || (l.forge !== '' && l.status !== 'pending'),
+            forge: p.forge || (l.status === 'pending' ? '' : l.forge),
+            synced: later(p.synced, l.synced),
+            // A link whose forge copy could not be read says only that it is linked.
+            status: l.status || 'linked',
+            url: `https://github.com/${l.owner}/${l.name}`,
+        });
+    }
+    for (const g of granted) {
+        const p = at(g.owner, g.name);
+        put({
+            ...p,
+            private: g.private,
+            branch: p.branch || g.default_branch,
+            activity: later(p.activity, g.pushed_at),
+            linked: true,
+            codebase: g.codebase.toLowerCase(),
+            url: `https://github.com/${g.owner}/${g.name}`,
+        });
+    }
+    const all = () => [...out.values()];
+    // Forge namespaces, as the forge's own issue links spell them.
+    const spaces = new Set();
+    for (const i of work ?? []) {
+        const where = i.forge ? parse(i.url) : null;
+        if (where)
+            spaces.add(where.repo.split('/')[0].toLowerCase());
+    }
+    const named = (key) => (key ? out.get(key) : undefined);
+    const onForge = (name, owner) => {
+        const n = name.toLowerCase();
+        return (named(byForge.get(n)) ??
+            named(byCodebase.get(n)) ??
+            [...spaces].map((space) => out.get(keyOf(space, name))).find((p) => p !== undefined) ??
+            at(owner, name));
+    };
+    for (const h of held) {
+        const p = onForge(h.name, h.org);
+        put({
+            ...p,
+            description: p.description || h.description,
+            // A linked repository's visibility is GitHub's own, never its forge copy's: unknown until GitHub says.
+            private: p.linked ? p.private : (p.private ?? !h.public),
+            branch: p.branch || h.branch,
+            activity: later(p.activity, h.updated),
+            mirrored: true,
+            // A link's copy keeps its own name: a forge repository of the same address is not it.
+            forge: p.forge || h.name,
+        });
+    }
+    for (const i of work ?? []) {
+        if (!i.forge)
+            continue;
+        const where = parse(i.url);
+        const p = onForge(i.forge, where ? where.repo.split('/')[0] : '');
+        put({ ...p, mirrored: true, forge: p.forge || i.forge });
+    }
+    for (const site of sites) {
+        const where = addressOf(site.repo);
+        // GitHub's, or the forge's own (git.hanzo.ai, or the platform's /v1/git); a site built from anywhere else is not a project here.
+        if (!where || (!where.github && !forgeHost(site.repo)))
+            continue;
+        const p = where.github ? at(where.owner, where.name) : onForge(where.name, where.owner);
+        put({
+            ...p,
+            branch: p.branch || site.branch,
+            activity: later(p.activity, site.updated),
+            linked: p.linked || where.github,
+            mirrored: p.mirrored || !where.github,
+            forge: p.forge || (where.github ? '' : where.name),
+            slug: p.slug || site.slug,
+            url: p.url || (where.github ? `https://github.com/${where.owner}/${where.name}` : ''),
+        });
+    }
+    if (work) {
+        const counted = new Map();
+        const list = all();
+        for (const i of work) {
+            const p = place(i, list);
+            if (!p)
+                continue;
+            const c = counted.get(p.key) ?? { issues: 0, pulls: 0, last: '' };
+            if (i.state === 'open' && i.pull)
+                c.pulls++;
+            else if (i.state === 'open')
+                c.issues++;
+            c.last = later(c.last, i.updated);
+            counted.set(p.key, c);
+        }
+        for (const p of list) {
+            const c = counted.get(p.key);
+            put({ ...p, issues: c?.issues ?? 0, pulls: c?.pulls ?? 0, activity: later(p.activity, c?.last ?? '') });
+        }
+    }
+    return all();
+}
+/** Each issue with the project it is for named as its `repo`, where one answers. */
+export function attach(list, projects) {
+    return list.map((i) => {
+        const p = place(i, projects);
+        return p ? { ...i, repo: `${p.owner}/${p.name}` } : i;
+    });
+}
+/** Most recent activity first; the unknown last; the address breaks a tie, so the order never shuffles. */
+export function byActivity(a, b) {
+    return time(b.activity) - time(a.activity) || a.key.localeCompare(b.key);
+}
+export function pickProjects(list, f = {}) {
+    return list
+        .filter((p) => !f.owner || p.owner.toLowerCase() === f.owner.toLowerCase())
+        .filter((p) => !f.open || (p.issues ?? 0) + (p.pulls ?? 0) > 0)
+        .filter((p) => matches(f.q ?? '', `${p.owner}/${p.name}`, p.description))
+        .sort(byActivity);
+}
+/** The owners named, once each whatever the case, in name order. */
+export function owners(...names) {
+    const seen = new Map();
+    for (const n of names.flat())
+        if (n && !seen.has(n.toLowerCase()))
+            seen.set(n.toLowerCase(), n);
+    return [...seen.values()].sort((a, b) => a.localeCompare(b));
+}
+const union = (a, b) => {
+    const out = [...a];
+    const have = new Set(a.map((x) => x.toLowerCase()));
+    for (const x of b) {
+        if (have.has(x.toLowerCase()))
+            continue;
+        have.add(x.toLowerCase());
+        out.push(x);
+    }
+    return out;
+};
+/**
+ * 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 function issues(...lists) {
+    const out = new Map();
+    for (const i of lists.flat()) {
+        if (!i.key)
+            continue;
+        const had = out.get(i.key);
+        if (!had) {
+            out.set(i.key, { ...i, sources: [...new Set(i.sources)] });
+            continue;
+        }
+        const [lead, rest] = time(i.updated) > time(had.updated) ? [i, had] : [had, i];
+        out.set(i.key, {
+            ...lead,
+            repo: lead.repo || rest.repo,
+            forge: lead.forge || rest.forge,
+            hint: lead.hint || rest.hint,
+            number: lead.number || rest.number,
+            title: lead.title || rest.title,
+            body: lead.body || rest.body,
+            url: lead.url || rest.url,
+            board: lead.board || rest.board,
+            labels: union(lead.labels, rest.labels),
+            assignees: union(lead.assignees, rest.assignees),
+            sources: [...new Set([...had.sources, ...i.sources])],
+        });
+    }
+    return [...out.values()];
+}
+/** Every label and assignee the list carries, for its filters, in name order. */
+export function facets(list) {
+    const order = (a, b) => a.localeCompare(b);
+    return {
+        labels: list.reduce((acc, i) => union(acc, i.labels), []).sort(order),
+        assignees: list.reduce((acc, i) => union(acc, i.assignees), []).sort(order),
+    };
+}
+/**
+ * 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 function home(i, p) {
+    if (i.sources.includes('github') && p.linked)
+        return 'github';
+    if (i.sources.includes('forge') && p.forge)
+        return 'forge';
+    return p.forge ? 'forge' : p.linked ? 'github' : 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 function closes(i, p) {
+    if (i.number <= 0)
+        return 0;
+    const at = home(i, p);
+    if (at === 'github' && i.sources.includes('github'))
+        return i.number;
+    if (at === 'forge' && i.sources.includes('forge'))
+        return i.number;
+    return 0;
+}
+/** How a person refers to an issue: `#N` where N is the repository's own number, else the board's handle. */
+export function handle(i) {
+    if (!i.number)
+        return '';
+    if (i.sources.includes('github') || i.sources.includes('forge'))
+        return `#${i.number}`;
+    return i.board ? `${i.board}-${i.number}` : '';
+}
+/**
+ * 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 function ask(i, closing = 0) {
+    const tag = closing ? `#${closing}` : i.board && i.number ? `${i.board}-${i.number}` : '';
+    const head = tag ? `${i.title} (${tag})` : i.title;
+    const body = i.body.trim();
+    return [head, i.url, body ? `\n${body}` : ''].filter(Boolean).join('\n');
+}

package/lib/meter.d.ts

@@ -0,0 +1,31 @@
+import type { Read } from './data.ts';
+import { type Standing } from './standing.ts';
+import { type Label } from './plan.ts';
+/** The ink a share is said in: quiet until it is close, and the one red when it is used. */
+export declare const INK: {
+    readonly ok: '$soft';
+    readonly near: '$yellow10';
+    readonly limited: '$red10';
+};
+/** A plan's name with its rung beside it, small: `Max` `20x`. */
+export declare function Title({ label, size }: {
+    label: Label;
+    size?: '$3' | '$5' | '$6';
+}): import("react").JSX.Element;
+/** The standing, drawn: what `Meter` shows once it has read. */
+export declare function Reading({ s, onPlans, onBilling, now }: {
+    s: Standing;
+    onPlans: () => void;
+    onBilling: () => void;
+    now?: number;
+}): import("react").JSX.Element;
+/**
+ * The block an account menu leads with: `read` is `useStanding`, asked while
+ * the menu is open. `onPlans` opens the plans and `onBilling` the page credits
+ * live on; the host says where each is.
+ */
+export declare function Meter({ read, onPlans, onBilling }: {
+    read: Read<Standing | null>;
+    onPlans: () => void;
+    onBilling: () => void;
+}): import("react").JSX.Element;

package/lib/meter.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The plan, at the top of an account menu: what the account is on, and its
+ * meter. One block for every account menu — Dev's, the app's column, Chat's —
+ * so the plan reads the same wherever the menu opens.
+ *
+ *   Max 20x        Session 40% · Resets 5:00 PM / Today 12% / Month 62%
+ *   Free           62% of today's free usage left · Upgrade
+ *   Pay as you go  $42.10 in credits · Add funds
+ *
+ * A plan's meter is its windows as shares and never money: credits are
+ * Billing's. Only an account with no plan and money in its balance sees the
+ * balance, because that balance is what it spends.
+ */
+import { SizableText, XStack, YStack } from '@hanzo/gui';
+import { money } from './api/billing.js';
+import { left, rows } from './standing.js';
+import { when } from './plan.js';
+/** The ink a share is said in: quiet until it is close, and the one red when it is used. */
+export const INK = { ok: '$soft', near: '$yellow10', limited: '$red10' };
+/** A plan's name with its rung beside it, small: `Max` `20x`. */
+export function Title({ label, size = '$3' }) {
+    return (_jsxs(XStack, { items: "baseline", gap: "$1.5", minW: 0, "data-slot": "plan-name", children: [_jsx(SizableText, { size: size, color: "$ink", style: { fontWeight: 600 }, numberOfLines: 1, children: label.name }), label.tag ? (_jsx(SizableText, { size: "$1", color: "$soft", px: "$1.5", rounded: "$2", borderWidth: 1, borderColor: "$borderColor", "data-slot": "plan-tag", children: label.tag })) : null] }));
+}
+/** A quiet text button. */
+function Act({ label, onPress }) {
+    return (_jsx(XStack, { render: "button", "aria-label": label, onPress: onPress, px: "$2", py: "$1", rounded: "$2", hoverStyle: { bg: '$hover' }, cursor: "pointer", shrink: 0, children: _jsx(SizableText, { size: "$1", color: "$ink", textDecorationLine: "underline", children: label }) }));
+}
+/** The standing, drawn: what `Meter` shows once it has read. */
+export function Reading({ s, onPlans, onBilling, now }) {
+    const windows = s.kind === 'plan' ? rows(s.limits, now) : [];
+    const share = s.kind === 'free' ? left(s.allowance) : null;
+    const resets = s.allowance ? when(s.allowance.resets, now) : '';
+    return (_jsxs(YStack, { px: "$2", py: "$1.5", gap: "$1", "data-slot": "meter", "data-kind": s.kind, children: [_jsxs(XStack, { items: "center", gap: "$2", minW: 0, children: [_jsx(XStack, { flex: 1, minW: 0, children: s.label ? _jsx(Title, { label: s.label }) : null }), s.kind === 'free' ? _jsx(Act, { label: "Upgrade", onPress: onPlans }) : s.kind === 'credits' ? _jsx(Act, { label: "Add funds", onPress: onBilling }) : null] }), windows.map((w) => (_jsxs(XStack, { items: "baseline", gap: "$2", "data-slot": "meter-window", "data-state": w.state, children: [_jsx(SizableText, { size: "$1", color: "$soft", width: 56, shrink: 0, children: w.name }), _jsxs(SizableText, { size: "$1", color: INK[w.state], style: { fontVariantNumeric: 'tabular-nums' }, shrink: 0, children: [w.percent, "%"] }), _jsx(SizableText, { size: "$1", color: "$soft", flex: 1, minW: 0, numberOfLines: 1, text: "right", children: w.resets })] }, w.name))), s.kind === 'free' && share !== null ? (_jsx(SizableText, { size: "$1", color: share === 0 ? '$red10' : '$soft', "data-slot": "meter-free", children: `${share}% of today’s free usage left${resets ? ` · Resets ${resets}` : ''}` })) : null, s.kind === 'credits' && s.balance !== null ? (_jsx(SizableText, { size: "$1", color: "$soft", "data-slot": "meter-balance", children: `${money(s.balance)} in credits` })) : null] }));
+}
+/**
+ * The block an account menu leads with: `read` is `useStanding`, asked while
+ * the menu is open. `onPlans` opens the plans and `onBilling` the page credits
+ * live on; the host says where each is.
+ */
+export function Meter({ read, onPlans, onBilling }) {
+    if (read.value)
+        return _jsx(Reading, { s: read.value, onPlans: onPlans, onBilling: onBilling });
+    return (_jsx(SizableText, { size: "$1", color: "$soft", px: "$2", py: "$1.5", "data-slot": "meter", children: read.error ? 'Your plan could not be read.' : 'Reading your plan…' }));
+}

package/lib/mind.d.ts

@@ -0,0 +1,60 @@
+import { type Target } from './api/call.ts';
+import { type Model } from './api/models.ts';
+export type Effort = 'low' | 'medium' | 'high';
+export declare const EFFORTS: readonly {
+    id: Effort;
+    label: string;
+    note: string;
+}[];
+/** What a person chose: the model (Enso routes) and the effort. */
+export interface Choice {
+    model: string;
+    effort: Effort;
+}
+export declare const FIRST: Choice;
+/** The kept choice, Enso and Medium where nothing is kept. Stable while the stored text is. */
+export declare function kept(): Choice;
+/** Keep a change, in this browser, for every surface that reads it. */
+export declare function keep(patch: Partial<Choice>): void;
+/** The kept choice and the way to change it. The server and the first render read the default. */
+export declare function useChoice(): readonly [Choice, (patch: Partial<Choice>) => void];
+/** Whether `model` takes an effort: the router and an undescribed model do, a listed one only if it reasons. */
+export declare function reasons(model: string, catalog: readonly Model[]): boolean;
+/** A model's name as the catalog spells it; Enso for the router. */
+export declare function nameOf(model: string, catalog: readonly Model[]): string;
+/** `GET /v1/models` for a target, asked once and shared; a refusal is not kept, so the next ask goes again. */
+export declare function catalog(t: Target): Promise<Model[]>;
+/** The catalog as a chooser draws it, and the list a kept pick is judged against. */
+export interface Catalog {
+    /** What the chooser offers: the list read, else the last one this browser kept, else Enso alone. */
+    models: Model[];
+    /** What was read, for a pick to stand on: empty when nothing was, so a kept pick stands. */
+    list: Model[];
+    loading: boolean;
+    /** Why there is no list to offer, in a reader's words; null when there is one. */
+    error: string | null;
+    /** A list shown from before, because this read failed. */
+    note: string;
+}
+/**
+ * The platform's catalog, as a hook: what was read already is there on the
+ * first render. The gateway answers 429 once the org's quota is spent, and a
+ * list that vanishes then leaves nothing to choose from, so a failed read shows
+ * the last list this browser kept, with a note; with none kept, Enso alone, and
+ * the reason in the chooser — never the platform's own words.
+ */
+export declare function useCatalog(t: Target): Catalog;
+/** The chip's whole state: the catalog, what answers next, and how to change either. */
+export interface Mind {
+    model: string;
+    effort: Effort;
+    models: Model[];
+    loading: boolean;
+    error: string | null;
+    /** A list shown from before, because this read failed. */
+    note: string;
+    /** A premium pick holds for this screen; any other is kept. */
+    pick: (id: string) => void;
+    pace: (effort: Effort) => void;
+}
+export declare function useMind(t: Target): Mind;