@hanzo/build 0.2.59 → 0.2.61

package/lib/suggest.js

@@ -0,0 +1,329 @@
+export const ICONS = ['github', 'agent', 'chat', 'file', 'task'];
+/** Hanzo's model the rows are asked of: it decodes under a strict JSON schema at api.hanzo.ai. */
+export const MODEL = 'zen5-flash';
+/** At most this many rows. */
+export const MOST = 3;
+const HOUR = 3_600_000;
+/** Rows this old are made again whatever happened. */
+export const DAY = 24 * HOUR;
+/** Rows younger than this are kept even when the activity has moved. */
+export const QUIET = HOUR;
+/** How many dismissals are remembered. */
+export const REMEMBER = 100;
+/** How many of each source the model reads. */
+export const TAKE = { conversation: 8, issue: 6, pull: 4, run: 6, automation: 4, file: 4 };
+const str = (v) => (typeof v === 'string' ? v : '');
+const obj = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : {});
+/** One line, at most `n` characters. */
+export function line(v, n) {
+    const s = str(v).replace(/\s+/g, ' ').trim();
+    return s.length > n ? `${s.slice(0, n - 1).trimEnd()}…` : s;
+}
+/** An https address, or ''. A row links to nothing else. */
+export function https(v) {
+    try {
+        const u = new URL(str(v));
+        return u.protocol === 'https:' ? u.href : '';
+    }
+    catch {
+        return '';
+    }
+}
+/** cyrb53: a 53-bit string hash, as 14 hex digits. A fingerprint, never a secret. */
+export function hash(s) {
+    let h1 = 0xdeadbeef;
+    let h2 = 0x41c6ce57;
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        h1 = Math.imul(h1 ^ c, 2654435761);
+        h2 = Math.imul(h2 ^ c, 1597334677);
+    }
+    h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+    h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+    return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16).padStart(14, '0');
+}
+const time = (iso) => {
+    const t = Date.parse(iso);
+    return Number.isFinite(t) ? t : 0;
+};
+/** The first line of a text. */
+const first = (s) => s.split('\n').find((l) => l.trim()) ?? '';
+/** The person's activity as inputs: their own runs only, each kind's newest `TAKE`. */
+export function inputs(a) {
+    const all = [
+        ...a.conversations.map((c) => ({ kind: 'conversation', key: c.id, title: c.title, state: '', text: '', href: '', updated: c.updated })),
+        ...a.issues.map((i) => ({
+            kind: i.pull ? 'pull' : 'issue',
+            key: i.key,
+            title: i.title,
+            state: i.state === 'closed' ? 'closed' : i.status || 'open',
+            text: [i.repo || i.forge || i.board, first(i.body)].filter(Boolean).join(': '),
+            href: https(i.url),
+            updated: i.updated,
+        })),
+        ...a.runs
+            .filter((r) => a.me && r.actor === a.me)
+            .map((r) => ({
+            kind: 'run',
+            key: r.id,
+            title: r.title,
+            state: r.status,
+            text: [r.repo, r.branch].filter(Boolean).join(' @ '),
+            href: https(r.pr),
+            updated: r.updatedAt || r.createdAt,
+        })),
+        ...a.automations
+            .filter((x) => !x.draft)
+            .map((x) => ({
+            kind: 'automation',
+            key: x.id,
+            title: x.name,
+            state: x.last?.status || (x.enabled ? 'on' : 'off'),
+            text: x.last?.summary || first(x.instructions),
+            href: '',
+            updated: x.last?.at || x.updated,
+        })),
+        ...a.files.map((f) => ({ kind: 'file', key: f.id, title: f.name, state: f.kind, text: f.source, href: '', updated: f.updated || f.created })),
+    ];
+    return pick(all);
+}
+/**
+ * The seed: what the account's preferences say (`callName`, `work`,
+ * `instructions` in /v1/pref) and what signup kept on the IAM user (`onboarding`
+ * in /v1/iam/preferences: the role picked, and personal, team or enterprise).
+ */
+export function seed(p, iam) {
+    const o = obj(obj(iam).onboarding);
+    const out = {
+        name: line(p.callName, 60),
+        work: line(p.work, 240),
+        role: line(o.role, 80),
+        use: line(o.use, 20),
+        instructions: line(p.instructions, 400),
+    };
+    return Object.fromEntries(Object.entries(out).filter(([, v]) => v));
+}
+/** Each kind's newest `TAKE`, newest first overall. */
+export function pick(all) {
+    const out = [];
+    for (const kind of Object.keys(TAKE)) {
+        out.push(...all
+            .filter((i) => i.kind === kind && i.title)
+            .sort((a, b) => time(b.updated) - time(a.updated))
+            .slice(0, TAKE[kind]));
+    }
+    return out.sort((a, b) => time(b.updated) - time(a.updated));
+}
+/**
+ * The fingerprint of what the rows are made from: each input's identity and
+ * state, and the seed. A new conversation, a closed issue or a finished run
+ * moves it; another turn in a conversation already read does not.
+ */
+export function sig(inputs, seed) {
+    const lines = inputs.map((i) => `${i.kind}\t${i.key}\t${i.state}`).sort();
+    const s = [seed.name, seed.work, seed.role, seed.use, seed.instructions].map((x) => x ?? '').join('\t');
+    return hash(`${lines.join('\n')}\n--\n${s}`);
+}
+/** Whether rows kept at `kept` are to be made again, now that the inputs read as `now`. */
+export function due(kept, fingerprint, now) {
+    if (!kept)
+        return true;
+    const age = now - time(kept.at);
+    if (!time(kept.at) || age < 0 || age >= DAY)
+        return true;
+    return kept.sig !== fingerprint && age >= QUIET;
+}
+/** Whether anything newer could change kept rows yet: false while they are younger than `QUIET`. */
+export function stale(kept, now) {
+    if (!kept)
+        return true;
+    const age = now - time(kept.at);
+    return !time(kept.at) || age < 0 || age >= QUIET;
+}
+/** The icon a row about `i` carries: GitHub's mark only for GitHub's own address. */
+export function iconOf(i) {
+    switch (i.kind) {
+        case 'conversation':
+            return 'chat';
+        case 'issue':
+        case 'pull':
+            return /^https:\/\/github\.com\//.test(i.href) ? 'github' : 'task';
+        case 'run':
+        case 'automation':
+            return 'agent';
+        case 'file':
+            return 'file';
+    }
+}
+/** The answer's shape, decoded strictly by the model. */
+export const SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['rows'],
+    properties: {
+        rows: {
+            type: 'array',
+            maxItems: MOST,
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['icon', 'title', 'href', 'summary', 'action', 'prompt'],
+                properties: {
+                    icon: { type: 'string', enum: [...ICONS] },
+                    title: { type: 'string' },
+                    href: { type: 'string' },
+                    summary: { type: 'string' },
+                    action: { type: 'string' },
+                    prompt: { type: 'string' },
+                },
+            },
+        },
+    },
+};
+const SYSTEM = [
+    'You choose up to three next steps for one person, from their own recent activity, to show under the box where they type to Hanzo.',
+    'Each row names something that happened and the step it calls for. Pick what is most worth their attention now: something that landed and needs checking, something open and urgent, something they were in the middle of.',
+    'Fields:',
+    '- title: what happened, at most 6 words, naming the thing ("Hanzo app login fixes landed", "Kai P0 mapping bug is open").',
+    '- action: the next step, imperative, at most 6 words ("Verify the user flow").',
+    '- summary: one to three plain sentences of what the source says. Only facts from the input; never invent numbers, names or dates.',
+    '- prompt: the message the person would send Hanzo to do the step, first person, complete on its own, naming the source and its address when it has one.',
+    '- href: copied exactly from the input the row is about, or "" when that input has none. Never write an address that is not in the input.',
+    '- icon: github for a github.com address, agent for a run or an automation, chat for a conversation, file for a file, task for any other issue or task.',
+    'With no activity, suggest from what the person told us at signup (their role, their work): first things to ask Hanzo, with href "".',
+    'Never repeat an item listed under skip. Never suggest the same item twice.',
+    'If nothing is worth saying, answer {"rows": []}. Fewer good rows beat three weak ones.',
+].join('\n');
+/** The chat completion that asks for rows, or null when there is nothing to make them from. */
+export function request(inputs, seed, skip, now) {
+    const person = Object.fromEntries(Object.entries(seed).filter(([, v]) => typeof v === 'string' && v.trim()));
+    if (!inputs.length && !Object.keys(person).length)
+        return null;
+    const activity = inputs.map((i) => ({
+        kind: i.kind,
+        title: line(i.title, 140),
+        ...(i.state ? { state: i.state } : {}),
+        ...(i.text ? { text: line(i.text, 240) } : {}),
+        href: i.href,
+        ...(i.updated ? { updated: i.updated.slice(0, 10) } : {}),
+    }));
+    return {
+        model: MODEL,
+        messages: [
+            { role: 'system', content: SYSTEM },
+            { role: 'user', content: JSON.stringify({ today: now.toISOString().slice(0, 10), person, activity, skip }) },
+        ],
+        response_format: { type: 'json_schema', json_schema: { name: 'suggestions', strict: true, schema: SCHEMA } },
+        max_tokens: 1200,
+        temperature: 0.3,
+    };
+}
+/** The first JSON object in a model's text: all of it, or from its first `{` to its last `}`. */
+function json(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        const a = text.indexOf('{');
+        const b = text.lastIndexOf('}');
+        if (a < 0 || b <= a)
+            return null;
+        try {
+            return JSON.parse(text.slice(a, b + 1));
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/** The text of a chat completion's first choice, or ''. */
+export function content(raw) {
+    const choices = obj(raw).choices;
+    const first = obj(Array.isArray(choices) ? choices[0] : null);
+    return str(obj(first.message).content);
+}
+/** A row's id: its address, or for a row without one, its title. */
+export const idOf = (href, title) => hash(href || title.toLowerCase());
+/**
+ * The rows of a chat completion, validated: each with every field, an address
+ * that is one of the inputs' own (or none), its icon from that input, one row
+ * per source, at most `MOST`. Anything else is dropped, never repaired.
+ */
+export function answer(raw, inputs) {
+    const by = new Map(inputs.filter((i) => i.href).map((i) => [i.href, i]));
+    const rows = obj(json(content(raw))).rows;
+    const out = [];
+    for (const r of Array.isArray(rows) ? rows : []) {
+        const o = obj(r);
+        const title = line(o.title, 80);
+        const action = line(o.action, 80).replace(/\.$/, '');
+        const prompt = str(o.prompt).trim().slice(0, 2000);
+        if (!title || !action || !prompt)
+            continue;
+        const said = str(o.href).trim();
+        const source = said ? by.get(said) : undefined;
+        if (said && !source)
+            continue;
+        // GitHub's mark only beside GitHub's own address: a row without one is a task at most.
+        const named = ICONS.includes(o.icon) ? o.icon : 'chat';
+        const icon = source ? iconOf(source) : named === 'github' ? 'task' : named;
+        const id = idOf(said, title);
+        if (out.some((x) => x.id === id))
+            continue;
+        out.push({ id, icon, title: title.replace(/\.$/, ''), href: said, summary: line(o.summary, 600), action, prompt });
+        if (out.length === MOST)
+            break;
+    }
+    return out;
+}
+/** One kept row, or null for one that does not read as a row. */
+function row(raw) {
+    const o = obj(raw);
+    const title = str(o.title);
+    const action = str(o.action);
+    const prompt = str(o.prompt);
+    const href = str(o.href);
+    if (!title || !action || !prompt || (href && https(href) !== href))
+        return null;
+    return {
+        id: str(o.id) || idOf(href, title),
+        icon: ICONS.includes(o.icon) ? o.icon : 'chat',
+        title,
+        href,
+        summary: str(o.summary),
+        action,
+        prompt,
+    };
+}
+/** The `suggest` key of the preference document, or undefined when it holds none. */
+export function kept(raw) {
+    const o = obj(raw);
+    if (!Object.keys(o).length)
+        return undefined;
+    return {
+        at: str(o.at),
+        sig: str(o.sig),
+        rows: (Array.isArray(o.rows) ? o.rows : []).map(row).filter((r) => r !== null).slice(0, MOST),
+        dismissed: (Array.isArray(o.dismissed) ? o.dismissed : []).filter((x) => typeof x === 'string' && x !== '').slice(0, REMEMBER),
+    };
+}
+/** The rows to draw: those not dismissed. */
+export const shown = (k) => (k ? k.rows.filter((r) => !k.dismissed.includes(r.id)).slice(0, MOST) : []);
+/** `k` with `id` dismissed: remembered first, the oldest forgotten past `REMEMBER`. */
+export function dismissed(k, id) {
+    return { ...k, dismissed: [id, ...k.dismissed.filter((x) => x !== id)].slice(0, REMEMBER) };
+}
+/** The addresses and titles of dismissed rows the model is told to skip. */
+export function skip(k, inputs) {
+    if (!k)
+        return [];
+    const gone = new Set(k.dismissed);
+    const out = new Set();
+    for (const i of inputs)
+        if (i.href && gone.has(idOf(i.href, '')))
+            out.add(i.href);
+    for (const r of k.rows)
+        if (gone.has(r.id))
+            out.add(r.href || r.title);
+    return [...out];
+}

package/lib/suggestions.d.ts

@@ -0,0 +1,20 @@
+import { type Target } from './api/call.ts';
+import { type Suggestion } from './suggest.ts';
+export interface Suggested {
+    /** The rows to draw: at most three, none dismissed. */
+    rows: Suggestion[];
+    /** Dismiss one, remembered by the account. */
+    dismiss: (id: string) => void;
+    /** Why the rows could not be read, made or kept, in the platform's words. */
+    error: string | null;
+}
+/** The person's suggestions. Signed out, or with nothing worth saying, there are none. */
+export declare function useSuggestions(t: Target): Suggested;
+export interface SuggestionsProps {
+    rows: readonly Suggestion[];
+    /** A row was chosen: its prompt, for the composer. */
+    onPick: (prompt: string) => void;
+    onDismiss: (id: string) => void;
+}
+/** The rows, or nothing when there are none. */
+export declare function Suggestions({ rows, onPick, onDismiss }: SuggestionsProps): import("react").JSX.Element | null;

package/lib/suggestions.js

@@ -0,0 +1,170 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The suggestions under the composer (above it on a phone): up to three rows,
+ * each the source's mark, what happened linked to where it happened (its
+ * summary on hover or focus), then the next step. Choosing a row puts its
+ * prompt in the composer; its × dismisses it, and the account remembers.
+ *
+ * `useSuggestions` reads the kept rows from the account (`suggest` in /v1/pref)
+ * and, when they are due (suggest.ts `due`), reads the person's activity and
+ * asks Hanzo's model for new ones. One document per page, read once per person
+ * and org, shared by every composer on it.
+ *
+ *   GET  /v1/pref                         the kept rows, and callName, work, instructions
+ *   GET  /v1/agents/chat/conversations    their conversations
+ *   GET  /v1/task/board                   the org's issues and pull requests
+ *   GET  /v1/agent/sessions?limit=20      Dev runs; their own are read
+ *   GET  /v1/auto/automations             automations
+ *   GET  /v1/library?scope=mine           their files
+ *   POST /v1/iam/preferences {}           what signup kept (`onboarding`)
+ *   POST /v1/chat/completions             the rows, as `MODEL` writes them
+ *   PATCH /v1/pref {suggest}              the rows kept, and each dismissal
+ */
+import { SizableText, useMedia, XStack, YStack } from '@hanzo/gui';
+import { ArrowUpRight, Bot, CalendarClock, FileText, Github, MessageSquare, X } from '@hanzogui/lucide-icons-2';
+import { HoverCard, HoverCardContent, HoverCardTrigger } from '@hanzo/ui';
+import { useCallback, useEffect, useMemo, useState, useSyncExternalStore } from 'react';
+import { automations } from './api/auto.js';
+import { call, Refusal, unwrap } from './api/call.js';
+import { conversations } from './api/conversations.js';
+import { items } from './api/library.js';
+import { read, save } from './api/pref.js';
+import { list } from './api/sessions.js';
+import { everything } from './api/work.js';
+import { claims } from './claims.js';
+import { Out } from './out.js';
+import { answer, dismissed, due, inputs, request, seed, shown, sig, skip, stale, TAKE } from './suggest.js';
+/** A source that refuses this person (a 4xx other than an expired sign-in or a rate) has nothing for them; any other failure leaves it unknown. */
+function soft(p, none) {
+    return p.catch((e) => {
+        if (e instanceof Refusal && e.status >= 400 && e.status < 500 && e.status !== 401 && e.status !== 429)
+            return none;
+        throw e;
+    });
+}
+/** The person's activity and seed, or null when a source could not be read: rows are never made from half of it. */
+async function gather(t, p) {
+    const c = claims(t.token());
+    const me = typeof c?.owner === 'string' && typeof c?.sub === 'string' ? `${c.owner}/${c.sub}` : '';
+    try {
+        const [cs, is, rs, as, fs, iam] = await Promise.all([
+            soft(conversations(t), []),
+            soft(everything(t), []),
+            soft(list(t, { limit: 20 }), []),
+            soft(automations(t), []),
+            soft(items(t, { scope: 'mine', limit: TAKE.file }).then((page) => page.data), []),
+            soft(call(t, 'POST', '/v1/iam/preferences', {}).then(unwrap), {}),
+        ]);
+        return { inputs: inputs({ conversations: cs, issues: is, runs: rs, automations: as, files: fs, me }), seed: seed(p, iam) };
+    }
+    catch {
+        return null;
+    }
+}
+// One document per page: the kept rows of whoever `loaded` names.
+let doc = null;
+let loaded = null;
+const listeners = new Set();
+const emit = () => listeners.forEach((f) => f());
+const subscribe = (f) => {
+    listeners.add(f);
+    return () => listeners.delete(f);
+};
+/** Read the kept rows, and make new ones when they are due. Each await checks it still speaks for `id`. */
+async function refresh(t, id) {
+    const p = await read(t);
+    if (loaded !== id)
+        return;
+    doc = p.suggest ?? null;
+    emit();
+    if (!stale(doc, Date.now()))
+        return;
+    const got = await gather(t, p);
+    if (loaded !== id || !got)
+        return;
+    const fingerprint = sig(got.inputs, got.seed);
+    if (!due(doc, fingerprint, Date.now()))
+        return;
+    const ask = request(got.inputs, got.seed, skip(doc, got.inputs), new Date());
+    const rows = ask ? answer(await call(t, 'POST', '/v1/chat/completions', ask), got.inputs) : [];
+    if (loaded !== id)
+        return;
+    // Dismissals made while the model wrote are the latest document's.
+    const gone = doc?.dismissed ?? [];
+    doc = { at: new Date().toISOString(), sig: fingerprint, rows: rows.filter((r) => !gone.includes(r.id)), dismissed: gone };
+    emit();
+    await save(t, { suggest: doc });
+}
+/** Whose rows: the platform, the org and the person. Signed out is nobody, and has none. */
+const whose = (t) => {
+    const token = t.token();
+    if (!token)
+        return '';
+    const sub = claims(token)?.sub;
+    return `${t.api}|${t.org ?? ''}|${typeof sub === 'string' ? sub : ''}`;
+};
+function load(t) {
+    const id = whose(t);
+    if (loaded === id)
+        return Promise.resolve();
+    loaded = id;
+    doc = null;
+    emit();
+    return id ? refresh(t, id) : Promise.resolve();
+}
+const said = (e) => (e instanceof Error && e.message ? e.message : 'Suggestions could not be read.');
+/** The person's suggestions. Signed out, or with nothing worth saying, there are none. */
+export function useSuggestions(t) {
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        load(t).then(() => setError(null), (e) => setError(said(e)));
+    }, [t]);
+    const now = useSyncExternalStore(subscribe, () => doc, () => doc);
+    const rows = useMemo(() => shown(now), [now]);
+    const dismiss = useCallback((id) => {
+        if (!doc)
+            return;
+        doc = dismissed(doc, id);
+        emit();
+        if (t.token())
+            save(t, { suggest: doc }).then(() => setError(null), (e) => setError(said(e)));
+    }, [t]);
+    return useMemo(() => ({ rows, dismiss, error }), [rows, dismiss, error]);
+}
+const MARKS = {
+    github: Github,
+    agent: Bot,
+    chat: MessageSquare,
+    file: FileText,
+    task: CalendarClock,
+};
+/** The row's pitch, px: a finger's on a phone, and the same at a desk. */
+const PITCH = 44;
+/** The rows, or nothing when there are none. */
+export function Suggestions({ rows, onPick, onDismiss }) {
+    // A phone has no hover: its × stays in sight.
+    const touch = !useMedia().sm;
+    if (!rows.length)
+        return null;
+    return (_jsx(YStack, { role: "list", "aria-label": "Suggestions", "data-slot": "suggestions", children: rows.map((r) => (_jsx(Row, { row: r, touch: touch, onPick: onPick, onDismiss: onDismiss }, r.id))) }));
+}
+/**
+ * One row. The whole row is one button, laid under the row's content (which is
+ * positioned after it, so it paints above, and lets presses through), and over
+ * it the title's link and the × are their own: three stops for the keyboard,
+ * none inside another.
+ */
+function Row({ row, touch, onPick, onDismiss }) {
+    const [near, setNear] = useState(false);
+    const Mark = MARKS[row.icon];
+    return (_jsxs(XStack, { role: "listitem", "data-slot": "suggestion", position: "relative", items: "center", gap: "$3", minH: PITCH, px: "$3", rounded: "$4", hoverStyle: { bg: '$hover' }, onPointerEnter: () => setNear(true), onPointerLeave: () => setNear(false), children: [_jsx(YStack, { render: "button", "aria-label": `${row.title}. ${row.action}`, onPress: () => onPick(row.prompt), position: "absolute", t: 0, r: 0, b: 0, l: 0, rounded: "$4", cursor: "pointer", focusVisibleStyle: { outlineWidth: 2, outlineStyle: 'solid', outlineColor: '$outlineColor' } }), _jsxs(XStack, { position: "relative", flex: 1, minW: 0, items: "center", gap: "$3", pointerEvents: "none", children: [_jsx(Mark, { size: 18, color: "$soft" }), _jsxs(XStack, { flex: 1, minW: 0, items: "center", children: [_jsx(Title, { row: row }), _jsx(SizableText, { fontSize: 15, color: "$soft", numberOfLines: 1, shrink: 1, minW: 0, children: `. ${row.action}` })] })] }), _jsx(XStack, { render: "button", "aria-label": `Dismiss ${row.title}`, position: "relative", onPress: () => onDismiss(row.id), p: "$1.5", rounded: "$2", cursor: "pointer", opacity: touch || near ? 1 : 0, hoverStyle: { bg: '$hover' }, focusVisibleStyle: { opacity: 1, outlineWidth: 2, outlineStyle: 'solid', outlineColor: '$outlineColor' }, children: _jsx(X, { size: 16, color: "$soft" }) })] }));
+}
+/** What happened, linked to its source with a ↗ when it has one, its summary in a card above it. It keeps its words before the step does, up to 70% of the line. */
+function Title({ row }) {
+    const words = (_jsx(SizableText, { fontSize: 15, color: "$soft", numberOfLines: 1, textDecorationLine: row.href ? 'underline' : 'none', textDecorationStyle: "dotted", children: row.title }));
+    const text = row.href ? (_jsxs(Out, { href: row.href, label: `${row.title}, opens the source`, children: [words, _jsx(ArrowUpRight, { size: 12, color: "$soft" })] })) : (words);
+    if (!row.summary) {
+        return (_jsx(XStack, { shrink: 0, maxW: "70%", minW: 0, pointerEvents: "auto", children: text }));
+    }
+    return (_jsxs(HoverCard, { openDelay: 300, closeDelay: 150, children: [_jsx(HoverCardTrigger, { shrink: 0, maxW: "70%", minW: 0, pointerEvents: "auto", children: text }), _jsx(HoverCardContent, { side: "top", align: "start", sideOffset: 8, width: 470, maxW: "calc(100vw - 32px)", rounded: "$6", p: "$4", children: _jsx(SizableText, { fontSize: 16, lineHeight: 26, color: "$ink", children: row.summary }) })] }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanzo/build",
-  "version": "0.2.59",
+  "version": "0.2.61",
   "type": "module",
   "license": "Apache-2.0 OR MIT",
   "description": "Hanzo Build — say what you want, watch it built, deployed and running. The builder as a component, mounted by the Hanzo app at hanzo.ai.",
@@ -12,7 +12,7 @@
     "@hanzo/font": "1.9.3",
     "@hanzo/gui": "8.3.5",
     "@hanzo/iam": "0.21.28",
-    "@hanzo/ui": "8.27.77",
+    "@hanzo/ui": "8.29.0",
     "@hanzo/vite": "0.1.4",
     "@hanzo/voice": "0.1.18",
     "@hanzogui/lucide-icons-2": "8.3.5",

package/lib/grip.d.ts

@@ -1,40 +0,0 @@
-/**
- * A column's free edge, which is also how wide the column is: a vertical
- * separator a person drags, or moves with the arrow keys, to size the column
- * beside it. The project workspace sizes its chat with it, and a host sizes its
- * own column with it (the Hanzo app's sidebar).
- *
- *   side      the edge of the window the column is pinned to: `left` grows
- *             rightwards (a sidebar, the chat), `right` grows leftwards (an
- *             aside). One control for both, the arithmetic reflected.
- *   span      the column's width now, px; `floor` and `ceil` bound it.
- *   onSpan    the width while it moves, at most once a frame.
- *   onKeep    the width it settled on: a drag let go, a key, a double-click.
- *   onShut    when given, a drag pulled well past the floor, or a key pressed
- *             at it, puts the column away; absent, the floor holds.
- *   reset     the width a double-click returns to.
- *
- * Keys: the arrows step 8px (32px with Shift), Home and End go to the floor and
- * the ceiling. Pointer events, so a mouse, a trackpad, a touchscreen and a pen
- * are one path, with the pointer captured: a drag that outruns the handle, or
- * crosses a framed page, keeps sizing. The drag is measured from the column as
- * drawn when it begins, so the edge never jumps to the cursor.
- *
- * It sits inside the column, absolutely, on the column's free edge; the rest of
- * its props place it elsewhere (a gutter beside the column) and win.
- */
-import { YStack } from '@hanzo/gui';
-import { type ComponentProps } from 'react';
-export interface GripProps extends Omit<ComponentProps<typeof YStack>, 'children'> {
-    side: 'left' | 'right';
-    span: number;
-    floor: number;
-    ceil: number;
-    reset: number;
-    onSpan: (n: number) => void;
-    onKeep?: (n: number) => void;
-    onShut?: () => void;
-    /** The separator's accessible name: "Resize sidebar", "Resize the chat". */
-    label: string;
-}
-export declare function Grip({ side, span, floor, ceil, reset, onSpan, onKeep, onShut, label, ...rest }: GripProps): import("react").JSX.Element;