@pellux/goodvibes-tui 1.27.1 → 2.0.2

package/src/renderer/conversation-tree.ts

@@ -1,228 +0,0 @@
-/**
- * conversation-tree.ts — column geometry for the transcript's branch tree.
- *
- * The transcript renders an assistant turn as a small tree: the turn header at
- * depth 0, each tool call it issues as a depth-1 branch, and each call's result
- * as a depth-2 branch under that call. This module owns the *only* arithmetic
- * that decides where those branch glyphs, status markers and row text land, so
- * every row type (event lines, tool-call rows, collapsed fragments) agrees on a
- * single column grid instead of each re-deriving it.
- *
- * ## The grid
- *
- * One function generates every column, from LAYOUT.LEFT_MARGIN and the row's
- * depth. With LEFT_MARGIN = 4 and TREE_STEP_COLS = 2 that is:
- *
- *   depth 0   `   ●  assistant …`            marker col 3, text col 6
- *   depth 1   `   ✓  ├ read  foo.ts`         marker col 3, connector col 5, text col 8
- *   depth 2   `      │ └  ▸ 31 lines`        connector col 7, text col 10
- *   depth 3   `      │   │ └  …`             connector col 9, text col 12
- *
- * A level's connector sits where its parent's content began, and the row's
- * first printable character sits two columns further right — the same
- * marker→text relationship a depth-0 row has. So the step between levels is
- * exactly TREE_STEP_COLS at every depth, for every row type.
- *
- * ## The status column IS the bullet column
- *
- * `treeStatusCol()` is defined as `treeBranchCol(0)` — literally the column the
- * `●` of `● assistant` occupies. A tool row's ✓ / ✗ / ⊘ / ◌ therefore lands in
- * the same column as the bullet of the turn that issued it, and reads as that
- * bullet's column continuing down the turn rather than as a separate rail off
- * to the left. Deriving it from treeBranchCol rather than restating a number is
- * what keeps the two from drifting: move the bullet and the markers follow.
- *
- * The column is free at every depth ≥ 1 by construction — a branch row's own
- * marker moves right with its indent, and depth 0 never contributes a `│`
- * gutter (a top-level row has no ancestor to continue), so nothing else can
- * claim it.
- *
- * ## Rails are continuous
- *
- * `drawTreeRails` paints EVERY line a row emits, not just its first: the
- * connector on line 0, then `│` down the row's own column for as long as the
- * row has a sibling below it, plus `│` in each open ancestor's gutter on every
- * line. That is what closes the gaps a first-line-only connector leaves under
- * multi-line rows (collapsed fragment boxes, wrapped text, expanded bodies).
- *
- * Rails never overwrite text: apart from the connector itself — which
- * deliberately replaces the marker cell of the row it labels — a rail is drawn
- * only into a cell that is blank and unstyled. A row whose own content reaches
- * into a rail column keeps its content and loses the rail there.
- *
- * ## Narrow terminals
- *
- * Indenting unconditionally would eat the content budget and silently truncate
- * the informative end of a row — the failure class the markdown-table column
- * bug came from. treeIndentCols() therefore clamps the indent to whatever still
- * leaves TREE_MIN_CONTENT_COLS of content, and drops to 0 (flush, no branch
- * glyph) when even one level does not fit. Losing the visual nesting on a
- * 30-column terminal is acceptable; losing characters is not.
- */
-
-import { LAYOUT } from './layout.ts';
-import type { Line } from '../types/grid.ts';
-import { createStyledCell } from '../types/grid.ts';
-import { getDisplayWidth } from '../utils/terminal-width.ts';
-
-/** Columns added per nesting level. Fixed — never content-dependent. */
-const TREE_STEP_COLS = 2;
-
-/**
- * Content columns a branch row is guaranteed to keep. Below this the indent is
- * reduced (and finally dropped) rather than squeezing the row's text.
- */
-const TREE_MIN_CONTENT_COLS = 16;
-
-/** Vertical rail drawn in an ancestor's gutter and down an open row's column. */
-const TREE_RAIL = '│';
-
-/** The connector a row draws when a sibling follows it below. */
-const TREE_CONNECTOR_CONTINUES = '├';
-
-/**
- * Effective indent, in columns, for a branch at `depth` rendered at `width`.
- *
- * Returns 0 for depth <= 0 (a flush, non-branch row) and for widths too narrow
- * to carry even one level while keeping TREE_MIN_CONTENT_COLS of content. The
- * result is always a whole multiple of TREE_STEP_COLS, so branch glyphs across
- * different depths stay on the same column grid.
- */
-export function treeIndentCols(depth: number, width: number): number {
-  if (depth <= 0) return 0;
-  const budget = width - LAYOUT.LEFT_MARGIN - LAYOUT.RIGHT_MARGIN - TREE_MIN_CONTENT_COLS;
-  if (budget < TREE_STEP_COLS) return 0;
-  const affordableLevels = Math.floor(budget / TREE_STEP_COLS);
-  return Math.min(depth, affordableLevels) * TREE_STEP_COLS;
-}
-
-/**
- * Column the row's leading glyph occupies for a given effective indent: the
- * `●` of a depth-0 row, the `├`/`└` of a branch row, and the `│` an ancestor
- * carries down through its descendants' rows.
- */
-export function treeBranchCol(indentCols: number): number {
-  return LAYOUT.LEFT_MARGIN - 1 + indentCols;
-}
-
-/**
- * Column at which a row's segment run begins. Segment runs carry one leading
- * blank by convention (` assistant `, ` ▸ 31 lines `, the fragment's ` ▸ `
- * prefix), so this is the gap column and treeTextCol is where glyphs land.
- */
-export function treeContentCol(indentCols: number): number {
-  return treeBranchCol(indentCols) + 2;
-}
-
-/**
- * Column of a row's first PRINTABLE character. Every row type must land its
- * text here — that is the invariant which makes each level step by exactly
- * TREE_STEP_COLS regardless of whether the row came from an event line, a
- * tool-call row or a collapsed fragment.
- */
-export function treeTextCol(indentCols: number): number {
-  return treeContentCol(indentCols) + 1;
-}
-
-/**
- * Write a branch row's status marker into the shared bullet column.
- *
- * Success and failure differ by GLYPH, not only by colour, so the distinction
- * survives a monochrome terminal and colour-blind viewers. A double-width glyph
- * claims its trailing cell too, so the column math stays honest for emoji-class
- * markers instead of leaving a stale half-character behind.
- */
-export function writeTreeStatusMarker(
-  line: Line,
-  glyph: string | null,
-  fg: string,
-  width: number,
-): void {
-  if (!glyph) return;
-  // THE column: treeBranchCol(0) is where a depth-0 row draws its `●`, so a
-  // branch row's marker lands in the bullet column of the turn it belongs to.
-  // Derived, never restated, so the two cannot drift apart.
-  const col = treeBranchCol(0);
-  if (col < 0 || col >= width) return;
-  const glyphWidth = getDisplayWidth(glyph);
-  if (glyphWidth <= 0) return;
-  line[col] = createStyledCell(glyph, { fg, bold: true });
-  if (glyphWidth > 1 && col + 1 < width) {
-    line[col + 1] = createStyledCell('', { fg, bold: true });
-  }
-}
-
-/**
- * Columns at which ancestor `│` gutters are drawn for a row at `depth`, given
- * the set of ancestor depths whose subtrees are still open.
- *
- * Clamping can push two levels onto the same column at narrow widths; a gutter
- * is emitted only when it lands strictly left of this row's own connector, so
- * a clamped tree degrades by losing gutters rather than by overwriting the
- * connector.
- */
-function treeGutterCols(
-  openAncestorDepths: readonly number[],
-  depth: number,
-  width: number,
-): number[] {
-  const ownCol = treeBranchCol(treeIndentCols(depth, width));
-  const cols: number[] = [];
-  for (const ancestorDepth of openAncestorDepths) {
-    const col = treeBranchCol(treeIndentCols(ancestorDepth, width));
-    if (col < ownCol) cols.push(col);
-  }
-  return cols;
-}
-
-/** True when a rail may claim this cell without destroying rendered content. */
-function railCellIsFree(line: Line, col: number): boolean {
-  const cell = line[col];
-  if (!cell) return false;
-  return cell.char === ' ' && !cell.bg;
-}
-
-function writeRail(line: Line, col: number, glyph: string, fg: string, width: number, force: boolean): void {
-  if (col < 0 || col >= width) return;
-  if (!force && !railCellIsFree(line, col)) return;
-  line[col] = createStyledCell(glyph, { fg, dim: true });
-}
-
-/**
- * Draw a row's connector and every rail that must pass through it, across ALL
- * the lines the row emitted.
- *
- * Line 0 gets the connector in the row's own column (deliberately replacing
- * whatever marker the row drew there — the connector IS that row's marker).
- * Subsequent lines get `│` in that column while the row still has a sibling
- * below it, so the rail runs unbroken from one `├` to the next. Every line
- * additionally gets `│` in each open ancestor's gutter.
- *
- * Connectors and gutters are recomputed from live structure on every rebuild
- * (see conversation-turn-structure.ts), never cached, so a row that stops being
- * last flips `└`→`├` here with nothing stale to invalidate.
- */
-export function drawTreeRails(
-  lines: readonly Line[],
-  depth: number,
-  connector: string | undefined,
-  openAncestorDepths: readonly number[],
-  width: number,
-  fg: string,
-): void {
-  if (depth <= 0 || !connector || lines.length === 0) return;
-  const indent = treeIndentCols(depth, width);
-  if (indent <= 0) return;
-  const ownCol = treeBranchCol(indent);
-  const gutterCols = treeGutterCols(openAncestorDepths, depth, width);
-  const continuesBelow = connector === TREE_CONNECTOR_CONTINUES;
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]!;
-    for (const gutterCol of gutterCols) {
-      writeRail(line, gutterCol, TREE_RAIL, fg, width, false);
-    }
-    if (i === 0) writeRail(line, ownCol, connector, fg, width, true);
-    else if (continuesBelow) writeRail(line, ownCol, TREE_RAIL, fg, width, false);
-  }
-}

package/src/runtime/agent-graph-composition.ts

@@ -1,78 +0,0 @@
-/**
- * agent-graph-composition.ts — the graph that runs agents.
- *
- * Six collaborators that are only meaningful as a set, so they are built as
- * one: a message bus, the archetype loader, the orchestrator that executes a
- * run, the manager that owns the records, the context-accounting holder, and
- * the WRFC controller. Every one of them holds a reference to at least one
- * other, and two of the links are circular — the orchestrator writes
- * conversation snapshots back through the manager, and the manager drives the
- * WRFC controller which was built from the manager. Assembled anywhere but in
- * one place, a half-wired graph looks correct and silently drops either the
- * snapshot bridge or the review loop.
- *
- * It is also the graph whose runs `cancelHostedAgentRuns` cancels at disposal:
- * the manager returned here is the one the runtime hands to the SDK's
- * `cancelAllAgentRuns`.
- */
-import { join } from 'node:path';
-import { AgentMessageBus, AgentOrchestrator, ArchetypeLoader, WrfcController } from '@pellux/goodvibes-sdk/platform/agents';
-import { AgentManager, ContextAccountingHolder } from '@pellux/goodvibes-sdk/platform/tools';
-import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
-import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
-import type { RuntimeEventBus } from '@/runtime/index.ts';
-
-export interface AgentGraph {
-  readonly agentMessageBus: AgentMessageBus;
-  readonly archetypeLoader: ArchetypeLoader;
-  readonly agentOrchestrator: AgentOrchestrator;
-  readonly agentManager: AgentManager;
-  readonly contextAccountingHolder: ContextAccountingHolder;
-  readonly wrfcController: WrfcController;
-}
-
-/** Build the agent-execution graph, fully wired in both directions. */
-export function createAgentGraph(options: {
-  readonly runtimeBus: RuntimeEventBus;
-  readonly workingDirectory: string;
-  readonly configManager: ConfigManager;
-  readonly providerRegistry: ProviderRegistry;
-}): AgentGraph {
-  const agentMessageBus = new AgentMessageBus();
-  agentMessageBus.setRuntimeBus(options.runtimeBus);
-  const archetypeLoader = new ArchetypeLoader(join(options.workingDirectory, '.goodvibes', 'agents'));
-  const agentOrchestrator = new AgentOrchestrator({
-    messageBus: agentMessageBus,
-  });
-  agentOrchestrator.setRuntimeBus(options.runtimeBus);
-  const agentManager = new AgentManager({
-    archetypeLoader,
-    messageBus: agentMessageBus,
-    executor: agentOrchestrator,
-    configManager: options.configManager,
-    // The live registry lets a bare model id in a spawn() override resolve
-    // through the shared resolver instead of being rejected as unqualified.
-    providerRegistry: options.providerRegistry,
-  });
-  const contextAccountingHolder = new ContextAccountingHolder();
-  // Conversation-snapshot bridge (mirrors the SDK's own createRuntimeServices).
-  agentOrchestrator.setConversationSink({
-    register: (agentId, source) => agentManager.registerConversationSource(agentId, source),
-    release: (agentId) => agentManager.releaseConversationSource(agentId),
-  });
-  agentManager.setRuntimeBus(options.runtimeBus);
-  const wrfcController = new WrfcController(options.runtimeBus, agentMessageBus, {
-    agentManager,
-    configManager: options.configManager,
-    projectRoot: options.workingDirectory,
-  });
-  agentManager.setWrfcController(wrfcController);
-  return {
-    agentMessageBus,
-    archetypeLoader,
-    agentOrchestrator,
-    agentManager,
-    contextAccountingHolder,
-    wrfcController,
-  };
-}

package/src/runtime/channel-composition.ts

@@ -1,46 +0,0 @@
-/**
- * channel-composition — route bindings, surface registry, and channel plugin
- * registry for the TUI composition root (split out of services.ts for the
- * line cap).
- *
- * RECORDED DIVERGENCE from the SDK composition root: SurfaceRegistry and
- * ChannelPluginRegistry are constructed WITHOUT the gate manager. The SDK's
- * surface gate map only names six surfaces (web/slack/discord/ntfy/webhook/
- * homeassistant) and reads every other adapter (telegram, whatsapp, signal,
- * imessage, msteams, ...) as OFF whenever a manager is present — no settings
- * key could re-enable them. Until the gate map covers every adapter, the
- * honest governing switch here stays the surfaces.<id>.enabled config each
- * adapter already reads, exactly as the feature surface's own
- * constant-binding rule states. RouteBindingManager keeps its manager — its
- * route-binding gate is a real registry feature.
- */
-
-import { AutomationRouteStore } from '@pellux/goodvibes-sdk/platform/automation';
-import { ChannelPluginRegistry, RouteBindingManager, SurfaceRegistry } from '@pellux/goodvibes-sdk/platform/channels';
-import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
-import type { FeatureFlagManager, RuntimeEventBus } from '@/runtime/index.ts';
-import type { RuntimeStore } from './store/index.ts';
-
-export interface ChannelComposition {
-  readonly routeBindings: RouteBindingManager;
-  readonly surfaceRegistry: SurfaceRegistry;
-  readonly channelPlugins: ChannelPluginRegistry;
-}
-
-export function createChannelComposition(options: {
-  readonly configManager: ConfigManager;
-  readonly runtimeStore: RuntimeStore;
-  readonly runtimeBus: RuntimeEventBus;
-  readonly featureFlags: FeatureFlagManager;
-}): ChannelComposition {
-  const routeBindings = new RouteBindingManager({
-    store: new AutomationRouteStore({ configManager: options.configManager }),
-    runtimeStore: options.runtimeStore,
-    runtimeBus: options.runtimeBus,
-    featureFlags: options.featureFlags,
-  });
-  const surfaceRegistry = new SurfaceRegistry(options.configManager, options.runtimeStore);
-  const channelPlugins = new ChannelPluginRegistry();
-  surfaceRegistry.attachPluginRegistry(channelPlugins);
-  return { routeBindings, surfaceRegistry, channelPlugins };
-}

package/src/runtime/cluster-composition.ts

@@ -1,124 +0,0 @@
-/**
- * cluster-composition.ts — this daemon's seat in the LAN leader election.
- *
- * When the same goodvibes install runs more than once on one network — a
- * laptop and a desktop, or two processes on one machine — every copy
- * independently reads the shared inbox, so one message is picked up twice and
- * answered twice. The SDK's cluster coordinator elects exactly one node to be
- * responsible for inbound consumption; everything else stays warm and silent.
- *
- * This file exists because the goodvibes-tui daemon does NOT get that for free
- * from the SDK facade. The facade gates the consumers IT owns (Telegram
- * ingress, the ntfy/Slack/Discord provider runtime), but this repository
- * composes an inbound consumer of its own — the Slack/Discord/email inbox
- * poller in daemon/handlers/inbox — and the facade knows nothing about it.
- * A fix that only landed in the facade would leave the poller double-reading
- * on exactly the machine this product runs on.
- *
- * So this composition builds the ONE coordinator for the process, registers
- * the inbox poller with it, and hands the same instance to the DaemonServer
- * (via `DaemonConfig.clusterCoordinator`) so the SDK's consumers ride the same
- * leadership rather than holding a second, competing election.
- *
- * What leadership does NOT gate, here or anywhere: outbound delivery,
- * sessions, the control plane, the HTTP listener, the UI. A standby node is a
- * complete goodvibes daemon that simply is not the one reading the inbox.
- */
-import {
-  ClusterCoordinator,
-  inboxSurface,
-  readClusterSettings,
-  type ClusterConsumerGate,
-  type ClusterTransport,
-} from '@pellux/goodvibes-sdk/platform/cluster';
-import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
-import type { ShellPathService } from '@/runtime/index.ts';
-import { logger } from '@pellux/goodvibes-sdk/platform/utils';
-import { GOODVIBES_TUI_SURFACE_ROOT } from '../config/surface.ts';
-import { VERSION } from '../version.ts';
-
-/** What an inbound poller must expose to be placed under leadership. */
-export interface GatedPollerControl {
-  /** Begin polling. Must not resolve until polling has actually begun. */
-  start(): Promise<void>;
-  /** Stop polling. Must not resolve until no further poll can run. */
-  stop(): Promise<void>;
-}
-
-/**
- * Build the process's single coordinator.
- *
- * Constructing it is inert: no socket is opened and no state is written until
- * `start()` runs, so composing a runtime in a test never joins a network.
- *
- * The version is THIS BINARY's version, not the SDK package's — the same
- * distinction daemon/cli.ts already makes for the self-update artifact. It is
- * the first ranking tier, so getting it wrong would let a stale build hold the
- * role through an update.
- */
-export function createClusterComposition(options: {
-  /**
-   * Narrowed to what is actually read, which is exactly what
-   * `readClusterSettings` asks for. The daemon passes a whole ConfigManager;
-   * the handler context carries only this slice, and a test standing in a
-   * minimal config object should not have to fabricate the full fifty-odd
-   * members to compose a coordinator — a cast there would hide a real shape
-   * mismatch rather than document one.
-   */
-  readonly configManager: Pick<ConfigManager, 'getCategory'>;
-  readonly shellPaths: ShellPathService;
-  /**
-   * The datagram transport to coordinate over.
-   *
-   * Supplied by the group layer (cluster-group-composition.ts), which owns the
-   * socket and wraps every election datagram in the group envelope, signed with
-   * the current group key. That is what stops a daemon belonging to somebody
-   * else on the same network from taking part in this election at all.
-   *
-   * Absent — the plain default — means the coordinator opens its own socket and
-   * coordinates with anything that answers on the configured port.
-   */
-  readonly transport?: ClusterTransport | undefined;
-}): ClusterCoordinator {
-  return new ClusterCoordinator({
-    settings: readClusterSettings(options.configManager),
-    version: VERSION,
-    // Surface-scoped, alongside this surface's other durable state: the node
-    // identity is per-surface and must not leak across surface roots.
-    stateDirectory: options.shellPaths.resolveProjectPath(GOODVIBES_TUI_SURFACE_ROOT, 'cluster'),
-    logger,
-    ...(options.transport ? { transport: options.transport } : {}),
-  });
-}
-
-/**
- * ONE inbox provider as a leadership gate.
- *
- * One gate per account, not one for the poller. Each inbox account is its own
- * surface in the election, so this laptop can hold the work Slack account
- * while the desktop holds the mailbox — and losing one machine moves only the
- * accounts it was reading. A single gate covering the whole poller could not
- * express that: it would hand every account over together, and a node with a
- * credential for only one of them could never take part at all.
- *
- * The provider id is the surface's local discriminator and is hashed before it
- * reaches the network, so what travels is a digest and not an account name.
- *
- * No replay cursor is threaded in, and that is deliberate rather than an
- * omission: the inbox keeps a persisted per-provider cursor of its own
- * (InboxCursorStore), so a node taking an account over resumes from where the
- * previous one committed. ntfy needs an explicit `since=` because it has no
- * server-side per-subscriber cursor; this poller does not.
- */
-export function inboxPollerGate(providerId: string, control: GatedPollerControl): ClusterConsumerGate {
-  return {
-    id: `inbox-poller:${providerId}`,
-    surface: inboxSurface(providerId),
-    start: async () => {
-      await control.start();
-    },
-    stop: async () => {
-      await control.stop();
-    },
-  };
-}