@diousk/pi-subagents-fast 0.20.0

package/dist/ui/schedule-menu.js

@@ -0,0 +1,94 @@
+/**
+ * schedule-menu.ts — `/agents → Scheduled jobs` submenu.
+ *
+ * Minimal v1 surface: list scheduled jobs, select one to inspect details +
+ * confirm cancellation. No create wizard (the `Agent` tool's `schedule` param
+ * is the canonical creation path), no toggle/cleanup (cancel is enough for
+ * "I scheduled something dumb, get rid of it"). Add management surfaces here
+ * if real demand emerges.
+ */
+import { selectItem } from "./select-item.js";
+/** Format an ISO timestamp as relative time ("in 4h", "2d ago", "—"). */
+function relTime(iso, now = Date.now()) {
+    if (!iso)
+        return "—";
+    const t = new Date(iso).getTime();
+    if (Number.isNaN(t))
+        return "—";
+    const diff = t - now;
+    const abs = Math.abs(diff);
+    const future = diff > 0;
+    if (abs < 60_000)
+        return future ? "in <1m" : "<1m ago";
+    const m = Math.round(abs / 60_000);
+    if (m < 60)
+        return future ? `in ${m}m` : `${m}m ago`;
+    const h = Math.round(abs / 3_600_000);
+    if (h < 24)
+        return future ? `in ${h}h` : `${h}h ago`;
+    const d = Math.round(abs / 86_400_000);
+    return future ? `in ${d}d` : `${d}d ago`;
+}
+/** One-line status icon. */
+function statusIcon(j) {
+    if (!j.enabled)
+        return "✗";
+    if (j.lastStatus === "error")
+        return "!";
+    if (j.lastStatus === "running")
+        return "⋯";
+    return "✓";
+}
+/** Compact selectable row — name, schedule, agent type, next/last run, count. */
+function formatJob(j, scheduler) {
+    const next = scheduler.getNextRun(j.id);
+    return [
+        statusIcon(j),
+        j.name.padEnd(18).slice(0, 18),
+        j.schedule.padEnd(14).slice(0, 14),
+        `[${j.subagent_type}]`,
+        `next ${relTime(next)}`,
+        `last ${relTime(j.lastRun)}`,
+        `runs ${j.runCount}`,
+    ].join("  ");
+}
+/** Multi-line details block for the cancel confirm. */
+function formatDetails(j, scheduler) {
+    const next = scheduler.getNextRun(j.id) ?? "—";
+    return [
+        `name:      ${j.name}`,
+        `schedule:  ${j.schedule} (${j.scheduleType})`,
+        `agent:     ${j.subagent_type}`,
+        `prompt:    ${j.prompt.slice(0, 200)}${j.prompt.length > 200 ? "…" : ""}`,
+        `created:   ${j.createdAt}`,
+        `last run:  ${j.lastRun ?? "—"} (${j.lastStatus ?? "—"})`,
+        `next run:  ${next}`,
+        `runs:      ${j.runCount}`,
+    ].join("\n");
+}
+/**
+ * List scheduled jobs; selecting one opens a cancel-confirm with details.
+ * Returns when the user backs out or after a cancellation.
+ */
+export async function showSchedulesMenu(ctx, scheduler) {
+    if (!scheduler.isActive()) {
+        ctx.ui.notify("Scheduler is not active in this session.", "warning");
+        return;
+    }
+    const jobs = scheduler.list();
+    if (jobs.length === 0) {
+        ctx.ui.notify("No scheduled jobs.", "info");
+        return;
+    }
+    // Numbered + item-paired: two jobs whose names agree in the first 18
+    // characters format identically, and matching the returned string back
+    // against a parallel label array cancelled whichever came first.
+    const job = await selectItem(ctx.ui, `Scheduled jobs (${jobs.length}) — select to cancel`, jobs, j => formatJob(j, scheduler));
+    if (!job)
+        return;
+    const ok = await ctx.ui.confirm(`Cancel "${job.name}"?`, formatDetails(job, scheduler));
+    if (!ok)
+        return;
+    scheduler.removeJob(job.id);
+    ctx.ui.notify(`Cancelled "${job.name}".`, "info");
+}

package/dist/ui/select-item.d.ts

@@ -0,0 +1,27 @@
+/**
+ * select-item.ts — pick an item from a list via `ctx.ui.select`, safely.
+ *
+ * Pi's dialog API is `select(title, options: string[]) => Promise<string | undefined>`:
+ * strings in, string out, with no index or value form. Callers therefore have to
+ * map the returned string back to the item it came from, and the obvious way —
+ * `labels.indexOf(choice)` over a parallel array — silently resolves to the
+ * FIRST match whenever two rows format identically. Row formatters here truncate
+ * (job names to 18 chars, agent descriptions to whatever fits), and the text they
+ * truncate is LLM-authored, so collisions are ordinary rather than exotic.
+ *
+ * This numbers every row, which makes the labels unique by construction — no
+ * data-dependent branch that only executes in the case nobody exercises — and
+ * keeps each label paired with its item so a later edit that sorts or filters
+ * between building and resolving cannot desync them.
+ */
+/** Minimal shape of the `ctx.ui` surface this needs. */
+export interface SelectUI {
+    select(title: string, options: string[]): Promise<string | undefined>;
+}
+/**
+ * Show a numbered picker and return the chosen item (not its label).
+ *
+ * Returns undefined when the user escapes, or when the returned string is not
+ * one we offered.
+ */
+export declare function selectItem<T>(ui: SelectUI, title: string, items: readonly T[], format: (item: T, index: number) => string): Promise<T | undefined>;

package/dist/ui/select-item.js

@@ -0,0 +1,34 @@
+/**
+ * select-item.ts — pick an item from a list via `ctx.ui.select`, safely.
+ *
+ * Pi's dialog API is `select(title, options: string[]) => Promise<string | undefined>`:
+ * strings in, string out, with no index or value form. Callers therefore have to
+ * map the returned string back to the item it came from, and the obvious way —
+ * `labels.indexOf(choice)` over a parallel array — silently resolves to the
+ * FIRST match whenever two rows format identically. Row formatters here truncate
+ * (job names to 18 chars, agent descriptions to whatever fits), and the text they
+ * truncate is LLM-authored, so collisions are ordinary rather than exotic.
+ *
+ * This numbers every row, which makes the labels unique by construction — no
+ * data-dependent branch that only executes in the case nobody exercises — and
+ * keeps each label paired with its item so a later edit that sorts or filters
+ * between building and resolving cannot desync them.
+ */
+/**
+ * Show a numbered picker and return the chosen item (not its label).
+ *
+ * Returns undefined when the user escapes, or when the returned string is not
+ * one we offered.
+ */
+export async function selectItem(ui, title, items, format) {
+    // Pad the number so a 10+ item list keeps its columns aligned.
+    const width = String(items.length).length;
+    const rows = items.map((item, i) => ({
+        item,
+        label: `${String(i + 1).padStart(width)}. ${format(item, i)}`,
+    }));
+    const choice = await ui.select(title, rows.map(r => r.label));
+    if (!choice)
+        return undefined;
+    return rows.find(r => r.label === choice)?.item;
+}

package/dist/ui/viewer-keys.d.ts

@@ -0,0 +1,20 @@
+/**
+ * viewer-keys.ts — Scroll key matchers for the conversation viewer.
+ *
+ * Resolves `tui.select.*` through the user's keybindings when pi provides a
+ * manager, falling back to the previous hardcoded keys otherwise. The viewer's
+ * k/j and shift+arrow aliases always work alongside whatever is bound.
+ */
+/** The `tui.select.*` keybinding ids the viewer resolves. */
+export type ViewerScrollKeybinding = "tui.select.up" | "tui.select.down" | "tui.select.pageUp" | "tui.select.pageDown";
+/** Structural subset of pi-tui's `KeybindingsManager` (which satisfies it). */
+export interface ViewerKeybindings {
+    matches(data: string, keybinding: ViewerScrollKeybinding): boolean;
+}
+export interface ViewerKeys {
+    scrollUp(data: string): boolean;
+    scrollDown(data: string): boolean;
+    pageUp(data: string): boolean;
+    pageDown(data: string): boolean;
+}
+export declare function createViewerKeys(keybindings?: ViewerKeybindings): ViewerKeys;

package/dist/ui/viewer-keys.js

@@ -0,0 +1,17 @@
+/**
+ * viewer-keys.ts — Scroll key matchers for the conversation viewer.
+ *
+ * Resolves `tui.select.*` through the user's keybindings when pi provides a
+ * manager, falling back to the previous hardcoded keys otherwise. The viewer's
+ * k/j and shift+arrow aliases always work alongside whatever is bound.
+ */
+import { matchesKey } from "@earendil-works/pi-tui";
+export function createViewerKeys(keybindings) {
+    const matches = (data, id, fallback) => keybindings ? keybindings.matches(data, id) : matchesKey(data, fallback);
+    return {
+        scrollUp: (data) => matches(data, "tui.select.up", "up") || matchesKey(data, "k"),
+        scrollDown: (data) => matches(data, "tui.select.down", "down") || matchesKey(data, "j"),
+        pageUp: (data) => matches(data, "tui.select.pageUp", "pageUp") || matchesKey(data, "shift+up"),
+        pageDown: (data) => matches(data, "tui.select.pageDown", "pageDown") || matchesKey(data, "shift+down"),
+    };
+}

package/dist/ui/workflow-card.d.ts

@@ -0,0 +1,175 @@
+/**
+ * workflow-card.ts — the inline transcript card for a running workflow.
+ *
+ * ```
+ * ▸ Workflow  review-changes                       3/7 agents · 1m12s
+ *   Review changed files across dimensions, verify each finding
+ *   ╭─ Review
+ *   │ ├─ ✔ review:bugs      · Explore · haiku · 18.4k · 12 tool calls · 42s
+ *   │ ├─ ⟳ review:perf      · Explore · 8 tool calls · 21s
+ *   │ └─ ⟳ review:security
+ *   ╰─ Verify
+ *     └─ ⟳ verify:auth.ts   · Plan · 3 tool calls · 9s
+ *   ⎿  scanned 41 changed files
+ * ```
+ *
+ * Two things about this file are easy to get wrong.
+ *
+ * **The glyphs are not the dialog's glyphs.** The inline row keys off the *raw*
+ * entry `state` (start | progress | done | error), not the derived display
+ * state, so a skipped or blocked agent renders as a plain ✘ here while the
+ * workflows dialog distinguishes them. `displayState` is deliberately not
+ * consulted below.
+ *
+ * **The layout is pure.** `layoutWorkflowCard` returns coloured segments and
+ * never touches a theme or a terminal, so the same layout drives the `Workflow`
+ * tool's `renderResult` and a standalone session entry (a workflow launched from
+ * a CLI flag has no tool call to attach to). Theme application is the thin
+ * `styleWorkflowCardLines` wrapper on top.
+ *
+ * All state derivation lives in `src/workflow/progress.ts`; this file only
+ * arranges what that module returns.
+ */
+import { Text } from "@earendil-works/pi-tui";
+import type { WorkflowEntryData } from "../workflow/entry.js";
+import type { WorkflowMeta } from "../workflow/meta.js";
+import { type WorkflowAgentEntry, type WorkflowEntry, type WorkflowRunStatus } from "../workflow/progress.js";
+import type { Theme } from "./agent-widget.js";
+/**
+ * Header re-render cadence. Claude Code ticks the workflow clock once a second,
+ * not at the 80ms spinner cadence — the running glyph is static, so there is
+ * nothing to animate faster than the elapsed time changes.
+ */
+export declare const WORKFLOW_TICK_MS = 1000;
+export interface WorkflowGlyphs {
+    /** Tool-title pointer, matching the Agent tool's `▸`. */
+    pointer: string;
+    tick: string;
+    cross: string;
+    /** Running/queued. A static glyph, hence no spinner inline. */
+    running: string;
+    /** First and subsequent phase groups. */
+    groupTop: string;
+    /** A group that is neither the first nor the last. */
+    groupMid: string;
+    /** The last phase group. */
+    groupBottom: string;
+    /** Continuation rail under a non-final group. */
+    vertical: string;
+    branch: string;
+    lastBranch: string;
+    /** Log-line prefix, matching the Agent tool's result lines. */
+    log: string;
+    warning: string;
+}
+export declare const UNICODE_GLYPHS: WorkflowGlyphs;
+/**
+ * The `figures` ASCII tier, for terminals that cannot draw the box set. Every
+ * glyph keeps its unicode counterpart's column width so the tree stays aligned
+ * either way.
+ */
+export declare const ASCII_GLYPHS: WorkflowGlyphs;
+/**
+ * pi theme keys. Claude Code's palette maps as success→success, error→error,
+ * subtle→dim, permission→warning for a blocked row and accent for selection;
+ * an undefined colour means "leave it at the terminal default", which is what
+ * the recovered inline mapping asks for on a running row.
+ *
+ * `accent` is unused by the card and exists for the workflows dialog, which
+ * shares these segment types.
+ */
+export type WorkflowCardColor = "success" | "error" | "warning" | "dim" | "muted" | "toolTitle" | "accent";
+export interface WorkflowCardSegment {
+    text: string;
+    color?: WorkflowCardColor;
+    bold?: boolean;
+}
+export type WorkflowCardLine = WorkflowCardSegment[];
+/** The subset of the task record the card reads. */
+export interface WorkflowCardTask {
+    status: WorkflowRunStatus;
+    workflowName?: string;
+    summary?: string;
+    description?: string;
+    startTime: number;
+    endTime?: number;
+    totalPausedMs?: number;
+}
+export interface WorkflowCardInput {
+    progress: readonly WorkflowEntry[];
+    task: WorkflowCardTask;
+    meta?: WorkflowMeta;
+    /** Agents the runtime has scheduled, which can exceed those that have reported. */
+    agentCount?: number;
+    /** Total tokens for the size warning; summed from the entries when omitted. */
+    totalTokens?: number;
+    agentCap?: number;
+    tokenCap?: number;
+    now?: number;
+    width?: number;
+    /** Swap in the ASCII glyph tier for terminals without unicode. */
+    ascii?: boolean;
+    /**
+     * Lead with `▸ SubagentWorkflow`.
+     *
+     * True where the card stands alone — the session entry a flag-launched run
+     * writes, which has no tool call above it to say what it is. False as a tool
+     * result, where the call line directly above already does.
+     */
+    showToolTitle?: boolean;
+}
+/** `18.4k` / `1.2M` — bare magnitude, since the row already reads as a stat. */
+export declare function formatCompactTokens(count: number): string;
+/**
+ * One label for the model pair. A fallback that never differed from the primary
+ * would just be noise, so it only shows when the run actually has two models in
+ * play.
+ */
+export declare function formatModel(entry: WorkflowAgentEntry, opts?: {
+    canonical?: boolean;
+}): string | undefined;
+/**
+ * The thinking level, and what was asked for when it was not honoured.
+ *
+ * Separate from {@link formatModel} because a row can have one without the
+ * other: an `agent()` that named no model still runs at some level, and a level
+ * pi clamped is worth saying so about even when the model is unremarkable.
+ */
+export declare function formatThinking(entry: WorkflowAgentEntry): string | undefined;
+/**
+ * What a row replayed from a resume journal says instead of a duration.
+ *
+ * Shared with the dialog so both views name the same thing the same way — the
+ * card shows it inline while the run happens, the dialog on the agent's row.
+ */
+export declare const REPLAYED_ANNOTATION = "from resume journal";
+/**
+ * The `·`-separated tail of an agent row, in the recovered order: agentType,
+ * model, tokens, toolCalls, durationMs. Absent values drop out entirely rather
+ * than rendering a placeholder.
+ */
+export declare function agentStatSegments(entry: WorkflowAgentEntry): string[];
+/** Trim a line to `width`, cutting inside whichever segment crosses the edge. */
+export declare function clampLine(line: WorkflowCardLine, width: number): WorkflowCardLine;
+/**
+ * Build the card.
+ *
+ * Everything derived — the phase tree, the header counts, the logs, the size
+ * warning — comes from `progress.ts`; what happens here is purely arrangement.
+ */
+export declare function layoutWorkflowCard(input: WorkflowCardInput): WorkflowCardLine[];
+/** The card as plain text — what the layout tests assert against. */
+export declare function plainWorkflowCardLines(lines: readonly WorkflowCardLine[]): string[];
+/** Apply the theme. Nothing here changes the layout, only its colours. */
+export declare function styleWorkflowCardLines(lines: readonly WorkflowCardLine[], theme: Theme): string[];
+/** The card as a component, for a tool result or a session entry renderer. */
+export declare function renderWorkflowCard(input: WorkflowCardInput, theme: Theme): Text;
+/**
+ * The card for a session entry, from the JSON a flag-launched run persisted.
+ *
+ * The same layout the tool result uses, not a second one — the only difference
+ * is `showToolTitle`, because a session entry stands alone and nothing above it
+ * says what it is. Returns undefined for an entry with no data, which is what
+ * pi's renderer contract wants for "nothing to draw".
+ */
+export declare function renderWorkflowEntryCard(data: WorkflowEntryData | undefined, theme: Theme): Text | undefined;