nfo-cli 0.0.4-improve-prompting → 0.0.5

package/src/tui/embedded-terminal.ts

@@ -1,325 +0,0 @@
-import xtermHeadless from '@xterm/headless';
-import type { IBufferCell, IBufferLine, Terminal as XTermTerminal } from '@xterm/headless';
-import { spawn, type IPty } from 'node-pty';
-
-const { Terminal } = xtermHeadless;
-
-export interface EmbeddedTerminalSpan {
-  text: string;
-  color?: string;
-  backgroundColor?: string;
-  dimColor?: boolean;
-  bold?: boolean;
-  italic?: boolean;
-  underline?: boolean;
-  strikethrough?: boolean;
-  inverse?: boolean;
-  cursor?: boolean;
-}
-
-export interface EmbeddedTerminalLine {
-  spans: EmbeddedTerminalSpan[];
-}
-
-export interface EmbeddedTerminalSnapshot {
-  title: string;
-  lines: EmbeddedTerminalLine[];
-  connected: boolean;
-}
-
-export interface EmbeddedTerminalOptions {
-  sessionName: string;
-  cwd: string;
-  cols: number;
-  rows: number;
-}
-
-type Listener = (snapshot: EmbeddedTerminalSnapshot) => void;
-type Disposable = { dispose(): void };
-
-function toRgbColor(value: number): string {
-  const red = (value >> 16) & 0xff;
-  const green = (value >> 8) & 0xff;
-  const blue = value & 0xff;
-  return `rgb(${red}, ${green}, ${blue})`;
-}
-
-function toInkColor(cell: IBufferCell, layer: 'foreground' | 'background'): string | undefined {
-  if (layer === 'foreground') {
-    if (cell.isFgRGB()) {
-      return toRgbColor(cell.getFgColor());
-    }
-    if (cell.isFgPalette()) {
-      return `ansi256(${cell.getFgColor()})`;
-    }
-    return undefined;
-  }
-  if (cell.isBgRGB()) {
-    return toRgbColor(cell.getBgColor());
-  }
-  if (cell.isBgPalette()) {
-    return `ansi256(${cell.getBgColor()})`;
-  }
-  return undefined;
-}
-
-function getSpanStyle(cell: IBufferCell): Omit<EmbeddedTerminalSpan, 'text'> {
-  const style: Omit<EmbeddedTerminalSpan, 'text'> = {};
-  const color = toInkColor(cell, 'foreground');
-  const backgroundColor = toInkColor(cell, 'background');
-  if (color !== undefined) {
-    style.color = color;
-  }
-  if (backgroundColor !== undefined) {
-    style.backgroundColor = backgroundColor;
-  }
-  if (cell.isDim() === 1) {
-    style.dimColor = true;
-  }
-  if (cell.isBold() === 1) {
-    style.bold = true;
-  }
-  if (cell.isItalic() === 1) {
-    style.italic = true;
-  }
-  if (cell.isUnderline() === 1) {
-    style.underline = true;
-  }
-  if (cell.isStrikethrough() === 1) {
-    style.strikethrough = true;
-  }
-  if (cell.isInverse() === 1) {
-    style.inverse = true;
-  }
-  return style;
-}
-
-function sameStyle(left: Omit<EmbeddedTerminalSpan, 'text'>, right: Omit<EmbeddedTerminalSpan, 'text'>): boolean {
-  return left.color === right.color
-    && left.backgroundColor === right.backgroundColor
-    && left.dimColor === right.dimColor
-    && left.bold === right.bold
-    && left.italic === right.italic
-    && left.underline === right.underline
-    && left.strikethrough === right.strikethrough
-    && left.inverse === right.inverse
-    && left.cursor === right.cursor;
-}
-
-function appendSpan(spans: EmbeddedTerminalSpan[], next: EmbeddedTerminalSpan): void {
-  if (next.text.length === 0) {
-    return;
-  }
-  const previous = spans.at(-1);
-  if (previous && sameStyle(previous, next)) {
-    previous.text += next.text;
-    return;
-  }
-  spans.push({ ...next });
-}
-
-function hasStyle(span: EmbeddedTerminalSpan): boolean {
-  return span.color !== undefined
-    || span.backgroundColor !== undefined
-    || span.dimColor === true
-    || span.bold === true
-    || span.italic === true
-    || span.underline === true
-    || span.strikethrough === true
-    || span.inverse === true
-    || span.cursor === true;
-}
-
-function trimTrailingPlainWhitespace(spans: EmbeddedTerminalSpan[]): EmbeddedTerminalSpan[] {
-  const trimmed = spans.map((span) => {
-    return { ...span };
-  });
-
-  while (trimmed.length > 0) {
-    const last = trimmed.at(-1);
-    if (!last || hasStyle(last)) {
-      break;
-    }
-    const text = last.text.replace(/\s+$/u, '');
-    if (text.length === 0) {
-      trimmed.pop();
-      continue;
-    }
-    if (text !== last.text) {
-      last.text = text;
-    }
-    break;
-  }
-
-  return trimmed;
-}
-
-function buildLineSnapshot(
-  line: IBufferLine | undefined,
-  cols: number,
-  blankCell: IBufferCell,
-  cursorColumn: number | null,
-): EmbeddedTerminalLine {
-  if (!line) {
-    return cursorColumn === cols
-      ? { spans: [{ text: ' ', cursor: true }] }
-      : { spans: [] };
-  }
-
-  const spans: EmbeddedTerminalSpan[] = [];
-  for (let col = 0; col < cols; col += 1) {
-    const cell = line.getCell(col, blankCell);
-    if (!cell) {
-      appendSpan(spans, { text: ' ' });
-      continue;
-    }
-    if (cell.getWidth() === 0) {
-      continue;
-    }
-
-    const chars = cell.isInvisible() === 1
-      ? ' '.repeat(Math.max(1, cell.getWidth()))
-      : (cell.getChars() || ' ');
-
-    appendSpan(spans, {
-      text: chars,
-      ...getSpanStyle(cell),
-      ...(cursorColumn === col ? { cursor: true } : {}),
-    });
-  }
-
-  if (cursorColumn === cols) {
-    appendSpan(spans, { text: ' ', cursor: true });
-  }
-
-  return {
-    spans: trimTrailingPlainWhitespace(spans),
-  };
-}
-
-export function buildSnapshot(terminal: XTermTerminal, title: string, connected: boolean): EmbeddedTerminalSnapshot {
-  const buffer = terminal.buffer.active;
-  const blankCell = buffer.getNullCell();
-  const cursorRow = (buffer.baseY + buffer.cursorY) - buffer.viewportY;
-  const visibleCursorRow = cursorRow >= 0 && cursorRow < terminal.rows ? cursorRow : null;
-  const visibleCursorColumn = visibleCursorRow !== null ? Math.min(buffer.cursorX, terminal.cols) : null;
-  const lines: EmbeddedTerminalLine[] = [];
-  for (let row = 0; row < terminal.rows; row += 1) {
-    const line = buffer.getLine(buffer.viewportY + row);
-    lines.push(buildLineSnapshot(
-      line,
-      terminal.cols,
-      blankCell,
-      visibleCursorRow === row ? visibleCursorColumn : null,
-    ));
-  }
-
-  return {
-    title,
-    lines,
-    connected,
-  };
-}
-
-export class EmbeddedTerminal {
-  private readonly terminal: XTermTerminal;
-  private readonly pty: IPty;
-  private readonly listeners = new Set<Listener>();
-  private readonly disposables: Disposable[] = [];
-  private title = 'Claude';
-  private connected = true;
-
-  public constructor(options: EmbeddedTerminalOptions) {
-    this.terminal = new Terminal({
-      allowProposedApi: true,
-      cols: options.cols,
-      rows: options.rows,
-      scrollback: 5000,
-    });
-    this.pty = spawn('tmux', ['attach-session', '-t', options.sessionName], {
-      name: 'xterm-256color',
-      cols: options.cols,
-      rows: options.rows,
-      cwd: options.cwd,
-      env: {
-        ...process.env,
-        TERM: 'xterm-256color',
-      },
-    });
-
-    this.disposables.push(
-      this.pty.onData((data) => {
-        this.terminal.write(data, () => {
-          this.publish();
-        });
-      }),
-      this.pty.onExit(() => {
-        this.connected = false;
-        this.publish();
-      }),
-      this.terminal.onTitleChange((title) => {
-        this.title = title.length > 0 ? title : 'Claude';
-        this.publish();
-      }),
-    );
-  }
-
-  public onChange(listener: Listener): () => void {
-    this.listeners.add(listener);
-    listener(this.snapshot());
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-
-  public snapshot(): EmbeddedTerminalSnapshot {
-    return buildSnapshot(this.terminal, this.title, this.connected);
-  }
-
-  public resize(cols: number, rows: number): void {
-    this.pty.resize(cols, rows);
-    this.terminal.resize(cols, rows);
-    this.publish();
-  }
-
-  public scrollPages(pageCount: number): void {
-    this.terminal.scrollPages(pageCount);
-    this.publish();
-  }
-
-  public scrollLines(lineCount: number): void {
-    this.terminal.scrollLines(lineCount);
-    this.publish();
-  }
-
-  public scrollToTop(): void {
-    this.terminal.scrollToTop();
-    this.publish();
-  }
-
-  public scrollToBottom(): void {
-    this.terminal.scrollToBottom();
-    this.publish();
-  }
-
-  public write(data: string): void {
-    this.pty.write(data);
-  }
-
-  public dispose(): void {
-    for (const disposable of this.disposables) {
-      disposable.dispose();
-    }
-    this.disposables.length = 0;
-    this.listeners.clear();
-    this.terminal.dispose();
-    this.pty.kill();
-  }
-
-  private publish(): void {
-    const snapshot = this.snapshot();
-    for (const listener of this.listeners) {
-      listener(snapshot);
-    }
-  }
-}

package/src/tui/format-time.ts

@@ -1,25 +0,0 @@
-export function formatRelativeTime(iso: string, nowIso: string): string {
-  const then = Date.parse(iso);
-  const now = Date.parse(nowIso);
-  if (Number.isNaN(then) || Number.isNaN(now)) {
-    return '?';
-  }
-  const deltaMs = now - then;
-  if (deltaMs < 1000) {
-    return '<1s';
-  }
-  const seconds = Math.floor(deltaMs / 1000);
-  if (seconds < 60) {
-    return `${seconds}s`;
-  }
-  const minutes = Math.floor(seconds / 60);
-  if (minutes < 60) {
-    return `${minutes}m`;
-  }
-  const hours = Math.floor(minutes / 60);
-  if (hours < 24) {
-    return `${hours}h`;
-  }
-  const days = Math.floor(hours / 24);
-  return `${days}d`;
-}

package/src/tui/keymap.ts

@@ -1,104 +0,0 @@
-export interface UiState {
-  selectedIndex: number;
-  musicianCount: number;
-  pendingDismissIndex: number | null;
-}
-
-export interface KeyInput {
-  input: string;
-  downArrow: boolean;
-  upArrow: boolean;
-  tab: boolean;
-  shiftTab: boolean;
-  return: boolean;
-  escape: boolean;
-}
-
-export type KeyAction =
-  | { kind: 'open-target'; selectedIndex: number }
-  | { kind: 'request-dismiss-musician'; index: number }
-  | { kind: 'dismiss-musician'; index: number }
-  | { kind: 'next-orchestra' }
-  | { kind: 'prev-orchestra' }
-  | { kind: 'open-notes' }
-  | { kind: 'detach-session' }
-  | { kind: 'jump-to-pending' }
-  | { kind: 'toggle-help' };
-
-export interface ReduceResult {
-  ui: UiState;
-  action?: KeyAction;
-}
-
-function clamp(value: number, min: number, max: number): number {
-  if (value < min) {
-    return min;
-  }
-  if (value > max) {
-    return max;
-  }
-  return value;
-}
-
-export function reduceKey(ui: UiState, key: KeyInput): ReduceResult {
-  const maxIndex = Math.max(0, ui.musicianCount);
-  const selectedMusicianIndex = ui.selectedIndex - 1;
-
-  if (key.input === 'd') {
-    if (selectedMusicianIndex < 0 || selectedMusicianIndex >= ui.musicianCount) {
-      return { ui };
-    }
-    if (ui.pendingDismissIndex === selectedMusicianIndex) {
-      return {
-        ui: { ...ui, pendingDismissIndex: null },
-        action: { kind: 'dismiss-musician', index: selectedMusicianIndex },
-      };
-    }
-    return {
-      ui: { ...ui, pendingDismissIndex: selectedMusicianIndex },
-      action: { kind: 'request-dismiss-musician', index: selectedMusicianIndex },
-    };
-  }
-
-  if (ui.pendingDismissIndex !== null) {
-    if (key.input === 'y' || key.return) {
-      return {
-        ui: { ...ui, pendingDismissIndex: null },
-        action: { kind: 'dismiss-musician', index: ui.pendingDismissIndex },
-      };
-    }
-    if (key.input === 'n' || key.escape) {
-      return { ui: { ...ui, pendingDismissIndex: null } };
-    }
-    ui = { ...ui, pendingDismissIndex: null };
-  }
-
-  if (key.downArrow || key.input === 'j') {
-    return { ui: { ...ui, selectedIndex: clamp(ui.selectedIndex + 1, 0, maxIndex) } };
-  }
-  if (key.upArrow || key.input === 'k') {
-    return { ui: { ...ui, selectedIndex: clamp(ui.selectedIndex - 1, 0, maxIndex) } };
-  }
-  if (key.tab) {
-    return { ui, action: { kind: 'next-orchestra' } };
-  }
-  if (key.shiftTab) {
-    return { ui, action: { kind: 'prev-orchestra' } };
-  }
-  if (key.return) {
-    return { ui, action: { kind: 'open-target', selectedIndex: ui.selectedIndex } };
-  }
-  if (key.input === 'n') {
-    return { ui, action: { kind: 'open-notes' } };
-  }
-  if (key.input === 'q') {
-    return { ui, action: { kind: 'detach-session' } };
-  }
-  if (key.input === 'p') {
-    return { ui, action: { kind: 'jump-to-pending' } };
-  }
-  if (key.input === '?') {
-    return { ui, action: { kind: 'toggle-help' } };
-  }
-  return { ui };
-}

package/src/tui/poll-activity.ts

@@ -1,25 +0,0 @@
-import { capturePane, sessionName } from '../tmux.js';
-import { extractActivityLine } from './activity-line.js';
-import type { OrchestraState } from '../state.types.js';
-
-/**
- * For each non-stopped musician, capture the last lines of its tmux window
- * and reduce to a single activity hint. Failures (e.g. a window that no longer
- * exists) are swallowed per-musician so one dead pane never breaks the poll.
- */
-export async function pollActivity(state: OrchestraState): Promise<Record<string, string>> {
-  const session = sessionName(state.orchestra_id);
-  const result: Record<string, string> = {};
-  for (const musician of state.musicians) {
-    if (musician.status === 'stopped') {
-      continue;
-    }
-    try {
-      const pane = await capturePane(`${session}:${musician.tmux_window_id}`, 10);
-      result[musician.id] = extractActivityLine(pane);
-    } catch {
-      result[musician.id] = '';
-    }
-  }
-  return result;
-}

package/src/tui/poll-idle.ts

@@ -1,149 +0,0 @@
-import { readState } from '../state.js';
-import type { Musician, OrchestraState } from '../state.types.js';
-import { setMusicianStatus } from '../state-updaters.js';
-import { captureVisiblePane, sessionName } from '../tmux.js';
-import { drainQueuedMusicianMessages } from '../musicians/message.js';
-
-export const IDLE_THRESHOLD_MS = 30_000;
-
-export interface MusicianIdleSnapshot {
-  signature: string;
-  unchangedSince: string;
-}
-
-export type MusicianIdleTracker = Record<string, MusicianIdleSnapshot>;
-
-export interface IdlePollResult {
-  nextTracker: MusicianIdleTracker;
-  idleMusicianIds: string[];
-}
-
-export function hasClaudeInputPrompt(paneText: string): boolean {
-  const lines = paneText
-    .replace(/\u00a0/g, ' ')
-    .replace(/\r/g, '')
-    .split('\n')
-    .map((line) => { return line.trim(); });
-  let promptIndex = -1;
-  for (let index = lines.length - 1; index >= 0; index -= 1) {
-    if (/^(?:❯|>|›)$/.test(lines[index])) {
-      promptIndex = index;
-      break;
-    }
-  }
-  if (promptIndex === -1) {
-    return false;
-  }
-  const trailingNonEmpty = lines.slice(promptIndex + 1).filter((line) => { return line.length > 0; });
-  return trailingNonEmpty.length <= 2;
-}
-
-export function normalisePaneSignature(paneText: string): string {
-  return paneText
-    .replace(/\u00a0/g, ' ')
-    .replace(/\r/g, '')
-    .trimEnd();
-}
-
-function millisSince(earlier: string, later: string): number {
-  const earlierMs = Date.parse(earlier);
-  const laterMs = Date.parse(later);
-  if (Number.isNaN(earlierMs) || Number.isNaN(laterMs)) {
-    return 0;
-  }
-  return laterMs - earlierMs;
-}
-
-function workingMusicians(state: OrchestraState): Musician[] {
-  return state.musicians.filter((musician) => { return musician.status === 'working'; });
-}
-
-export function detectIdleMusicians(
-  state: OrchestraState,
-  panes: Record<string, string>,
-  tracker: MusicianIdleTracker,
-  now = new Date().toISOString(),
-): IdlePollResult {
-  const nextTracker: MusicianIdleTracker = {};
-  const idleMusicianIds: string[] = [];
-
-  for (const musician of workingMusicians(state)) {
-    const paneText = panes[musician.id];
-    if (!paneText) {
-      continue;
-    }
-
-    const signature = normalisePaneSignature(paneText);
-    const promptVisible = hasClaudeInputPrompt(signature);
-    const previous = tracker[musician.id];
-    const unchangedSince = previous?.signature === signature
-      ? previous.unchangedSince
-      : (promptVisible ? musician.last_activity : now);
-
-    nextTracker[musician.id] = {
-      signature,
-      unchangedSince,
-    };
-
-    if (!promptVisible) {
-      continue;
-    }
-
-    if (millisSince(unchangedSince, now) >= IDLE_THRESHOLD_MS) {
-      idleMusicianIds.push(musician.id);
-    }
-  }
-
-  return { nextTracker, idleMusicianIds };
-}
-
-export async function pollIdleMusicians(
-  state: OrchestraState,
-  tracker: MusicianIdleTracker,
-  now = new Date().toISOString(),
-): Promise<IdlePollResult> {
-  const session = sessionName(state.orchestra_id);
-  const panes = Object.fromEntries(await Promise.all(workingMusicians(state).map(async (musician) => {
-    try {
-      const pane = await captureVisiblePane(`${session}:${musician.tmux_window_id}`);
-      return [musician.id, pane] as const;
-    } catch {
-      return [musician.id, ''] as const;
-    }
-  })));
-  return detectIdleMusicians(state, panes, tracker, now);
-}
-
-export async function syncMusicianIdleState(
-  orchestraId: string,
-  tracker: MusicianIdleTracker,
-  now = new Date().toISOString(),
-): Promise<MusicianIdleTracker> {
-  const state = await readState(orchestraId);
-  if (!state) {
-    return {};
-  }
-
-  const { nextTracker, idleMusicianIds } = await pollIdleMusicians(state, tracker, now);
-  for (const musicianId of idleMusicianIds) {
-    try {
-      const fresh = await readState(orchestraId);
-      const musician = fresh?.musicians.find((candidate) => { return candidate.id === musicianId; });
-      if (!musician || musician.status !== 'working') {
-        continue;
-      }
-
-      const deliveredMessages = await drainQueuedMusicianMessages(orchestraId, musicianId);
-      if (deliveredMessages > 0) {
-        await setMusicianStatus(orchestraId, musicianId, 'working', null);
-        continue;
-      }
-
-      await setMusicianStatus(orchestraId, musicianId, 'idle', null);
-    } catch {
-      // Musician state can race with dismissals/restores; keep polling the rest.
-    }
-  }
-
-  return nextTracker;
-}

package/src/tui/poll-permission.ts

@@ -1,50 +0,0 @@
-import { capturePane, sessionName } from '../tmux.js';
-import { detectPermissionPrompt } from './detect-permission.js';
-import type { OrchestraState } from '../state.types.js';
-
-export interface PermissionTransition {
-  musicianId: string;
-  newStatus: 'awaiting_permission' | 'working';
-  pendingPermission: string | null;
-}
-
-/**
- * For each non-stopped musician, capture the last lines of its tmux window,
- * run the permission-prompt detector, and emit a transition only when the
- * detected state differs from the musician's current status. Failures (e.g.
- * a window that no longer exists) are swallowed per-musician so one dead pane
- * never breaks the poll.
- */
-export async function pollPermissions(state: OrchestraState): Promise<PermissionTransition[]> {
-  const session = sessionName(state.orchestra_id);
-  const transitions: PermissionTransition[] = [];
-
-  for (const musician of state.musicians) {
-    if (musician.status === 'stopped') {
-      continue;
-    }
-
-    try {
-      const paneText = await capturePane(`${session}:${musician.tmux_window_id}`, 20);
-      const detected = detectPermissionPrompt(paneText);
-
-      if (detected.pending && musician.status !== 'awaiting_permission') {
-        transitions.push({
-          musicianId: musician.id,
-          newStatus: 'awaiting_permission',
-          pendingPermission: detected.tool ?? 'tool',
-        });
-      } else if (!detected.pending && musician.status === 'awaiting_permission') {
-        transitions.push({
-          musicianId: musician.id,
-          newStatus: 'working',
-          pendingPermission: null,
-        });
-      }
-    } catch {
-      /* swallow — a dead window must not break the poll */
-    }
-  }
-
-  return transitions;
-}

package/src/tui/status-icon.ts

@@ -1,35 +0,0 @@
-import type { MusicianStatus } from '../state.types.js';
-
-export function statusIcon(status: MusicianStatus): string {
-  switch (status) {
-    case 'working': {
-      return '●';
-    }
-    case 'idle': {
-      return '◐';
-    }
-    case 'awaiting_permission': {
-      return '⚠';
-    }
-    case 'stopped': {
-      return '○';
-    }
-  }
-}
-
-export function statusColor(status: MusicianStatus): string {
-  switch (status) {
-    case 'working': {
-      return 'green';
-    }
-    case 'idle': {
-      return 'yellow';
-    }
-    case 'awaiting_permission': {
-      return 'red';
-    }
-    case 'stopped': {
-      return 'gray';
-    }
-  }
-}