@bubblebrain-ai/bubble 0.0.63 → 0.0.65

package/dist/tui/controller/controller.d.ts

@@ -0,0 +1,199 @@
+/**
+ * BubbleTuiController — the framework-neutral runtime orchestrator
+ * (design doc §8.1). Assembles the extracted sub-modules:
+ *
+ *   - agent-event-reducer (stream/tool/turn semantics)
+ *   - input-queue-machine (steer/queue lifecycle)
+ *   - overlay-controller (blocking request lifecycle)
+ *   - session-transition (two-phase atomic switch)
+ *   - task-runtime-controller (task markers/wakes)
+ *
+ * The controller consumes an Agent event stream, applies effects, batches
+ * streaming updates behind the 40ms FlushScheduler, and publishes immutable
+ * snapshots. Renderers subscribe; they never mutate.
+ */
+import type { Agent, AgentRunOptions } from "../../agent.js";
+import type { WorkflowRunSnapshot } from "../../agent/workflow/control.js";
+import type { BackgroundTaskInfo, ProcessManager } from "../../tasks/manager.js";
+import { SessionManager } from "../../session.js";
+import type { GoalStore } from "../../goal/store.js";
+import type { BubbleTuiPorts } from "./ports.js";
+import type { ControllerEffect } from "./effects.js";
+import { type DisplayMessage, type DisplayMessagePart, type DisplayToolCall } from "../model/display-history.js";
+import { type SubagentGroup } from "../model/subagent-view.js";
+import type { SubmitPayload } from "../model/composer-types.js";
+import type { PromotionChannel } from "../../tasks/promotion.js";
+import { type RewindExecutionResult, type RewindScope } from "../../rewind.js";
+import type { Message } from "../../types.js";
+export interface TuiExitSummary {
+    reason: string;
+    wallMs: number;
+}
+export interface BubbleTuiControllerDeps {
+    readonly agent: Pick<Agent, "run" | "messages" | "setSessionID" | "listSubAgents" | "listWorkflows" | "getSubAgentMessages" | "closeSubAgent" | "closeWorkflow" | "resetContextUsageAnchor"> & {
+        messages: Message[];
+        backgroundTasks?: Agent["backgroundTasks"];
+    };
+    readonly sessionManager: SessionManager;
+    readonly goalStore?: GoalStore;
+    readonly processManager?: ProcessManager;
+    readonly tasksAutoResume?: boolean;
+    readonly promotionChannel?: PromotionChannel;
+    readonly workspaceCwd?: string;
+    readonly ports: BubbleTuiPorts;
+    readonly onEffect?: (effect: ControllerEffect) => void;
+}
+export interface TuiAgentRunOptions extends AgentRunOptions {
+    /** Internal Goal continuation; never forwarded to Agent.run(). */
+    goalRun?: boolean;
+}
+export interface CommandActivity {
+    kind: "compact";
+    status: "running" | "cancelling";
+    startedAt: number;
+}
+export declare class BubbleTuiController {
+    private readonly deps;
+    private readonly state;
+    private readonly listeners;
+    private readonly overlays;
+    private readonly queue;
+    private readonly sessionTransition;
+    private readonly startedAtMs;
+    private turnStartedAt;
+    private readonly goalRuntime?;
+    private readonly taskRuntime?;
+    private readonly pendingTaskAnnouncements;
+    private sessionManager;
+    private transcript;
+    private runActive;
+    private runState;
+    /** Provider-turn accumulators for true child-session inspection. */
+    private readonly childRuns;
+    private activeInputController;
+    private activeAbortController;
+    private commandActivity;
+    /** False after a provider turn commits, so settled and live rows never coexist. */
+    private liveStreamVisible;
+    private readonly backgroundTaskUnsubscribe?;
+    private disposed;
+    constructor(deps: BubbleTuiControllerDeps);
+    private externalGeneration;
+    subscribe(listener: (version: number) => void): () => void;
+    getSnapshotVersion(): number;
+    getTranscript(): readonly DisplayMessage[];
+    getSessionManager(): SessionManager;
+    getGoalIndicator(): string | undefined;
+    handleGoalCommand(input: string, cwd: string): void;
+    getSubagentGroups(): SubagentGroup[];
+    /**
+     * Start of the current (or, when idle, the latest) agent run. The tasks pane
+     * keeps finished work that was launched since then; wall clock on purpose,
+     * it is compared with subagent/task/workflow creation stamps.
+     */
+    getTurnStartedAt(): number | undefined;
+    getWorkflows(): WorkflowRunSnapshot[];
+    getBackgroundTasks(): BackgroundTaskInfo[];
+    getChildTranscript(agentId: string): DisplayMessage[];
+    getChildStreamingTail(agentId: string): {
+        content: string;
+        reasoning: string;
+        tools: DisplayToolCall[];
+        parts: DisplayMessagePart[];
+    } | null;
+    stopSubagent(agentId: string): void;
+    stopWorkflow(runId: string): void;
+    stopBackgroundTask(id: string): void;
+    getBackgroundTaskOutput(id: string): string;
+    /** Called by the host after graceful task reaping on TUI exit. */
+    persistFinalTaskMarkers(): void;
+    private appendTaskMarker;
+    private announceTaskCompletion;
+    /** Pending completions whose launch row has settled since they arrived. */
+    private landPendingTaskAnnouncementsInLiveRound;
+    /** Move the newest live Bash Execute into the unified task manager. */
+    promoteActiveBash(): string | undefined;
+    /** Drop every transcript row (/clear). */
+    clearTranscript(): void;
+    /** Re-project the visible transcript after a non-controller command rewrites Agent history. */
+    rebuildTranscriptFromAgent(): void;
+    /**
+     * Rewind persistence and every renderer-facing mirror as one observable
+     * transition. File restoration can take time, but no partial transcript is
+     * published while it runs.
+     */
+    rewindToTurn(targetId: string, scope: RewindScope): Promise<RewindExecutionResult>;
+    /** Host-side row injection (user echo, notices) — single append point. */
+    appendDisplayMessage(message: DisplayMessage): void;
+    isRunning(): boolean;
+    /** A slash command that owns the activity lane without masquerading as an
+     * Agent turn. This keeps streaming/steering state separate while still
+     * giving Escape and Ctrl+C one cancellation boundary. */
+    beginCommandActivity(kind: CommandActivity["kind"]): AbortSignal;
+    finishCommandActivity(kind: CommandActivity["kind"], event?: DisplayMessage): void;
+    getCommandActivity(): CommandActivity | null;
+    isBusy(): boolean;
+    /** Queue composer input while a command owns the pane. Grok keeps the
+     * composer available during Compact; the message starts after the command
+     * reaches its terminal event instead of racing the history rewrite. */
+    queueAfterCommand(input: string | SubmitPayload): boolean;
+    /** Queue a complete composer payload for the next provider turn. */
+    queueInput(input: string | SubmitPayload): void;
+    drainQueuedInputs(cwd: string, agentOptions?: AgentRunOptions): Promise<void>;
+    pendingSteerCount(): number;
+    queuedInputCount(): number;
+    private submitDisplayText;
+    private submitAgentInput;
+    /** Add input to the current Agent run without creating a second run that
+     * would overwrite the shared streaming accumulator. */
+    steer(content: string): boolean;
+    cancelActiveRun(reason?: string): boolean;
+    /**
+     * Live streaming tail for the render loop: the in-flight accumulator's
+     * content/reasoning/tool summary. Renderers draw it in the live region
+     * (never committed to scrollback) until the turn commits.
+     */
+    getStreamingTail(): {
+        content: string;
+        reasoning: string;
+        tools: DisplayToolCall[];
+        parts: DisplayMessagePart[];
+        phase: "thinking" | "working";
+    } | null;
+    pendingOverlayCount(): number;
+    /**
+     * Drive one agent run: reduce the event stream, apply effects, and finish.
+     * Mirrors runAgentInput (app.tsx:1438-1958) minus the rendering.
+     */
+    runTurn(input: unknown, cwd: string, options?: TuiAgentRunOptions): Promise<void>;
+    /** Apply one reducer transition and publish exactly one observable snapshot. */
+    private applyEffects;
+    /** Mutate for one effect; callers own the surrounding transaction + notify. */
+    private applyEffectMutation;
+    private notify;
+    private reduceChildEvent;
+    private isAbortLike;
+    /** Drain leftover steers at run end (cancelled drops, normal requeues). */
+    drainLeftovers(leftovers: Array<{
+        id: string;
+        content: string;
+    }>, cancelled: boolean): void;
+    /** Atomic session switch through the two-phase transaction. */
+    switchSession(plan: {
+        targetFile: string;
+        notice?: string;
+    }): {
+        ok: boolean;
+        error?: string;
+    };
+    /** Start an empty native session using the same atomic lifecycle as resume. */
+    createFreshSession(cwd: string, notice?: string): {
+        ok: boolean;
+        error?: string;
+    };
+    /**
+     * Shutdown: settle overlays, cancel any run, and report the exit summary.
+     * Idempotent — a second call is a no-op.
+     */
+    shutdown(reason: string): TuiExitSummary;
+}