@openagt/dashboard 0.8.0 → 0.10.0

package/dist/widget-types/src/store/provided.d.ts

@@ -1,16 +0,0 @@
-/**
- * A package's command just ran in the project at `root` (a widget's, through the dashboard), and
- * may have written what one of the framework's provided readers caches: every provided reader
- * forgets that project, so its next read runs the provider again. The framework never knows which
- * command writes what; forgetting is cheap and re-reading is what it does anyway.
- */
-export declare function providedDataChanged(root: string): void;
-/** The kinds of the framework's data a project's package may provide, one reader each (`git-host` is `git-host.ts`). */
-export declare const PROVIDED_KINDS: readonly ['tickets', 'queue', 'runs', 'branches', 'git-host'];
-/**
- * Why a kind of the project's data has no provider although packages declare it (#1820): two or
- * more declare the kind and the project's package.json names none, or names one that does not
- * declare it. One sentence per such kind, for the project's error banner; none when every kind is
- * settled. Nobody declaring a kind is not a problem: the project has none of that data.
- */
-export declare function providerProblems(root: string): Promise<string[]>;

package/dist/widget-types/src/store/queue.d.ts

@@ -1,45 +0,0 @@
-/**
- * The agent queue, as the framework reads it (#1774). The framework keeps no queue and imports no
- * queue package: a project's queue comes from whichever of its packages declares that it provides
- * it — `"framework": { "queue": "<command>" }` in the package's own package.json — and the
- * framework reads it by running that command. Swap the package for another that answers the same
- * command line and prints the same shape, and nothing here changes. No package declares it: the
- * project has no queue, and the dashboard shows it none.
- *
- * The command line a provider answers, printing one JSON document and exiting 0:
- *   `<command> --local`   the open entries, in order of work, as an array of strings
- * `--local` reads the copy on this machine, no network: the framework polls.
- *
- * That is the whole contract. Writing the queue is not the framework's: a widget the queue package
- * brings acts on it through its own command (`framework/widget`'s link actions), and the framework
- * only re-reads.
- *
- * The shape, owned here: an entry is one string, the task a future agent is started with, as the
- * queue's own command prints it. A markdown link at its start names the work and where it points;
- * how a dashboard reads that is the queue package's widget's.
- */
-/** A project's queue: what a provider answers, read by the framework. */
-export interface QueueSource {
-    /** The open entries, in order of work; `[]` when none can be read. */
-    list(): Promise<string[]>;
-}
-/** The queue of the project at `root`, or `undefined` when none of its packages provides one. */
-export type QueueFor = (root: string) => Promise<QueueSource | undefined>;
-/** A {@link QueueFor} that also forgets what it read of one project, for when a widget just wrote there. */
-export type QueueReader = QueueFor & {
-    changed(root: string): void;
-};
-/** Entries read back from a provider's output: the non-empty strings of an array, trimmed; anything else is no entries. */
-export declare function parseQueueEntries(output: unknown): string[];
-/**
- * The production {@link QueueReader}: the project's provider, looked up by its package.json, one
- * source per project kept while the same command provides — so the cache holds across the many
- * reads of one poll, and a project that installs, swaps or drops its provider is read the new way
- * within {@link CACHE_MS}. `changed(root)` forgets that project's read, so the next read runs the
- * command again: a widget's command just ran there, and may have written.
- */
-export declare function providedQueue(now?: () => number): QueueReader;
-/** The framework's one reader of the queue, shared by every caller so they share its cache. */
-export declare const projectQueue: QueueReader;
-/** A {@link QueueFor} for a project with no provider: no queue. */
-export declare const noQueue: QueueFor;

package/dist/widget-types/src/store/run-record.d.ts

@@ -1,21 +0,0 @@
-import type { AnyDiaryLine, RunCard } from './runs.js';
-import type { FrameworkEvent } from '../events.js';
-import type { AgentMeta } from './agent-store.js';
-/**
- * A run's card and diary (`runs.ts`), read as the framework's own shapes (#1769): the card as the
- * meta every list shows, the diary as the events the run page replays and tails. The card's
- * eleven plain fields and four kinds of diary line are the shape; whoever ran the agent keeps the
- * rest of what it knows under one key, `caller`, and writes its other lines as they are. The
- * framework records no run of its own (#1774), so there is no writing half.
- */
-/** A card as the framework's meta: `caller` unfolded, the card's own fields winning. */
-export declare function fromRunCard(card: RunCard): AgentMeta;
-/**
- * One diary line as one framework event: what the agent said, its result, the run's end and its
- * cost are the shape's four kinds; a line of any other kind is a framework event as written, and
- * one whose kind is no longer an event (the kinds of runs recorded before The Framework stopped
- * running agents) reads as nothing. The line's time, `at`, is the event's, whatever the kind.
- */
-export declare function fromDiaryLine(line: AnyDiaryLine): FrameworkEvent | undefined;
-/** A diary as the run's events, for a reader that replays them. */
-export declare function eventsOf(lines: readonly AnyDiaryLine[]): FrameworkEvent[];

package/dist/widget-types/src/store/runs.d.ts

@@ -1,101 +0,0 @@
-/**
- * Finished runs, as the framework reads them (#1774). The framework keeps no run and imports no
- * records package: a project's finished runs come from whichever of its packages declares that it
- * provides them — `"framework": { "runs": "<command>" }` in the package's own package.json — and
- * the framework reads them by running that command. Swap the package for another that answers
- * the same command line and prints the same shapes, and nothing here changes. No package declares
- * it: the project has no finished runs, only the ones still running in a checkout.
- *
- * The command line a provider answers, each printing one JSON document and exiting 0:
- *   `<command> --local --full --limit N`   the runs, newest first, whole cards
- *   `<command> show <id> --local --full`   one run: the whole card plus `diary`, every line
- *   `<command> delete <id>`                remove a run
- *   `<command> patch <id> [--branch <b>] [--pr <n> --pr-url <url>]`   the two late facts
- * `--local` reads the copy on this machine, no network: the framework polls.
- *
- * The shapes, owned here: {@link RunCard} and {@link AnyDiaryLine}. A running agent's own card in
- * its checkout is the same shape, written by the tool that runs it.
- */
-/** How a run stands: still going, or how it ended. */
-export type RunStatus = 'running' | 'done' | 'stopped' | 'failed' | 'waiting';
-/**
- * A run's card: what was asked, where the work went, how it ended, what it cost. `caller` is the
- * bookkeeping of the program that ran the agent (its pid, host, session id, …), one key.
- */
-export interface RunCard {
-    id: string;
-    startedAt: string;
-    endedAt?: string;
-    status: RunStatus;
-    intent?: string;
-    driver?: string;
-    model?: string;
-    branch?: string;
-    pr?: {
-        number: number;
-        url: string;
-    };
-    ticket?: string;
-    cost?: number;
-    caller?: Record<string, unknown>;
-}
-/** The two late facts a finished run's card may still learn: the branch its work landed on, its pull request. */
-export type RunPatch = Partial<Pick<RunCard, 'branch' | 'pr'>>;
-/** One line of a run's diary: a JSON object with a `kind`. */
-export type AnyDiaryLine = {
-    kind: string;
-} & Record<string, unknown>;
-/** A finished run: its card and its whole diary. */
-export interface FinishedRun {
-    card: RunCard;
-    diary: AnyDiaryLine[];
-}
-/** A project's finished runs: what a provider answers, read by the framework. */
-export interface RunsSource {
-    /**
-     * Every finished run's card, newest first; `[]` when none can be read. `fresh` skips a list read
-     * a moment ago: the caller knows the runs changed since.
-     */
-    list(opts?: {
-        fresh?: boolean;
-    }): Promise<RunCard[]>;
-    /** One run with its diary; `undefined` for no such run, or none readable. */
-    show(id: string): Promise<FinishedRun | undefined>;
-    /** Remove a run, or why it could not be. */
-    remove(id: string): Promise<RunsWrite>;
-    /** Set a run's late facts, or why they could not be. */
-    patch(id: string, patch: RunPatch): Promise<RunsWrite>;
-}
-/** What a change to the runs did: done, or the provider's reason it was not. */
-export type RunsWrite = {
-    ok: true;
-} | {
-    ok: false;
-    error: string;
-};
-/** The finished runs of the project at `root`, or `undefined` when none of its packages provides them. */
-export type RunsFor = (root: string) => Promise<RunsSource | undefined>;
-/** A {@link RunsFor} that also forgets what it read of one project, for when a widget just wrote there. */
-export type RunsReader = RunsFor & {
-    changed(root: string): void;
-};
-/** Whether a string can name a run: letters, digits, `-` and `_`, nothing a path can climb out with. */
-export declare function isRunId(id: string): boolean;
-/**
- * A card read back: the fields of the shape, each kept only when it has the right type, plus
- * `caller` as it is. `undefined` for anything that is not a card — not an object, or missing an
- * id, a start or a status. Takes a card's JSON text or an already-parsed value.
- */
-export declare function parseRunCard(input: unknown): RunCard | undefined;
-/**
- * The production {@link RunsFor}: the project's provider, looked up by its package.json, one
- * source per project kept while the same command provides — so the cache holds across the many
- * reads of one poll, and a project that installs, swaps or drops its provider is read the new way
- * within {@link CACHE_MS}. `changed(root)` forgets that project's reads, so the next read runs the
- * command again: a widget's command just ran there, and may have written.
- */
-export declare function providedRuns(now?: () => number): RunsReader;
-/** The framework's one reader of finished runs, shared by every caller so they share its cache. */
-export declare const projectRuns: RunsReader;
-/** A {@link RunsFor} for a project with no provider: no finished runs. */
-export declare const noRuns: RunsFor;

package/dist/widget-types/src/store/tickets.d.ts

@@ -1,72 +0,0 @@
-/**
- * The tickets, as the framework reads them (#1774). The framework keeps no ticket and imports no
- * tickets package: a project's tickets come from whichever of its packages declares that it
- * provides them — `"framework": { "tickets": "<command>" }` in the package's own package.json —
- * and the framework reads them by running that command. Swap the package for another that answers
- * the same command line and prints the same shape, and nothing here changes. No package declares
- * it: the project has no tickets, and the dashboard shows it none.
- *
- * The command line a provider answers, printing one JSON document and exiting 0:
- *   `<command> list --local`   every open ticket, as an array of {@link Ticket}
- * `--local` reads the copy on this machine, no network: the framework polls.
- *
- * That is the whole contract. The framework reads tickets for what it composes across skills: the
- * onboarding step, a queued link's title. Showing them, planning them, claiming and releasing them,
- * and the Overview's hot-tickets card, are the tickets package's own widget, through its own command.
- *
- * The shape, owned here: {@link Ticket}, the row a ticket lists as.
- */
-/** A ticket's row, as a provider prints it. Everything but the five plain facts is optional. */
-export interface Ticket {
-    /** The ticket's file name, its identity: `tickets/<file>` is the path a link to it carries. */
-    file: string;
-    title: string;
-    /** One line of what it is about; empty when the ticket says nothing beyond its title. */
-    summary: string;
-    /** `0`–`10` as written, `10` acting at once; absent when unset, and not checked here. */
-    priority?: string;
-    topics?: string[];
-    /** The issue it tracks in the project's tracker, and the pull request that closes it: a label and where it points. */
-    issue?: {
-        label: string;
-        url: string;
-    };
-    pr?: {
-        label: string;
-        url: string;
-    };
-    /** ISO 8601: the file's date. */
-    date: string;
-    /** Whether a plan sits beside it. */
-    planned: boolean;
-    /** Whether someone holds it, and who: a run's id, or a branch. */
-    locked?: boolean;
-    lockedBy?: string;
-    effort?: number;
-    uncertainty?: number;
-}
-/** A project's tickets: what a provider answers, read by the framework. */
-export interface TicketsSource {
-    /** Every open ticket; `[]` when none can be read. */
-    list(): Promise<Ticket[]>;
-}
-/** The tickets of the project at `root`, or `undefined` when none of its packages provides them. */
-export type TicketsFor = (root: string) => Promise<TicketsSource | undefined>;
-/** A {@link TicketsFor} that also forgets what it read of one project, for when a widget just wrote there. */
-export type TicketsReader = TicketsFor & {
-    changed(root: string): void;
-};
-/** The rows read back from a provider's output: the objects with the five plain facts, everything else as printed; anything else is no ticket. */
-export declare function parseTickets(output: unknown): Ticket[];
-/**
- * The production {@link TicketsReader}: the project's provider, looked up by its package.json, one
- * source per project kept while the same command provides — so the cache holds across the many
- * reads of one poll, and a project that installs, swaps or drops its provider is read the new way
- * within {@link CACHE_MS}. `changed(root)` forgets that project's read, so the next read runs the
- * command again: a widget's command just ran there, and may have written.
- */
-export declare function providedTickets(now?: () => number): TicketsReader;
-/** The framework's one reader of the tickets, shared by every caller so they share its cache. */
-export declare const projectTickets: TicketsReader;
-/** A {@link TicketsFor} for a project with no provider: no tickets. */
-export declare const noTickets: TicketsFor;

package/dist/widget-types/src/tickets.d.ts

@@ -1,17 +0,0 @@
-import type { AgentMeta } from './store/index.js';
-/**
- * The ask for one ticket's plan (#685): `Create tickets/<stem>.plan.md`, the `.md` swapped for the
- * sibling `.plan.md` the plan views read. The one wording for plan work wherever the dashboard
- * asks for it — the sentence the plan column starts an attended agent with, and the queue-add
- * writes as entries — so the surfaces cannot drift apart
- * (#1187) and a queued copy is recognizable by exact text.
- */
-export declare function planTicketPrompt(file: string): string;
-/**
- * The agent that wrote a ticket's plan (#1511): the newest agent whose ask names that plan — the
- * {@link planTicketPrompt} sentence, as the plan column starts it and as a pinned queue drain
- * carries it. There is no marker in the plan file itself, so the link is made from the
- * framework's own records instead. A plan written by a run whose ask never named it (a single
- * unpinned drain reading "the first open entry") is not attributed.
- */
-export declare function planAgentFor(agents: AgentMeta[], file: string): AgentMeta | undefined;

package/dist/widget-types/src/worktrees.d.ts

@@ -1,89 +0,0 @@
-import { type AgentStatus, type BranchesFor, type RunsFor } from './store/index.js';
-/** A retained worktree and the agent that left it behind (#752). */
-export interface WorktreeRow {
-    /** The agent id. */
-    agentId: string;
-    /** The branch the agent's work landed on, when its meta recorded one (#799). */
-    branch?: string;
-    /** How the agent that left this checkout ended, or `running` while it is still going. */
-    status?: AgentStatus;
-    /** Size on disk in bytes, absent for a live agent (its tree is still changing) or when unreadable. */
-    sizeBytes?: number;
-    /** True while the agent owning this checkout is still going: it is in use, not retained. */
-    live: boolean;
-}
-/** The outcome of {@link removeProjectWorktree}. */
-export type RemoveResult = {
-    ok: true;
-    /**
-     * Branches that went with the checkout: the branch it was on, when that held nothing the
-     * remote lacks (#1650); the run-id branch the agent branched away from, when everything on
-     * it is in the branch that stays (#1657). Absent when nothing went.
-     */
-    branchesDeleted?: string[];
-} | {
-    ok: false;
-    error: string;
-};
-/**
- * The worktrees a project still has on disk (#752), newest first — the same view the dashboard's
- * retained-worktrees list is built from, through the same store reads, so the CLI is a second
- * surface rather than a second behaviour. The checkouts are what the project's branches provider
- * lists (#1774); a project with no provider has none.
- *
- * A live agent's checkout is included and flagged rather than hidden: "what is this directory and
- * why can I not remove it" is exactly the question the list has to answer.
- */
-export declare function listProjectWorktrees(cwd: string, opts?: {
-    sizes?: boolean;
-}, branches?: BranchesFor): Promise<WorktreeRow[]>;
-/**
- * Remove one retained worktree (#752/#737/E5): the one implementation behind every surface that
- * removes one: the dashboard's Remove button (#982). The run's own tool reclaims a finished run's
- * checkout by the same rule; this is for the checkouts that rule kept.
- *
- * **One rule: only what is on the remote may go**: the rule is the branches provider's, whose
- * `remove` pushes the branch first when the remote lacks it and refuses what it cannot push
- * (#1774); its refusal is answered in its own words.
- *
- * Refuses while the agent is still going — an agent's checkout is where its agent is working, and Stop
- * is how you end an agent, not pulling the floor out from under it.
- */
-export declare function removeProjectWorktree(cwd: string, agentId: string, branches?: BranchesFor): Promise<RemoveResult>;
-/** The outcome of {@link deleteProjectAgent}. */
-export type DeleteAgentResult = {
-    ok: true;
-} | {
-    ok: false;
-    error: string;
-};
-/** Where {@link deleteProjectAgent} reads: the project's providers by default. */
-export interface DeleteAgentOptions {
-    /** Where the project's finished runs are read and removed; the project's runs provider by default. */
-    runs?: RunsFor;
-    /** Where the project's checkouts are read and removed; the project's branches provider by default. */
-    branches?: BranchesFor;
-}
-/**
- * Delete a session (#1032): take it out of the dashboard, records and all.
- *
- * This is the sibling of {@link removeProjectWorktree}, and the difference is the whole point.
- * Remove-worktree reclaims the checkout on disk and keeps the session — its row, its replayable
- * log — because the run is recorded on the data branch. Delete removes that record too: the card
- * (`<id>.json`, what the rail lists) and the diary (`<id>.jsonl`, what replays), so the row is
- * gone for good. It is the one destructive-of-history action, which is
- * why the surfaces that call it confirm first. The run is on the data branch, so its deletion is
- * itself a committed, pushed change.
- *
- * What it deliberately leaves is git's, not the dashboard's: the branch `agent-<id>`
- * (or the name the agent gave it) and its commits. Deleting a branch that may carry merged work
- * or an open PR is not a thing a
- * dashboard action should do silently, so the branch stays and delete means "remove from the
- * dashboard", not "erase every trace".
- *
- * Refuses while the agent is still going — Stop is how an agent ends. Any uncommitted work in the
- * worktree is discarded with it, which is the intent here (the session is being thrown away),
- * unlike remove-worktree, which refuses a checkout holding uncommitted work: the branches
- * provider's `remove --discard` (#1774).
- */
-export declare function deleteProjectAgent(cwd: string, agentId: string, opts?: DeleteAgentOptions): Promise<DeleteAgentResult>;

package/dist/widget.css

@@ -1,50 +0,0 @@
-/* The dashboard's theme as Tailwind sees it (#1774): the dark variant, the fonts, and the utilities
-   (`bg-card`, `text-muted-foreground`, …) that read the page's own tokens. The dashboard imports
-   it, and so does a widget's stylesheet, so a widget's classes read the tokens the page defines in
-   tailwind.css — its colours follow the theme and the theme toggle without a copy of either. */
-
-/* The theme is the `.dark` class LayoutDefault toggles, not the OS preference. Without this,
-   Tailwind v4 compiles `dark:` to `@media (prefers-color-scheme: dark)`, so the `dark:` utilities
-   disagreed with the tokens: picking Dark on a light OS applied the dark tokens but left
-   `dark:text-*-400` unapplied, and picking Light on a dark OS applied them when it should not. */
-@custom-variant dark (&:where(.dark, .dark *));
-
-/* The page is squarer than the old UI, so the radius tightens to ~2px to match. */
-@theme {
-  --radius: 0.125rem;
-  /* The landing page's typeface (#1118), loaded in pages/+Head.tsx. Overriding these two theme
-     keys retargets Tailwind's default body font and every `font-mono` to IBM Plex. */
-  --font-sans: 'IBM Plex Sans', ui-sans-serif, system-ui, sans-serif;
-  --font-mono: 'IBM Plex Mono', ui-monospace, SFMono-Regular, Menlo, monospace;
-}
-
-@theme inline {
-  --color-background: var(--background);
-  --color-foreground: var(--foreground);
-  --color-card: var(--card);
-  --color-card-foreground: var(--card-foreground);
-  --color-muted: var(--muted);
-  --color-muted-foreground: var(--muted-foreground);
-  --color-border: var(--border);
-  --color-primary: var(--primary);
-  --color-primary-foreground: var(--primary-foreground);
-  --color-accent: var(--accent);
-  --color-accent-foreground: var(--accent-foreground);
-  --color-success: var(--success);
-  --color-warning: var(--warning);
-  --color-danger: var(--danger);
-  --color-info: var(--info);
-
-  /* The shadcn sidebar reads its own `--sidebar-*` family so a sidebar can be themed apart from
-     the page. We keep it in step with the rest of the palette (the rail is the app's own surface,
-     not a contrasting slab): background canvas, accent for the hover/active fill, the shared border
-     and the primary ring. */
-  --color-sidebar: var(--background);
-  --color-sidebar-foreground: var(--foreground);
-  --color-sidebar-primary: var(--primary);
-  --color-sidebar-primary-foreground: var(--primary-foreground);
-  --color-sidebar-accent: var(--accent);
-  --color-sidebar-accent-foreground: var(--accent-foreground);
-  --color-sidebar-border: var(--border);
-  --color-sidebar-ring: var(--primary);
-}