tycono 0.1.95 → 0.1.96-beta.1

package/bin/tycono.ts

@@ -20,6 +20,8 @@ function printHelp(): void {
 
   Usage:
     tycono [path]       Start the server (optionally point to a company directory)
+    tycono tui          Start API server + TUI mode
+    tycono tui --attach Connect TUI to existing API server
     tycono --help       Show this help message
     tycono --version    Show version
 
@@ -27,6 +29,8 @@ function printHelp(): void {
     tycono                      Start in current directory
     tycono ./my-company         Start with existing company folder
     tycono /path/to/akb         Start with absolute path
+    tycono tui                  Start with terminal UI
+    PORT=3000 tycono tui --attach  Attach TUI to running server
 
   AI Engine (auto-detected):
     1. Claude Code CLI       Install from https://claude.ai/download (recommended)
@@ -190,6 +194,49 @@ async function startServer(): Promise<void> {
   process.on('SIGTERM', shutdown);
 }
 
+async function startServerForTui(): Promise<void> {
+  // Load .env from current directory
+  const dotenvPath = path.resolve(process.cwd(), '.env');
+  if (fs.existsSync(dotenvPath)) {
+    const { config } = await import('dotenv');
+    config({ path: dotenvPath });
+  }
+
+  if (!process.env.COMPANY_ROOT) {
+    process.env.COMPANY_ROOT = process.cwd();
+  }
+
+  process.env.NODE_ENV = 'production';
+  const auth = detectAuth();
+  process.env.EXECUTION_ENGINE = auth.engine === 'claude-cli' ? 'claude-cli' : auth.engine === 'direct-api' ? 'direct-api' : 'none';
+
+  const port = process.env.PORT ? Number(process.env.PORT) : await findFreePort();
+  process.env.PORT = String(port);
+
+  const { createHttpServer } = await import('../src/api/src/create-server.js');
+  const server = createHttpServer();
+
+  const host = process.env.HOST || '0.0.0.0';
+
+  await new Promise<void>((resolve) => {
+    server.listen(port, host, () => resolve());
+  });
+
+  console.log(`  API server started on port ${port}`);
+
+  // Graceful shutdown
+  const shutdown = () => {
+    server.close(() => process.exit(0));
+    setTimeout(() => process.exit(1), 5000);
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  // Start TUI
+  const { startTui } = await import('../src/tui/index.tsx');
+  await startTui({ port });
+}
+
 export async function main(args: string[]): Promise<void> {
   const command = args[0];
 
@@ -203,6 +250,22 @@ export async function main(args: string[]): Promise<void> {
     return;
   }
 
+  // tui subcommand: start API server + TUI mode
+  if (command === 'tui') {
+    const attachMode = args.includes('--attach');
+    // If --attach, skip server start — just connect to existing API
+    if (attachMode) {
+      const port = process.env.PORT ? Number(process.env.PORT) : 3000;
+      const { startTui } = await import('../src/tui/index.tsx');
+      await startTui({ port });
+      return;
+    }
+
+    // Start API server, then TUI
+    await startServerForTui();
+    return;
+  }
+
   if (command && !command.startsWith('-')) {
     // Treat as path to company directory
     const resolved = path.resolve(command);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tycono",
-  "version": "0.1.95",
+  "version": "0.1.96-beta.1",
   "description": "Build an AI company. Watch them work.",
   "type": "module",
   "bin": {
@@ -11,6 +11,7 @@
     "src/api/src/",
     "src/api/package.json",
     "src/shared/",
+    "src/tui/",
     "src/web/dist/",
     "templates/"
   ],
@@ -36,7 +37,12 @@
     "express": "^5.0.1",
     "glob": "^11.0.1",
     "gray-matter": "^4.0.3",
+    "ink": "^5.2.1",
+    "ink-select-input": "^6.2.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
     "marked": "^15.0.6",
+    "react": "^18.3.1",
     "tsx": "^4.19.3",
     "tyconoforge": "^0.1.0-beta.0",
     "yaml": "^2.7.0"
@@ -45,6 +51,7 @@
     "@types/cors": "^2.8.17",
     "@types/express": "^5.0.0",
     "@types/node": "^22.13.4",
+    "@types/react": "^19.2.14",
     "tsup": "^8.5.1",
     "typescript": "^5.7.3"
   },

package/src/tui/api.ts

@@ -0,0 +1,241 @@
+/**
+ * TUI API Client — HTTP + SSE for communicating with Tycono API server
+ */
+
+import http from 'node:http';
+
+let BASE_URL = 'http://localhost:3000';
+
+export function setBaseUrl(url: string): void {
+  BASE_URL = url.replace(/\/$/, '');
+}
+
+export function getBaseUrl(): string {
+  return BASE_URL;
+}
+
+/* ─── HTTP helpers ─── */
+
+async function fetchJson<T>(path: string, options?: { method?: string; body?: unknown }): Promise<T> {
+  const url = `${BASE_URL}${path}`;
+  const method = options?.method ?? 'GET';
+  const bodyStr = options?.body ? JSON.stringify(options.body) : undefined;
+
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const req = http.request(
+      {
+        hostname: urlObj.hostname,
+        port: urlObj.port,
+        path: urlObj.pathname + urlObj.search,
+        method,
+        headers: {
+          'Content-Type': 'application/json',
+          ...(bodyStr ? { 'Content-Length': Buffer.byteLength(bodyStr) } : {}),
+        },
+      },
+      (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(data) as T);
+          } catch {
+            reject(new Error(`Invalid JSON from ${path}: ${data.slice(0, 200)}`));
+          }
+        });
+      },
+    );
+    req.on('error', reject);
+    if (bodyStr) req.write(bodyStr);
+    req.end();
+  });
+}
+
+/* ─── API Types ─── */
+
+export interface RoleInfo {
+  id: string;
+  name: string;
+  level: string;
+  reportsTo: string;
+  status: string;
+}
+
+export interface CompanyInfo {
+  name: string;
+  domain: string;
+  founded: string;
+  mission: string;
+  roles: RoleInfo[];
+}
+
+export interface SessionInfo {
+  id: string;
+  roleId: string;
+  title: string;
+  mode: string;
+  status: string;
+  source: string;
+  waveId?: string;
+  createdAt: string;
+}
+
+export interface ExecStatus {
+  statuses: Record<string, string>;
+  activeExecutions: Array<{
+    id: string;
+    roleId: string;
+    task: string;
+    startedAt: string;
+  }>;
+}
+
+export interface WaveResponse {
+  waveId: string;
+  supervisorSessionId?: string;
+  mode: string;
+  directive: string;
+}
+
+export interface SSEEvent {
+  seq: number;
+  ts: string;
+  type: string;
+  roleId: string;
+  data: Record<string, unknown>;
+}
+
+/* ─── API calls ─── */
+
+export async function fetchCompany(): Promise<CompanyInfo> {
+  return fetchJson<CompanyInfo>('/api/company');
+}
+
+export async function fetchRoles(): Promise<RoleInfo[]> {
+  return fetchJson<RoleInfo[]>('/api/roles');
+}
+
+export async function fetchSessions(): Promise<SessionInfo[]> {
+  return fetchJson<SessionInfo[]>('/api/sessions');
+}
+
+export async function fetchExecStatus(): Promise<ExecStatus> {
+  return fetchJson<ExecStatus>('/api/exec/status');
+}
+
+export async function dispatchWave(directive: string, options?: {
+  targetRoles?: string[];
+  continuous?: boolean;
+}): Promise<WaveResponse> {
+  return fetchJson<WaveResponse>('/api/jobs', {
+    method: 'POST',
+    body: {
+      type: 'wave',
+      directive,
+      targetRoles: options?.targetRoles,
+      continuous: options?.continuous ?? false,
+    },
+  });
+}
+
+export async function sendDirective(waveId: string, text: string): Promise<{ ok: boolean }> {
+  return fetchJson<{ ok: boolean }>(`/api/waves/${waveId}/directive`, {
+    method: 'POST',
+    body: { text },
+  });
+}
+
+export async function fetchActiveWaves(): Promise<{ waves: Array<{ waveId: string; sessionIds: string[] }> }> {
+  return fetchJson('/api/waves/active');
+}
+
+/* ─── SSE stream ─── */
+
+export interface SSEConnection {
+  close(): void;
+}
+
+export function subscribeToWaveStream(
+  waveId: string,
+  onEvent: (event: SSEEvent) => void,
+  onEnd?: (reason: string) => void,
+  fromSeq?: number,
+): SSEConnection {
+  const url = new URL(`${BASE_URL}/api/waves/${waveId}/stream`);
+  if (fromSeq) url.searchParams.set('from', String(fromSeq));
+
+  let destroyed = false;
+  let req: http.ClientRequest | null = null;
+
+  const connect = () => {
+    req = http.get(url.toString(), (res) => {
+      let buffer = '';
+
+      res.on('data', (chunk: Buffer) => {
+        if (destroyed) return;
+        buffer += chunk.toString();
+
+        // Parse SSE format
+        const parts = buffer.split('\n\n');
+        buffer = parts.pop() ?? '';
+
+        for (const part of parts) {
+          if (!part.trim() || part.startsWith(':')) continue;
+
+          const lines = part.split('\n');
+          let eventType = '';
+          let data = '';
+
+          for (const line of lines) {
+            if (line.startsWith('event: ')) {
+              eventType = line.slice(7);
+            } else if (line.startsWith('data: ')) {
+              data = line.slice(6);
+            }
+          }
+
+          if (eventType === 'activity' && data) {
+            try {
+              onEvent(JSON.parse(data) as SSEEvent);
+            } catch { /* ignore parse errors */ }
+          } else if (eventType === 'stream:end' && data) {
+            try {
+              const parsed = JSON.parse(data);
+              onEnd?.(parsed.reason ?? 'unknown');
+            } catch {
+              onEnd?.('unknown');
+            }
+          }
+        }
+      });
+
+      res.on('end', () => {
+        if (!destroyed) {
+          onEnd?.('disconnected');
+        }
+      });
+
+      res.on('error', () => {
+        if (!destroyed) {
+          onEnd?.('error');
+        }
+      });
+    });
+
+    req.on('error', () => {
+      if (!destroyed) {
+        onEnd?.('error');
+      }
+    });
+  };
+
+  connect();
+
+  return {
+    close() {
+      destroyed = true;
+      req?.destroy();
+    },
+  };
+}

package/src/tui/app.tsx

@@ -0,0 +1,230 @@
+/**
+ * TUI App — main layout with 4 panels
+ *
+ * Layout:
+ * ┌─────────────────────────────────────────┐
+ * │ StatusBar                               │
+ * ├──────────────┬──────────────────────────┤
+ * │ OrgTree      │ StreamPanel              │
+ * │              │                          │
+ * ├──────────────┤                          │
+ * │ SessionList  │                          │
+ * ├──────────────┴──────────────────────────┤
+ * │ CommandInput                            │
+ * └─────────────────────────────────────────┘
+ */
+
+import React, { useState, useCallback, useMemo } from 'react';
+import { Box, Text, useApp } from 'ink';
+import { StatusBar } from './components/StatusBar';
+import { OrgTree } from './components/OrgTree';
+import { SessionList } from './components/SessionList';
+import { StreamPanel } from './components/StreamPanel';
+import { CommandInput } from './components/CommandInput';
+import { WaveDialog } from './components/WaveDialog';
+import { HelpOverlay } from './components/HelpOverlay';
+import { useApi } from './hooks/useApi';
+import { useSSE } from './hooks/useSSE';
+import { useKeyboard } from './hooks/useKeyboard';
+import { buildOrgTree } from './store';
+import { dispatchWave } from './api';
+
+type Panel = 'org' | 'sessions' | 'stream' | 'command';
+type Dialog = 'none' | 'wave' | 'help';
+
+const PANELS: Panel[] = ['org', 'sessions', 'stream', 'command'];
+
+export const App: React.FC = () => {
+  const { exit } = useApp();
+  const api = useApi();
+
+  const [activePanel, setActivePanel] = useState<Panel>('org');
+  const [dialog, setDialog] = useState<Dialog>('none');
+  const [selectedRoleIndex, setSelectedRoleIndex] = useState(0);
+  const [selectedSessionIndex, setSelectedSessionIndex] = useState(0);
+  const [waveId, setWaveId] = useState<string | null>(null);
+  const [waveStatus, setWaveStatus] = useState<'idle' | 'running' | 'done'>('idle');
+
+  // Derive active wave from API if we don't have one
+  const effectiveWaveId = waveId ?? api.activeWaveId;
+
+  const sse = useSSE(effectiveWaveId);
+
+  // Build org tree
+  const roles = api.company?.roles ?? [];
+  const flatRoleIds = useMemo(() => roles.map(r => r.id), [roles]);
+  const statuses = api.execStatus?.statuses ?? {};
+  const orgTree = useMemo(() => buildOrgTree(roles, statuses), [roles, statuses]);
+
+  // Count active
+  const activeCount = Object.values(statuses).filter(s => s === 'working' || s === 'streaming').length;
+
+  // Determine wave status from SSE
+  const derivedWaveStatus = useMemo(() => {
+    if (sse.streamStatus === 'streaming') return 'running' as const;
+    if (sse.streamStatus === 'done') return 'done' as const;
+    if (waveStatus === 'running' && activeCount > 0) return 'running' as const;
+    return waveStatus;
+  }, [sse.streamStatus, waveStatus, activeCount]);
+
+  // Handle wave dispatch
+  const handleWaveSubmit = useCallback(async (directive: string) => {
+    setDialog('none');
+    try {
+      const result = await dispatchWave(directive);
+      setWaveId(result.waveId);
+      setWaveStatus('running');
+      sse.clearEvents();
+      api.refresh();
+    } catch (err) {
+      // Show error briefly
+      console.error('Wave dispatch failed:', err);
+    }
+  }, [sse, api]);
+
+  // Keyboard actions — disabled when dialog is open
+  const keyboardEnabled = dialog === 'none';
+
+  useKeyboard({
+    onWave: () => setDialog('wave'),
+    onQuit: () => exit(),
+    onHelp: () => setDialog(dialog === 'help' ? 'none' : 'help'),
+    onTab: () => {
+      const idx = PANELS.indexOf(activePanel);
+      setActivePanel(PANELS[(idx + 1) % PANELS.length]);
+    },
+    onUp: () => {
+      if (activePanel === 'org') {
+        setSelectedRoleIndex(Math.max(0, selectedRoleIndex - 1));
+      } else if (activePanel === 'sessions') {
+        setSelectedSessionIndex(Math.max(0, selectedSessionIndex - 1));
+      }
+    },
+    onDown: () => {
+      if (activePanel === 'org') {
+        setSelectedRoleIndex(Math.min(flatRoleIds.length - 1, selectedRoleIndex + 1));
+      } else if (activePanel === 'sessions') {
+        setSelectedSessionIndex(Math.min(Math.max(0, api.sessions.length - 1), selectedSessionIndex + 1));
+      }
+    },
+    onEnter: () => {
+      // Future: select role/session to show in stream
+    },
+    onEscape: () => {
+      if (dialog !== 'none') {
+        setDialog('none');
+      }
+    },
+  }, keyboardEnabled);
+
+  // Error display
+  if (api.error) {
+    return (
+      <Box flexDirection="column" paddingX={1}>
+        <Text color="cyan" bold>TYCONO TUI</Text>
+        <Text color="red">API Error: {api.error}</Text>
+        <Text color="gray">Make sure the API server is running on the configured port.</Text>
+        <Text color="gray" dimColor>Press q to quit</Text>
+      </Box>
+    );
+  }
+
+  // Help overlay
+  if (dialog === 'help') {
+    return (
+      <Box flexDirection="column">
+        <StatusBar
+          companyName={api.company?.name ?? 'Loading...'}
+          waveId={effectiveWaveId}
+          waveStatus={derivedWaveStatus}
+          activeCount={activeCount}
+          totalCost={0}
+        />
+        <HelpOverlay onClose={() => setDialog('none')} />
+      </Box>
+    );
+  }
+
+  // Wave dialog
+  if (dialog === 'wave') {
+    return (
+      <Box flexDirection="column">
+        <StatusBar
+          companyName={api.company?.name ?? 'Loading...'}
+          waveId={effectiveWaveId}
+          waveStatus={derivedWaveStatus}
+          activeCount={activeCount}
+          totalCost={0}
+        />
+        <WaveDialog
+          onSubmit={handleWaveSubmit}
+          onCancel={() => setDialog('none')}
+        />
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column">
+      {/* Status Bar */}
+      <StatusBar
+        companyName={api.company?.name ?? 'Loading...'}
+        waveId={effectiveWaveId}
+        waveStatus={derivedWaveStatus}
+        activeCount={activeCount}
+        totalCost={0}
+      />
+
+      {/* Separator */}
+      <Box width="100%">
+        <Text color="gray">{'\u2500'.repeat(70)}</Text>
+      </Box>
+
+      {/* Main content: left (org + sessions) | right (stream) */}
+      <Box flexGrow={1}>
+        {/* Left column */}
+        <Box flexDirection="column" width={28}>
+          <OrgTree
+            tree={orgTree}
+            focused={activePanel === 'org'}
+            selectedIndex={selectedRoleIndex}
+            flatRoles={flatRoleIds}
+          />
+          <Box marginTop={1}>
+            <SessionList
+              sessions={api.sessions}
+              focused={activePanel === 'sessions'}
+              selectedIndex={selectedSessionIndex}
+            />
+          </Box>
+        </Box>
+
+        {/* Vertical separator */}
+        <Box flexDirection="column" marginX={0}>
+          <Text color="gray">{'\u2502\n'.repeat(15)}</Text>
+        </Box>
+
+        {/* Right column: Stream */}
+        <StreamPanel
+          events={sse.events}
+          allRoleIds={flatRoleIds}
+          focused={activePanel === 'stream'}
+          streamStatus={sse.streamStatus}
+          waveId={effectiveWaveId}
+        />
+      </Box>
+
+      {/* Separator */}
+      <Box width="100%">
+        <Text color="gray">{'\u2500'.repeat(70)}</Text>
+      </Box>
+
+      {/* Command Input */}
+      <CommandInput
+        focused={activePanel === 'command'}
+        waveStatus={derivedWaveStatus}
+        dialog={dialog}
+      />
+    </Box>
+  );
+};

package/src/tui/components/CommandInput.tsx

@@ -0,0 +1,32 @@
+/**
+ * CommandInput — bottom bar with command input and shortcut hints
+ */
+
+import React from 'react';
+import { Box, Text } from 'ink';
+
+interface CommandInputProps {
+  focused: boolean;
+  waveStatus: 'idle' | 'running' | 'done';
+  dialog: string;
+}
+
+export const CommandInput: React.FC<CommandInputProps> = ({ focused, waveStatus, dialog }) => {
+  if (dialog !== 'none') return null;
+
+  return (
+    <Box width="100%" paddingX={1} justifyContent="space-between">
+      <Box>
+        <Text color="green" bold>&gt; </Text>
+        <Text color={focused ? 'white' : 'gray'}>
+          {waveStatus === 'running' ? 'Wave running...' : 'Ready'}
+        </Text>
+      </Box>
+      <Box>
+        <Text color="gray" dimColor>
+          [w]ave  [?]help  [q]uit  [Tab]panel
+        </Text>
+      </Box>
+    </Box>
+  );
+};

package/src/tui/components/HelpOverlay.tsx

@@ -0,0 +1,51 @@
+/**
+ * HelpOverlay — keyboard shortcut reference
+ */
+
+import React from 'react';
+import { Box, Text, useInput } from 'ink';
+
+interface HelpOverlayProps {
+  onClose(): void;
+}
+
+const shortcuts = [
+  ['w', 'Wave dispatch'],
+  ['q', 'Quit'],
+  ['?', 'Toggle help'],
+  ['Tab', 'Cycle panels'],
+  ['j/k', 'Navigate (in focused panel)'],
+  ['Enter', 'Select'],
+  ['Esc', 'Close dialog / deselect'],
+] as const;
+
+export const HelpOverlay: React.FC<HelpOverlayProps> = ({ onClose }) => {
+  useInput((input, key) => {
+    if (input === '?' || input === 'q' || key.escape) {
+      onClose();
+    }
+  });
+
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="round"
+      borderColor="yellow"
+      paddingX={2}
+      paddingY={1}
+    >
+      <Text bold color="yellow">{'\u2500\u2500'} Keyboard Shortcuts {'\u2500\u2500'}</Text>
+      <Box marginTop={1} flexDirection="column">
+        {shortcuts.map(([key, desc]) => (
+          <Box key={key}>
+            <Text color="cyan" bold>{key.padEnd(8)}</Text>
+            <Text color="white">{desc}</Text>
+          </Box>
+        ))}
+      </Box>
+      <Box marginTop={1}>
+        <Text color="gray" dimColor>Press ? or Esc to close</Text>
+      </Box>
+    </Box>
+  );
+};