@cdoing/opentuicli 0.1.2

package/src/lib/autocomplete.ts

@@ -0,0 +1,258 @@
+/**
+ * Autocomplete engine — slash commands, @mentions, path completion, tool subcommands
+ *
+ * Ported from @cdoing/cli UserInput.tsx logic for the OpenTUI terminal.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+
+// ── Slash Commands ────────────────────────────────────────
+
+export interface SlashCommand {
+  name: string;
+  description: string;
+}
+
+export const SLASH_COMMANDS: SlashCommand[] = [
+  { name: "/help", description: "Show available commands" },
+  { name: "/clear", description: "Clear chat history" },
+  { name: "/new", description: "Start new conversation" },
+  { name: "/model", description: "Show/change model" },
+  { name: "/provider", description: "Show/change provider" },
+  { name: "/mode", description: "Cycle permission mode" },
+  { name: "/usage", description: "Show token usage & cost" },
+  { name: "/compact", description: "Compress context" },
+  { name: "/config", description: "Show/set configuration" },
+  { name: "/dir", description: "Change working directory" },
+  { name: "/history", description: "Browse past sessions" },
+  { name: "/ls", description: "List conversations" },
+  { name: "/resume", description: "Resume conversation by ID" },
+  { name: "/view", description: "View a conversation" },
+  { name: "/fork", description: "Fork current conversation" },
+  { name: "/delete", description: "Delete a conversation" },
+  { name: "/plan", description: "Toggle plan mode" },
+  { name: "/tasks", description: "Show active tasks" },
+  { name: "/memory", description: "Show agent memory" },
+  { name: "/permissions", description: "Show permission rules" },
+  { name: "/hooks", description: "Show configured hooks" },
+  { name: "/rules", description: "Show project rules" },
+  { name: "/mcp", description: "MCP server management" },
+  { name: "/context", description: "Show context providers" },
+  { name: "/effort", description: "Set effort level" },
+  { name: "/theme", description: "Switch theme" },
+  { name: "/bg", description: "Run in background" },
+  { name: "/jobs", description: "Show background jobs" },
+  { name: "/login", description: "OAuth login" },
+  { name: "/logout", description: "OAuth logout" },
+  { name: "/setup", description: "Run setup wizard" },
+  { name: "/doctor", description: "Check system health" },
+  { name: "/init", description: "Initialize project config" },
+  { name: "/exit", description: "Quit the TUI" },
+  { name: "/quit", description: "Quit the TUI" },
+  { name: "/btw", description: "Ask without adding to history" },
+  { name: "/auth-status", description: "Show authentication status" },
+  { name: "/queue", description: "Show message queue" },
+];
+
+// ── @Mention Providers ────────────────────────────────────
+
+export interface MentionProvider {
+  trigger: string;
+  description: string;
+}
+
+export const MENTION_PROVIDERS: MentionProvider[] = [
+  { trigger: "@terminal", description: "Recent terminal output" },
+  { trigger: "@url", description: "Fetch URL content" },
+  { trigger: "@tree", description: "Project file tree" },
+  { trigger: "@codebase", description: "Full codebase context" },
+  { trigger: "@clip", description: "Clipboard content" },
+  { trigger: "@file", description: "Include a file" },
+];
+
+// ── Tool Subcommands ──────────────────────────────────────
+
+const TOOL_SUBCOMMANDS: Record<string, string[]> = {
+  npm: ["install", "run", "test", "start", "build", "init", "publish", "uninstall", "update", "ls", "audit", "ci"],
+  yarn: ["install", "add", "remove", "run", "build", "test", "start", "dev", "upgrade", "info", "why"],
+  pnpm: ["install", "add", "remove", "run", "build", "test", "dev", "update", "store"],
+  bun: ["install", "add", "remove", "run", "build", "test", "dev", "init", "create"],
+  git: ["status", "add", "commit", "push", "pull", "fetch", "checkout", "branch", "merge", "rebase", "log", "diff", "stash", "reset", "clone", "remote", "tag", "cherry-pick", "bisect", "show", "blame", "reflog"],
+  docker: ["build", "run", "exec", "ps", "images", "pull", "push", "stop", "rm", "logs", "compose"],
+  python: ["-m", "-c", "--version", "manage.py"],
+  python3: ["-m", "-c", "--version", "manage.py"],
+  pip: ["install", "uninstall", "freeze", "list", "show"],
+  cargo: ["build", "run", "test", "check", "clippy", "fmt", "new", "init", "add", "publish"],
+  go: ["build", "run", "test", "get", "mod", "fmt", "vet", "install", "generate"],
+  make: ["build", "test", "clean", "install", "all"],
+  kubectl: ["get", "describe", "apply", "delete", "logs", "exec", "port-forward", "scale"],
+  gh: ["pr", "issue", "repo", "run", "release", "api", "auth", "browse"],
+  turbo: ["build", "dev", "test", "lint", "run"],
+  npx: ["tsc", "ts-node", "eslint", "prettier", "jest", "vitest", "playwright"],
+};
+
+// ── Suggestion Types ──────────────────────────────────────
+
+export interface Suggestion {
+  text: string;
+  description?: string;
+  type: "command" | "mention" | "file" | "subcommand";
+}
+
+// ── Autocomplete Logic ────────────────────────────────────
+
+export function getCompletions(input: string, workingDir: string): Suggestion[] {
+  if (!input) return [];
+
+  // Slash commands
+  if (input.startsWith("/")) {
+    return SLASH_COMMANDS
+      .filter((c) => c.name.startsWith(input))
+      .map((c) => ({ text: c.name, description: c.description, type: "command" as const }));
+  }
+
+  // @mentions
+  if (input.startsWith("@") || input.includes(" @")) {
+    const atIdx = input.lastIndexOf("@");
+    const query = input.substring(atIdx);
+
+    const results: Suggestion[] = [];
+
+    // Provider matches
+    for (const p of MENTION_PROVIDERS) {
+      if (p.trigger.startsWith(query)) {
+        results.push({ text: p.trigger, description: p.description, type: "mention" });
+      }
+    }
+
+    // File matches for @file or bare @
+    if (query === "@" || query.startsWith("@file ") || query.startsWith("@f")) {
+      const fileQuery = query.startsWith("@file ") ? query.substring(6) : "";
+      const files = getProjectFiles(workingDir, fileQuery);
+      for (const f of files.slice(0, 10)) {
+        results.push({ text: `@file ${f}`, description: "", type: "file" });
+      }
+    }
+
+    return results;
+  }
+
+  // Tool subcommands (e.g. "npm " → show npm subcommands)
+  const parts = input.split(" ");
+  if (parts.length >= 1) {
+    const tool = parts[0];
+    const subcommands = TOOL_SUBCOMMANDS[tool];
+    if (subcommands && parts.length <= 2) {
+      const sub = parts[1] || "";
+      return subcommands
+        .filter((s) => s.startsWith(sub))
+        .map((s) => ({ text: `${tool} ${s}`, description: "", type: "subcommand" as const }));
+    }
+  }
+
+  // Path completion for shell commands (cd, ls, cat, etc.)
+  if (parts.length >= 2) {
+    const pathResults = getPathCompletions(input, workingDir);
+    if (pathResults.length > 0) {
+      const prefix = parts.slice(0, -1).join(" ") + " ";
+      return pathResults.map((p) => ({
+        text: prefix + p,
+        description: p.endsWith("/") ? "directory" : "file",
+        type: "file" as const,
+      }));
+    }
+  }
+
+  return [];
+}
+
+// ── Ghost Text ────────────────────────────────────────────
+
+export function getGhostText(input: string, workingDir: string): string {
+  if (!input) return "";
+
+  // Slash command ghost
+  if (input.startsWith("/")) {
+    const match = SLASH_COMMANDS.find((c) => c.name.startsWith(input) && c.name !== input);
+    return match ? match.name.substring(input.length) : "";
+  }
+
+  // @mention ghost
+  const atIdx = input.lastIndexOf("@");
+  if (atIdx >= 0 && atIdx === input.length - input.substring(atIdx).length) {
+    const query = input.substring(atIdx);
+    const match = MENTION_PROVIDERS.find((p) => p.trigger.startsWith(query) && p.trigger !== query);
+    return match ? match.trigger.substring(query.length) : "";
+  }
+
+  return "";
+}
+
+// ── Path Completion ───────────────────────────────────────
+
+export function getPathCompletions(input: string, workingDir: string): string[] {
+  // Detect path context: commands like cd, ls, cat, etc.
+  const pathCommands = ["cd", "ls", "cat", "head", "tail", "less", "more", "vim", "nano", "code", "open", "rm", "cp", "mv", "mkdir", "touch", "chmod"];
+  const parts = input.split(" ");
+  if (parts.length < 2) return [];
+
+  const cmd = parts[0];
+  if (!pathCommands.includes(cmd)) return [];
+
+  const partial = parts[parts.length - 1] || "";
+  return readPathEntries(workingDir, partial);
+}
+
+function readPathEntries(workingDir: string, partial: string): string[] {
+  try {
+    const dir = partial.includes("/")
+      ? path.resolve(workingDir, partial.substring(0, partial.lastIndexOf("/") + 1))
+      : workingDir;
+    const prefix = partial.includes("/") ? partial.substring(partial.lastIndexOf("/") + 1) : partial;
+
+    if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return [];
+
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const base = partial.includes("/") ? partial.substring(0, partial.lastIndexOf("/") + 1) : "";
+
+    return entries
+      .filter((e) => !e.name.startsWith(".") || partial.startsWith("."))
+      .filter((e) => e.name.toLowerCase().startsWith(prefix.toLowerCase()))
+      .sort((a, b) => {
+        if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
+        return a.name.localeCompare(b.name);
+      })
+      .slice(0, 20)
+      .map((e) => base + e.name + (e.isDirectory() ? "/" : ""));
+  } catch {
+    return [];
+  }
+}
+
+function getProjectFiles(workingDir: string, query: string): string[] {
+  const results: string[] = [];
+  const lower = query.toLowerCase();
+  const skipDirs = new Set(["node_modules", ".git", "dist", "build", "__pycache__", ".cache", "coverage"]);
+
+  const walk = (dir: string, rel: string, depth: number) => {
+    if (depth > 3 || results.length >= 15) return;
+    try {
+      const entries = fs.readdirSync(path.join(workingDir, dir), { withFileTypes: true });
+      for (const e of entries) {
+        if (e.name.startsWith(".") || skipDirs.has(e.name)) continue;
+        if (results.length >= 15) break;
+        const p = rel ? `${rel}/${e.name}` : e.name;
+        if (e.isDirectory()) {
+          if (!query || p.toLowerCase().includes(lower)) results.push(p + "/");
+          walk(path.join(dir, e.name), p, depth + 1);
+        } else {
+          if (!query || p.toLowerCase().includes(lower)) results.push(p);
+        }
+      }
+    } catch { /* skip */ }
+  };
+
+  walk("", "", 0);
+  return results;
+}

package/src/lib/context-providers.ts

@@ -0,0 +1,98 @@
+/**
+ * Context Provider Expansion — resolves @mentions in user messages
+ *
+ * Detects @terminal, @url, @tree, @codebase, @clip, @file triggers
+ * and expands them into the actual content before sending to the agent.
+ */
+
+import {
+  ContextProviderRegistry,
+  TerminalContextProvider,
+  UrlContextProvider,
+  TreeContextProvider,
+  CodebaseContextProvider,
+  ClipboardContextProvider,
+  FileIncludeContextProvider,
+} from "@cdoing/core";
+
+let registry: ContextProviderRegistry | null = null;
+let terminalProvider: TerminalContextProvider | null = null;
+
+function getRegistry(): ContextProviderRegistry {
+  if (!registry) {
+    registry = new ContextProviderRegistry();
+    terminalProvider = new TerminalContextProvider();
+    registry.register(terminalProvider);
+    registry.register(new UrlContextProvider());
+    registry.register(new TreeContextProvider());
+    registry.register(new CodebaseContextProvider());
+    registry.register(new ClipboardContextProvider());
+    registry.register(new FileIncludeContextProvider());
+  }
+  return registry;
+}
+
+/** Update terminal provider with recent shell output */
+export function pushTerminalOutput(output: string): void {
+  getRegistry();
+  if (terminalProvider && typeof (terminalProvider as any).push === "function") {
+    (terminalProvider as any).push(output);
+  }
+}
+
+/** Known @mention triggers */
+const TRIGGERS = ["@terminal", "@url", "@tree", "@codebase", "@clip", "@file"];
+
+/**
+ * Resolve all @mention providers in a message.
+ * Returns the expanded message with provider content appended.
+ */
+export async function resolveContextProviders(
+  message: string,
+  workingDir: string
+): Promise<string> {
+  const reg = getRegistry();
+  let expandedMessage = message;
+  const appendSections: string[] = [];
+
+  for (const trigger of TRIGGERS) {
+    const idx = expandedMessage.indexOf(trigger);
+    if (idx === -1) continue;
+
+    // Extract the trigger + argument
+    const afterTrigger = expandedMessage.substring(idx + trigger.length);
+    const endIdx = afterTrigger.search(/\s@|\n|$/);
+    const arg = afterTrigger.substring(0, endIdx === -1 ? afterTrigger.length : endIdx).trim();
+
+    // Remove trigger from message
+    const fullTrigger = trigger + (arg ? " " + arg : "");
+    expandedMessage = expandedMessage.replace(fullTrigger, "").trim();
+
+    // Resolve
+    const providerName = trigger.substring(1); // strip @
+    const provider = reg.get(providerName);
+    if (!provider) continue;
+
+    try {
+      const result = await provider.resolve(arg, { workingDir });
+      if (result) {
+        appendSections.push(`--- ${trigger} ---\n${result}`);
+      }
+    } catch {
+      // Silently skip failed providers
+    }
+  }
+
+  if (appendSections.length > 0) {
+    expandedMessage = expandedMessage + "\n\n" + appendSections.join("\n\n");
+  }
+
+  return expandedMessage;
+}
+
+/**
+ * Check if a message contains any @mention triggers.
+ */
+export function hasContextMentions(message: string): boolean {
+  return TRIGGERS.some((t) => message.includes(t));
+}

package/src/lib/history.ts

@@ -0,0 +1,164 @@
+/**
+ * Conversation History Manager for TUI
+ *
+ * Saves conversations to ~/.cdoing/conversations/ as JSON files.
+ * Mirrors the base CLI implementation for full compatibility.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+const CONV_DIR = path.join(os.homedir(), ".cdoing", "conversations");
+
+export interface ChatMessage {
+  role: "user" | "assistant" | "tool";
+  content: string;
+  toolName?: string;
+  timestamp: number;
+}
+
+export interface Conversation {
+  id: string;
+  title: string;
+  createdAt: number;
+  updatedAt: number;
+  provider: string;
+  model: string;
+  messages: ChatMessage[];
+}
+
+function ensureDir(): void {
+  if (!fs.existsSync(CONV_DIR)) fs.mkdirSync(CONV_DIR, { recursive: true });
+}
+
+function generateId(): string {
+  const now = Date.now().toString(36);
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `${now}-${rand}`;
+}
+
+function deriveTitle(message: string): string {
+  const clean = message.replace(/\n/g, " ").trim();
+  return clean.length > 60 ? clean.substring(0, 57) + "..." : clean;
+}
+
+export function createConversation(provider: string, model: string): Conversation {
+  ensureDir();
+  return {
+    id: generateId(),
+    title: "New conversation",
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    provider,
+    model,
+    messages: [],
+  };
+}
+
+export function addMessage(
+  conv: Conversation,
+  role: "user" | "assistant" | "tool",
+  content: string,
+  toolName?: string
+): void {
+  conv.messages.push({ role, content, timestamp: Date.now(), toolName });
+  conv.updatedAt = Date.now();
+
+  if (role === "user" && conv.title === "New conversation") {
+    conv.title = deriveTitle(content);
+  }
+
+  saveConversation(conv);
+}
+
+export function saveConversation(conv: Conversation): void {
+  ensureDir();
+  const filePath = path.join(CONV_DIR, `${conv.id}.json`);
+  fs.writeFileSync(filePath, JSON.stringify(conv, null, 2), "utf-8");
+}
+
+export function loadConversation(id: string): Conversation | null {
+  // Support partial IDs
+  ensureDir();
+  const files = fs.readdirSync(CONV_DIR).filter((f) => f.endsWith(".json"));
+  const match = files.find((f) => f.startsWith(id) || f.replace(".json", "") === id);
+  if (!match) return null;
+
+  const filePath = path.join(CONV_DIR, match);
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+export function listConversations(): Conversation[] {
+  ensureDir();
+  const files = fs.readdirSync(CONV_DIR).filter((f) => f.endsWith(".json"));
+  const convs: Conversation[] = [];
+
+  for (const file of files) {
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(CONV_DIR, file), "utf-8"));
+      convs.push(data);
+    } catch {}
+  }
+
+  return convs.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+
+export function loadLastConversation(): Conversation | null {
+  const all = listConversations();
+  return all.length > 0 ? all[0] : null;
+}
+
+export function deleteConversation(id: string): boolean {
+  ensureDir();
+  const files = fs.readdirSync(CONV_DIR).filter((f) => f.endsWith(".json"));
+  const match = files.find((f) => f.startsWith(id) || f.replace(".json", "") === id);
+  if (match) {
+    fs.unlinkSync(path.join(CONV_DIR, match));
+    return true;
+  }
+  return false;
+}
+
+export function forkConversation(idOrConv: string | Conversation): Conversation | null {
+  const original =
+    typeof idOrConv === "string" ? loadConversation(idOrConv) : idOrConv;
+  if (!original) return null;
+
+  ensureDir();
+  const forked: Conversation = {
+    ...original,
+    id: generateId(),
+    title: `Fork of: ${original.title}`,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    messages: original.messages.map((m) => ({ ...m })),
+  };
+  saveConversation(forked);
+  return forked;
+}
+
+export function updateConversationTitle(id: string, title: string): void {
+  const conv = loadConversation(id);
+  if (!conv) return;
+  conv.title = title.length > 80 ? title.substring(0, 77) + "..." : title;
+  conv.updatedAt = Date.now();
+  saveConversation(conv);
+}
+
+export function formatRelativeDate(timestamp: number): string {
+  const diff = Date.now() - timestamp;
+  const seconds = Math.floor(diff / 1000);
+  if (seconds < 60) return "just now";
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 30) return `${days}d ago`;
+  return new Date(timestamp).toLocaleDateString();
+}

package/src/lib/terminal-title.ts

@@ -0,0 +1,15 @@
+/**
+ * Terminal Title — set/reset the terminal window title via escape sequences
+ */
+
+export function setTerminalTitle(title: string): void {
+  if (process.stdout.isTTY) {
+    process.stdout.write(`\x1b]0;${title}\x07`);
+  }
+}
+
+export function resetTerminalTitle(): void {
+  if (process.stdout.isTTY) {
+    process.stdout.write(`\x1b]0;\x07`);
+  }
+}

package/src/routes/home.tsx

@@ -0,0 +1,148 @@
+/**
+ * Home Route — landing screen with logo, project info, shortcuts, and quick actions
+ *
+ * Responsive: adapts layout based on terminal dimensions.
+ *   - Small terminals (< 60 cols or < 20 rows): compact layout, no logo
+ *   - Medium terminals: smaller logo, condensed info
+ *   - Large terminals: full figlet logo, spacious layout
+ */
+
+import { TextAttributes } from "@opentui/core";
+import { useTerminalDimensions } from "@opentui/react";
+import { useTheme } from "../context/theme";
+import { InputArea } from "../components/input-area";
+import type { ImageAttachment } from "@cdoing/ai";
+
+// Full figlet logo (ANSI Shadow)
+const LOGO_FULL = [
+  " ██████╗██████╗  ██████╗ ██╗███╗   ██╗ ██████╗ ",
+  "██╔════╝██╔══██╗██╔═══██╗██║████╗  ██║██╔════╝ ",
+  "██║     ██║  ██║██║   ██║██║██╔██╗ ██║██║  ███╗",
+  "██║     ██║  ██║██║   ██║██║██║╚██╗██║██║   ██║",
+  "╚██████╗██████╔╝╚██████╔╝██║██║ ╚████║╚██████╔╝",
+  " ╚═════╝╚═════╝  ╚═════╝ ╚═╝╚═╝  ╚═══╝ ╚═════╝ ",
+];
+
+// Compact logo for smaller terminals
+const LOGO_COMPACT = [
+  "┌─┐┌┐ ┌─┐┬┌┐┌┌─┐",
+  "│  │││ ││││││││ ┬",
+  "└─┘└┘└─┘└─┘┘└┘└─┘",
+];
+
+export function Home(props: {
+  provider: string;
+  model: string;
+  workingDir: string;
+  themeId: string;
+  onAction?: (action: string) => void;
+  onSubmit?: (text: string, images?: ImageAttachment[]) => void;
+}) {
+  const { theme } = useTheme();
+  const t = theme;
+  const dims = useTerminalDimensions();
+  const w = dims.width || 80;
+  const h = dims.height || 24;
+
+  const shortDir = () => {
+    const home = process.env.HOME || "";
+    const d = props.workingDir;
+    return home && d.startsWith(home) ? "~" + d.slice(home.length) : d;
+  };
+
+  const subtitle = "Multi-provider AI coding assistant";
+  const version = "v0.1.1";
+
+  // Determine layout size
+  const isSmall = w < 60 || h < 20;
+  const isMedium = !isSmall && (w < 80 || h < 30);
+
+  // Pick logo
+  const logo = isSmall ? null : isMedium ? LOGO_COMPACT : LOGO_FULL;
+
+  // Build info lines
+  const infoLines = [
+    ["Provider", props.provider],
+    ["Model", props.model],
+    ["Theme", props.themeId],
+    ["Directory", shortDir()],
+  ];
+  const maxKeyLen = Math.max(...infoLines.map(([k]) => k.length));
+
+  // Quick actions
+  const actions = [
+    { key: "Enter", label: "Send message / start session", id: "start" },
+    { key: "Ctrl+P", label: "Switch model", id: "model" },
+    { key: "Ctrl+T", label: "Change theme", id: "theme" },
+    { key: "Ctrl+N", label: "New session", id: "new" },
+    { key: "Ctrl+S", label: "Browse sessions", id: "sessions" },
+    { key: "Ctrl+X", label: "Command palette", id: "commands" },
+    { key: "/setup", label: "Setup wizard", id: "setup" },
+    { key: "Ctrl+C", label: "Quit", id: "quit" },
+  ];
+  const maxActionKey = Math.max(...actions.map((a) => a.key.length));
+
+  return (
+    <box flexDirection="column" flexGrow={1} flexShrink={1} overflow="hidden">
+      <box flexDirection="column" alignItems="center" justifyContent="center" flexGrow={1}>
+        {/* Logo */}
+        {logo && logo.map((line, i) => (
+          <text key={`logo-${i}`} fg={t.primary} attributes={TextAttributes.BOLD}>
+            {line}
+          </text>
+        ))}
+
+        {/* Subtitle + version */}
+        <text fg={t.textDim}>
+          {subtitle}
+        </text>
+        <text fg={t.textMuted}>
+          {version}
+        </text>
+
+        <text>{""}</text>
+
+        {/* Info section */}
+        {infoLines.map(([key, val], i) => {
+          const line = `${key.padStart(maxKeyLen)}  ${val}`;
+          return (
+            <text key={`info-${i}`} fg={t.textDim}>
+              {line}
+            </text>
+          );
+        })}
+
+        <text>{""}</text>
+
+        {/* Actions */}
+        <text fg={t.primary} attributes={TextAttributes.BOLD}>
+          {"Actions"}
+        </text>
+        {actions.map((action, i) => {
+          const line = `${action.key.padStart(maxActionKey)}   ${action.label}`;
+          return (
+            <text key={`act-${i}`} fg={t.textMuted}>
+              {line}
+            </text>
+          );
+        })}
+
+        <text>{""}</text>
+
+        {/* Footer */}
+        <text fg={t.textDim}>
+          {"Powered by @opentui/react + @cdoing/ai"}
+        </text>
+      </box>
+
+      {/* Input bar at bottom — user can start typing immediately */}
+      {props.onSubmit && (
+        <InputArea
+          onSubmit={props.onSubmit}
+          workingDir={props.workingDir}
+          placeholder="Start typing to begin a session... (/ commands, @ context)"
+        />
+      )}
+    </box>
+  );
+}