hydra-os-cli 0.1.0

package/dist/config.js

@@ -0,0 +1,91 @@
+/**
+ * Configuration loading and validation for the Hydra TUI.
+ *
+ * Config file: ~/.hydra/config.yaml
+ * Overridable via environment variables.
+ */
+import { z } from "zod";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { parse as parseYaml } from "yaml";
+export const TuiConfigSchema = z.object({
+    temporal: z.object({
+        address: z.string().default("localhost:7233"),
+        namespace: z.string().default("default"),
+    }).default({}),
+    api: z.object({
+        url: z.string().default("http://localhost:7070"),
+    }).default({}),
+    qdrant: z.object({
+        url: z.string().default("http://localhost:6333"),
+    }).default({}),
+    tui: z.object({
+        theme: z.enum(["dark", "light", "solarized", "monokai", "hydra"]).default("dark"),
+        layout: z.enum(["split", "full"]).default("split"),
+        rightPanel: z.boolean().default(true),
+        vimMode: z.boolean().default(false),
+        syntaxHighlighting: z.boolean().default(true),
+        maxHistory: z.number().default(1000),
+        spinnerStyle: z.enum(["dots", "line", "arc", "bounce"]).default("dots"),
+    }).default({}),
+    workflow: z.object({
+        defaultModel: z.string().default("claude-sonnet-4-5-20250929"),
+        autoApproveReads: z.boolean().default(true),
+        qualityThreshold: z.number().default(28),
+        costWarning: z.number().default(5.0),
+    }).default({}),
+    notifications: z.object({
+        sound: z.boolean().default(true),
+        desktop: z.boolean().default(true),
+        idleAlert: z.number().default(300),
+    }).default({}),
+});
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+        const sv = source[key];
+        const tv = result[key];
+        if (sv && typeof sv === "object" && !Array.isArray(sv) && tv && typeof tv === "object" && !Array.isArray(tv)) {
+            result[key] = deepMerge(tv, sv);
+        }
+        else {
+            result[key] = sv;
+        }
+    }
+    return result;
+}
+function loadYamlConfig() {
+    try {
+        const configPath = join(homedir(), ".hydra", "config.yaml");
+        const raw = readFileSync(configPath, "utf-8");
+        const parsed = parseYaml(raw);
+        return typeof parsed === "object" && parsed !== null ? parsed : {};
+    }
+    catch {
+        // No config file or parse error — use defaults
+        return {};
+    }
+}
+export function getEnvOverrides() {
+    const overrides = {};
+    if (process.env.TEMPORAL_ADDRESS) {
+        overrides.temporal = { address: process.env.TEMPORAL_ADDRESS };
+    }
+    if (process.env.HYDRA_API_URL) {
+        overrides.api = { url: process.env.HYDRA_API_URL };
+    }
+    if (process.env.QDRANT_URL) {
+        overrides.qdrant = { url: process.env.QDRANT_URL };
+    }
+    if (process.env.HYDRA_THEME) {
+        overrides.tui = { theme: process.env.HYDRA_THEME };
+    }
+    return overrides;
+}
+export function loadConfig() {
+    const fileConfig = loadYamlConfig();
+    const envOverrides = getEnvOverrides();
+    const merged = deepMerge(fileConfig, envOverrides);
+    return TuiConfigSchema.parse(merged);
+}

package/dist/screens/help.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Help screen.
+ * Displays all available commands grouped by category.
+ */
+export declare function HelpScreen(): import("react/jsx-runtime").JSX.Element;

package/dist/screens/help.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Help screen.
+ * Displays all available commands grouped by category.
+ */
+import { Box, Text } from "ink";
+import { getAllCommands } from "../commands/index.js";
+export function HelpScreen() {
+    const commands = getAllCommands();
+    const categories = [...new Set(commands.map((c) => c.category))];
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, children: "Hydra TUI Commands" }), _jsx(Text, {}), categories.map((cat) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: cat.toUpperCase() }), commands
+                        .filter((c) => c.category === cat)
+                        .map((cmd) => (_jsxs(Box, { gap: 2, children: [_jsx(Text, { color: "green", children: `/${cmd.name}`.padEnd(16) }), _jsx(Text, { children: cmd.description })] }, cmd.name)))] }, cat))), _jsx(Text, {}), _jsx(Text, { dimColor: true, children: "Keyboard: Ctrl+P toggle panels | Ctrl+D exit | F1 help | F5 refresh" })] }));
+}

package/dist/screens/main.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Main screen with split layout.
+ * This is the default screen shown on TUI launch.
+ */
+export { App as MainScreen } from "../app.js";

package/dist/screens/main.js

@@ -0,0 +1,5 @@
+/**
+ * Main screen with split layout.
+ * This is the default screen shown on TUI launch.
+ */
+export { App as MainScreen } from "../app.js";

package/dist/screens/workflow-detail.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Workflow detail / timeline view screen.
+ * Shows full workflow timeline, agent outputs, quality scores, artifacts.
+ */
+interface WorkflowDetailScreenProps {
+    workflowId: string;
+}
+export declare function WorkflowDetailScreen({ workflowId }: WorkflowDetailScreenProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/screens/workflow-detail.js

@@ -0,0 +1,11 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Workflow detail / timeline view screen.
+ * Shows full workflow timeline, agent outputs, quality scores, artifacts.
+ */
+import { Box, Text } from "ink";
+import { Timeline } from "../widgets/timeline.js";
+export function WorkflowDetailScreen({ workflowId }) {
+    // TODO: fetch workflow data from API/Temporal
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { bold: true, children: ["Workflow Detail: ", workflowId] }), _jsx(Timeline, { workflowId: workflowId, workflowStatus: "LOADING", startedAgo: "...", totalCost: "...", steps: [] })] }));
+}

package/dist/screens/workflow-list.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Workflow list view screen.
+ * Shows all workflows with status, phase, cost, elapsed time.
+ */
+export declare function WorkflowListScreen(): import("react/jsx-runtime").JSX.Element;

package/dist/screens/workflow-list.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Workflow list view screen.
+ * Shows all workflows with status, phase, cost, elapsed time.
+ */
+import { Box, Text } from "ink";
+export function WorkflowListScreen() {
+    // TODO: fetch workflows from API
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, underline: true, children: "Workflows" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "No workflows found. Use /start to create one." }) })] }));
+}

package/dist/sse.d.ts

@@ -0,0 +1,16 @@
+/**
+ * SSE (Server-Sent Events) streaming for the Hydra TUI.
+ * Fetch-based parser since Node 18+ has no native EventSource.
+ */
+import type { HydraStore } from "./store.js";
+export interface SseEvent {
+    event: string;
+    data: string;
+    id?: string;
+}
+/**
+ * Subscribe to a workflow's SSE stream and push updates to the store.
+ * Reconnects with exponential backoff on connection failure (max 5 retries).
+ * Returns an AbortController for cleanup.
+ */
+export declare function subscribeToWorkflow(apiUrl: string, workflowId: string, store: HydraStore): AbortController;

package/dist/sse.js

@@ -0,0 +1,197 @@
+/**
+ * SSE (Server-Sent Events) streaming for the Hydra TUI.
+ * Fetch-based parser since Node 18+ has no native EventSource.
+ */
+const MAX_RECONNECT_ATTEMPTS = 5;
+const BASE_RECONNECT_DELAY_MS = 1000;
+function parseSseLine(line, state) {
+    if (line.startsWith(":"))
+        return; // Comment / heartbeat
+    const colonIdx = line.indexOf(":");
+    // Per SSE spec: line with no colon uses entire line as field name with empty value
+    const field = colonIdx === -1 ? line : line.slice(0, colonIdx);
+    const value = colonIdx === -1 ? "" : line.slice(colonIdx + 1).trimStart();
+    switch (field) {
+        case "event":
+            state.event = value;
+            break;
+        case "data":
+            state.data += (state.data ? "\n" : "") + value;
+            break;
+        case "id":
+            state.id = value;
+            break;
+    }
+}
+/**
+ * Async generator that yields parsed SSE events from a fetch stream.
+ */
+async function* sseStream(url, signal) {
+    const res = await fetch(url, {
+        headers: { Accept: "text/event-stream" },
+        signal,
+    });
+    if (!res.ok) {
+        throw new Error(`SSE connection failed: ${res.status} ${res.statusText}`);
+    }
+    const reader = res.body?.getReader();
+    if (!reader)
+        throw new Error("No response body");
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const state = { event: "", data: "", id: undefined };
+    function resetState() {
+        state.event = "";
+        state.data = "";
+        state.id = undefined;
+    }
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            // Keep the last incomplete line in buffer
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (line === "") {
+                    // Empty line = event boundary
+                    if (state.data) {
+                        yield {
+                            event: state.event || "message",
+                            data: state.data.trimEnd(),
+                            id: state.id,
+                        };
+                    }
+                    resetState();
+                    continue;
+                }
+                parseSseLine(line, state);
+            }
+        }
+        // Flush any remaining data in buffer after stream ends
+        if (buffer.trim()) {
+            parseSseLine(buffer, state);
+        }
+        if (state.data) {
+            yield {
+                event: state.event || "message",
+                data: state.data.trimEnd(),
+                id: state.id,
+            };
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function processSseEvent(event, workflowId, store) {
+    if (event.event === "heartbeat")
+        return;
+    try {
+        const data = JSON.parse(event.data);
+        if (event.event === "workflow.progress") {
+            const step = data.current_step ?? data.phase ?? "unknown";
+            const status = data.status ?? "";
+            store.addMessage({
+                role: "agent",
+                content: `[${step}] ${status}${data.message ? `: ${data.message}` : ""}`,
+                agent: step,
+            });
+            // Update agents from step data
+            if (Array.isArray(data.steps)) {
+                store.setAgents(data.steps.map((st) => ({
+                    id: String(st.role ?? ""),
+                    role_id: String(st.role ?? ""),
+                    queue: String(st.role ?? ""),
+                    status: String(st.status === "completed" ? "idle" : st.status === "running" ? "active" : "idle"),
+                    model: "",
+                    active_sessions: st.status === "running" ? 1 : 0,
+                    total_tokens_used: Number(st.tokens ?? 0),
+                    current_workflow: st.status === "running" ? workflowId : null,
+                    skill_packs: [],
+                })));
+            }
+        }
+        else if (event.event === "workflow.completed") {
+            store.addMessage({
+                role: "system",
+                content: `Workflow completed: ${data.status ?? "done"}`,
+            });
+            store.removeSseController(workflowId);
+        }
+        else if (event.event === "error") {
+            store.addMessage({
+                role: "error",
+                content: `Stream error: ${data.message ?? JSON.stringify(data)}`,
+            });
+        }
+        else {
+            store.addMessage({
+                role: "agent",
+                content: `[${event.event}] ${JSON.stringify(data).slice(0, 200)}`,
+                agent: "stream",
+            });
+        }
+    }
+    catch {
+        // Non-JSON data
+        store.addMessage({
+            role: "agent",
+            content: `[${event.event}] ${event.data.slice(0, 200)}`,
+            agent: "stream",
+        });
+    }
+}
+/**
+ * Subscribe to a workflow's SSE stream and push updates to the store.
+ * Reconnects with exponential backoff on connection failure (max 5 retries).
+ * Returns an AbortController for cleanup.
+ */
+export function subscribeToWorkflow(apiUrl, workflowId, store) {
+    const controller = new AbortController();
+    const url = `${apiUrl.replace(/\/$/, "")}/stream/workflows/${workflowId}`;
+    (async () => {
+        let attempts = 0;
+        while (!controller.signal.aborted) {
+            try {
+                attempts++;
+                for await (const event of sseStream(url, controller.signal)) {
+                    processSseEvent(event, workflowId, store);
+                    // Reset attempts on successful event — connection is healthy
+                    attempts = 0;
+                }
+                // Stream ended normally (server closed connection)
+                break;
+            }
+            catch (err) {
+                if (controller.signal.aborted)
+                    return; // Normal cleanup
+                if (attempts >= MAX_RECONNECT_ATTEMPTS) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    store.addMessage({
+                        role: "error",
+                        content: `SSE stream failed after ${MAX_RECONNECT_ATTEMPTS} attempts: ${msg}`,
+                    });
+                    store.removeSseController(workflowId);
+                    return;
+                }
+                const delay = BASE_RECONNECT_DELAY_MS * Math.pow(2, attempts - 1);
+                store.addMessage({
+                    role: "system",
+                    content: `Stream disconnected, reconnecting in ${(delay / 1000).toFixed(0)}s (attempt ${attempts}/${MAX_RECONNECT_ATTEMPTS})...`,
+                });
+                await new Promise((resolve) => {
+                    const timer = setTimeout(resolve, delay);
+                    // Allow abort to cancel the wait
+                    controller.signal.addEventListener("abort", () => {
+                        clearTimeout(timer);
+                        resolve();
+                    }, { once: true });
+                });
+            }
+        }
+    })();
+    return controller;
+}

package/dist/store.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Central Zustand store for the Hydra TUI.
+ * All widgets read from it, all commands write to it.
+ */
+export type ConnectionStatus = "disconnected" | "connecting" | "connected" | "error";
+export interface ChatMessage {
+    id: string;
+    role: "user" | "agent" | "system" | "error";
+    content: string;
+    timestamp: Date;
+    agent?: string;
+}
+export interface WorkflowDetail {
+    id: string;
+    workflow_type: string;
+    status: string;
+    current_step: string | null;
+    steps: Array<{
+        role: string;
+        status: string;
+        started_at?: string;
+        completed_at?: string;
+        cost?: number;
+        tokens?: number;
+        score?: number;
+    }>;
+    input: Record<string, unknown>;
+    output: Record<string, unknown> | null;
+    artifacts: Array<{
+        path: string;
+        type: string;
+        name?: string;
+    }>;
+    created_at: string;
+    updated_at: string;
+    metrics: Record<string, unknown> | null;
+}
+export interface WorkflowSummary {
+    workflow_id: string;
+    workflow_type: string;
+    task_description: string | null;
+    status: string;
+    domain: string | null;
+    technologies: string[] | null;
+    complexity: string | null;
+    created_at: string;
+    completed_at: string | null;
+    duration_minutes: number | null;
+    current_step: string | null;
+    completed_steps: string[] | null;
+}
+export interface InboxItem {
+    id: string;
+    type: string;
+    workflow_id: string;
+    workflow_type: string;
+    title: string;
+    summary: string;
+    priority: string;
+    created_at: string;
+    agent_role: string | null;
+    approval_type: string;
+    status: string;
+}
+export interface AgentInfo {
+    id: string;
+    role_id: string;
+    queue: string;
+    status: string;
+    model: string;
+    active_sessions: number;
+    total_tokens_used: number;
+    current_workflow: string | null;
+    skill_packs: string[];
+}
+export interface HydraStore {
+    messages: ChatMessage[];
+    maxHistory: number;
+    activeWorkflowId: string | null;
+    activeWorkflow: WorkflowDetail | null;
+    workflows: WorkflowSummary[];
+    inbox: InboxItem[];
+    agents: AgentInfo[];
+    apiUrl: string;
+    apiStatus: ConnectionStatus;
+    sseAbortControllers: Map<string, AbortController>;
+    addMessage: (msg: Omit<ChatMessage, "id" | "timestamp">) => void;
+    clearMessages: () => void;
+    setActiveWorkflowId: (id: string | null) => void;
+    setActiveWorkflow: (wf: WorkflowDetail | null) => void;
+    setWorkflows: (wfs: WorkflowSummary[]) => void;
+    setInbox: (items: InboxItem[]) => void;
+    setAgents: (agents: AgentInfo[]) => void;
+    setApiUrl: (url: string) => void;
+    setApiStatus: (status: ConnectionStatus) => void;
+    addSseController: (key: string, controller: AbortController) => void;
+    removeSseController: (key: string) => void;
+    abortAllSse: () => void;
+}
+export declare const useStore: import("zustand").UseBoundStore<import("zustand").StoreApi<HydraStore>>;

package/dist/store.js

@@ -0,0 +1,64 @@
+/**
+ * Central Zustand store for the Hydra TUI.
+ * All widgets read from it, all commands write to it.
+ */
+import { create } from "zustand";
+let messageCounter = 0;
+export const useStore = create((set, get) => ({
+    messages: [],
+    maxHistory: 1000,
+    activeWorkflowId: null,
+    activeWorkflow: null,
+    workflows: [],
+    inbox: [],
+    agents: [],
+    apiUrl: "http://localhost:7070",
+    apiStatus: "disconnected",
+    sseAbortControllers: new Map(),
+    addMessage: (msg) => set((state) => {
+        const next = [
+            ...state.messages,
+            {
+                ...msg,
+                id: `msg-${Date.now()}-${++messageCounter}`,
+                timestamp: new Date(),
+            },
+        ];
+        return {
+            messages: next.length > state.maxHistory
+                ? next.slice(-state.maxHistory)
+                : next,
+        };
+    }),
+    clearMessages: () => set({ messages: [] }),
+    setActiveWorkflowId: (id) => set({ activeWorkflowId: id }),
+    setActiveWorkflow: (wf) => set({ activeWorkflow: wf }),
+    setWorkflows: (wfs) => set({ workflows: wfs }),
+    setInbox: (items) => set({ inbox: items }),
+    setAgents: (agents) => set({ agents }),
+    setApiUrl: (url) => set({ apiUrl: url }),
+    setApiStatus: (status) => set({ apiStatus: status }),
+    addSseController: (key, controller) => set((state) => {
+        const next = new Map(state.sseAbortControllers);
+        // Abort existing controller for this key
+        const existing = next.get(key);
+        if (existing)
+            existing.abort();
+        next.set(key, controller);
+        return { sseAbortControllers: next };
+    }),
+    removeSseController: (key) => set((state) => {
+        const next = new Map(state.sseAbortControllers);
+        const existing = next.get(key);
+        if (existing)
+            existing.abort();
+        next.delete(key);
+        return { sseAbortControllers: next };
+    }),
+    abortAllSse: () => set((state) => {
+        for (const controller of state.sseAbortControllers.values()) {
+            controller.abort();
+        }
+        return { sseAbortControllers: new Map() };
+    }),
+}));

package/dist/widgets/agent-panel.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Agent panel widget.
+ * Shows live status of each agent role in the active workflow.
+ */
+interface AgentStatus {
+    role: string;
+    status: "done" | "running" | "waiting" | "pending" | "failed";
+    duration?: string;
+}
+interface AgentPanelProps {
+    workflowId?: string;
+    agents?: AgentStatus[];
+}
+export declare function AgentPanel({ workflowId, agents }: AgentPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/widgets/agent-panel.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Agent panel widget.
+ * Shows live status of each agent role in the active workflow.
+ */
+import { Box, Text } from "ink";
+const STATUS_ICONS = {
+    done: "✓",
+    running: "⏳",
+    waiting: "⏸",
+    pending: "○",
+    failed: "✗",
+};
+const STATUS_COLORS = {
+    done: "green",
+    running: "cyan",
+    waiting: "yellow",
+    pending: "gray",
+    failed: "red",
+};
+export function AgentPanel({ workflowId, agents = [] }) {
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, underline: true, children: "Agents" }), !workflowId ? (_jsx(Text, { dimColor: true, children: "No active workflow" })) : agents.length === 0 ? (_jsx(Text, { dimColor: true, children: "Waiting for agents..." })) : (agents.map((agent) => (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: STATUS_COLORS[agent.status], children: STATUS_ICONS[agent.status] }), _jsx(Text, { children: agent.role.padEnd(14) }), _jsx(Text, { dimColor: true, children: agent.status })] }, agent.role))))] }));
+}

package/dist/widgets/approval-modal.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Approval modal widget.
+ * Displays approval requests from workflows with approve/deny/edit options.
+ */
+interface ApprovalModalProps {
+    agent: string;
+    action: string;
+    command: string;
+    risk: "LOW" | "MEDIUM" | "HIGH";
+    active?: boolean;
+    onApprove: () => void;
+    onDeny: () => void;
+    onEdit?: () => void;
+}
+export declare function ApprovalModal({ agent, action, command, risk, active, onApprove, onDeny, onEdit, }: ApprovalModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/widgets/approval-modal.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Approval modal widget.
+ * Displays approval requests from workflows with approve/deny/edit options.
+ */
+import { Box, Text, useInput } from "ink";
+const RISK_COLORS = {
+    LOW: "green",
+    MEDIUM: "yellow",
+    HIGH: "red",
+};
+export function ApprovalModal({ agent, action, command, risk, active = true, onApprove, onDeny, onEdit, }) {
+    useInput((input) => {
+        if (!active)
+            return;
+        if (input === "y")
+            onApprove();
+        if (input === "n")
+            onDeny();
+        if (input === "e" && onEdit)
+            onEdit();
+    }, { isActive: active });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "double", borderColor: "yellow", padding: 1, children: [_jsx(Text, { bold: true, color: "yellow", children: "APPROVAL REQUIRED" }), _jsx(Text, {}), _jsxs(Text, { children: ["Agent: ", _jsx(Text, { bold: true, children: agent })] }), _jsxs(Text, { children: ["Action: ", action] }), _jsx(Text, {}), _jsx(Box, { borderStyle: "single", paddingX: 1, children: _jsx(Text, { children: command }) }), _jsx(Text, {}), _jsxs(Text, { children: ["Risk: ", _jsx(Text, { color: RISK_COLORS[risk], children: risk })] }), _jsx(Text, {}), _jsxs(Text, { children: [_jsx(Text, { color: "green", children: "[y]" }), " Approve", "  ", _jsx(Text, { color: "red", children: "[n]" }), " Deny", "  ", onEdit && (_jsxs(_Fragment, { children: [_jsx(Text, { color: "blue", children: "[e]" }), " Edit"] }))] })] }));
+}

package/dist/widgets/artifact-tree.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Artifact tree widget.
+ * Displays a tree view of artifacts produced by the active workflow.
+ */
+interface Artifact {
+    path: string;
+    type: "file" | "directory";
+}
+interface ArtifactTreeProps {
+    workflowId?: string;
+    artifacts?: Artifact[];
+}
+export declare function ArtifactTree({ workflowId, artifacts }: ArtifactTreeProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/widgets/artifact-tree.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Artifact tree widget.
+ * Displays a tree view of artifacts produced by the active workflow.
+ */
+import { Box, Text } from "ink";
+export function ArtifactTree({ workflowId, artifacts = [] }) {
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, underline: true, children: "Artifacts" }), !workflowId ? (_jsx(Text, { dimColor: true, children: "No active workflow" })) : artifacts.length === 0 ? (_jsx(Text, { dimColor: true, children: "No artifacts yet" })) : (artifacts.map((artifact) => (_jsxs(Text, { children: [artifact.type === "directory" ? "📁 " : "📄 ", artifact.path] }, artifact.path))))] }));
+}

package/dist/widgets/chat-panel.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Chat panel widget.
+ * Displays streaming output from agents, approval prompts, and user messages.
+ */
+import type { ChatMessage } from "../store.js";
+interface ChatPanelProps {
+    messages?: ChatMessage[];
+}
+export declare function ChatPanel({ messages }: ChatPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};