@wenathlan/devthink 1.1.1

package/session.ts

@@ -0,0 +1,155 @@
+/** DevThink session model: one stable identity contract for CLI, gateway, local database, and URL-addressable web state. */
+import { existsSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { ensurePaths, type DevThinkPaths } from "./config.ts";
+import type { ChatMessage } from "./providers.ts";
+import { createCompactId } from "./ids.ts";
+import { mirrorSession, type StoredSession, type StoredWorkspace } from "./storage.ts";
+
+export type SessionSection = "chat" | "inspector" | "settings" | "memory" | "providers" | "projects" | "routes" | "usage";
+export type SessionTab = { id: string; sessionId: string; workspaceId: string; label: string; provider?: string; sectionId: SessionSection; createdAt: string; updatedAt: string };
+export type SessionMessage = ChatMessage & { id: string; sessionId: string; workspaceId: string; tabId: string; sectionId: SessionSection; createdAt: string };
+export type Workspace = { id: string; title: string; createdAt: string; updatedAt: string };
+
+export type Session = {
+  id: string;
+  workspaceId: string;
+  title: string;
+  mode: string;
+  model?: string;
+  provider?: string;
+  createdAt: string;
+  updatedAt: string;
+  activeTabId: string;
+  tabs: SessionTab[];
+  messages: SessionMessage[];
+};
+
+function sessionPath(paths: DevThinkPaths, id: string): string {
+  return join(paths.sessions, `${id}.json`);
+}
+
+function safeTitle(messages: SessionMessage[]): string {
+  const first = messages.find((message) => message.role === "user");
+  return first?.content.slice(0, 80) || "Untitled session";
+}
+
+function workspacePath(paths: DevThinkPaths, id: string): string {
+  return join(paths.workspaces, `${id}.json`);
+}
+
+function atomicWrite(path: string, value: unknown): void {
+  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+  renameSync(temporary, path);
+}
+
+function newWorkspace(id = createCompactId("w"), title = "Untitled workspace", now = new Date().toISOString()): Workspace {
+  return { id, title, createdAt: now, updatedAt: now };
+}
+
+function newTab(sessionId: string, workspaceId: string, provider: string | undefined, label: string, sectionId: SessionSection, now: string, id = createCompactId("t")): SessionTab {
+  return { id, sessionId, workspaceId, provider, label, sectionId, createdAt: now, updatedAt: now };
+}
+
+function normalizeSession(raw: Session): Session {
+  const now = raw.updatedAt || new Date().toISOString();
+  const workspaceId = raw.workspaceId || createCompactId("w");
+  const tabs = raw.tabs?.length ? raw.tabs.map((tab) => ({ ...tab, sessionId: raw.id, workspaceId, sectionId: tab.sectionId || "chat" as SessionSection })) : [newTab(raw.id, workspaceId, raw.provider, raw.title || "Untitled session", "chat", now)];
+  const activeTabId = tabs.some((tab) => tab.id === raw.activeTabId) ? raw.activeTabId : tabs[0].id;
+  const messages = (raw.messages || []).map((message) => ({ ...message, id: message.id || createCompactId("m"), sessionId: raw.id, workspaceId, tabId: message.tabId || activeTabId, sectionId: message.sectionId || "chat" as SessionSection, createdAt: message.createdAt || now }));
+  return { ...raw, workspaceId, activeTabId, tabs, messages };
+}
+
+function readSession(path: string): Session | undefined {
+  try {
+    if (!existsSync(path)) return undefined;
+    return normalizeSession(JSON.parse(readFileSync(path, "utf8")) as Session);
+  } catch {
+    return undefined;
+  }
+}
+
+function workspaceFor(session: Session): Workspace {
+  const title = session.title === "Untitled session" ? "Untitled workspace" : session.title;
+  return newWorkspace(session.workspaceId, title, session.createdAt);
+}
+
+function saveSession(paths: DevThinkPaths, session: Session): Session {
+  ensurePaths(paths);
+  const normalized = normalizeSession(session);
+  const existing = loadWorkspace(paths, normalized.workspaceId);
+  const workspace = { ...(existing || workspaceFor(normalized)), title: normalized.title === "Untitled session" ? existing?.title || "Untitled workspace" : normalized.title, updatedAt: normalized.updatedAt };
+  atomicWrite(sessionPath(paths, normalized.id), normalized);
+  atomicWrite(workspacePath(paths, workspace.id), workspace);
+  mirrorSession(paths, workspace as StoredWorkspace, normalized as StoredSession);
+  return normalized;
+}
+
+export function createWorkspace(paths: DevThinkPaths, title = "Untitled workspace", id = createCompactId("w")): Workspace {
+  ensurePaths(paths);
+  const workspace = newWorkspace(id, title);
+  atomicWrite(workspacePath(paths, id), workspace);
+  return workspace;
+}
+
+export function loadWorkspace(paths: DevThinkPaths, id: string): Workspace | undefined {
+  try {
+    if (!existsSync(workspacePath(paths, id))) return undefined;
+    return JSON.parse(readFileSync(workspacePath(paths, id), "utf8")) as Workspace;
+  } catch {
+    return undefined;
+  }
+}
+
+export function createSession(paths: DevThinkPaths, metadata: Pick<Session, "mode" | "model" | "provider"> & { workspaceId?: string; tabId?: string; sectionId?: SessionSection; title?: string }): Session {
+  const now = new Date().toISOString();
+  const id = createCompactId("s");
+  const workspace = metadata.workspaceId ? loadWorkspace(paths, metadata.workspaceId) || createWorkspace(paths, "Untitled workspace", metadata.workspaceId) : createWorkspace(paths);
+  const tab = newTab(id, workspace.id, metadata.provider, metadata.title || "Untitled session", metadata.sectionId || "chat", now, metadata.tabId);
+  const session: Session = { id, workspaceId: workspace.id, title: metadata.title || "Untitled session", mode: metadata.mode, model: metadata.model, provider: metadata.provider, createdAt: now, updatedAt: now, activeTabId: tab.id, tabs: [tab], messages: [] };
+  return saveSession(paths, session);
+}
+
+export function loadSession(paths: DevThinkPaths, id: string): Session | undefined {
+  const session = readSession(sessionPath(paths, id));
+  return session ? saveSession(paths, session) : undefined;
+}
+
+export function createTab(paths: DevThinkPaths, session: Session, input: { id?: string; label?: string; provider?: string; sectionId?: SessionSection }): Session {
+  const now = new Date().toISOString();
+  const tab = newTab(session.id, session.workspaceId, input.provider || session.provider, input.label || "New session", input.sectionId || "chat", now, input.id);
+  return saveSession(paths, { ...session, activeTabId: tab.id, updatedAt: now, tabs: [...session.tabs, tab] });
+}
+
+export function updateTab(paths: DevThinkPaths, session: Session, tabId: string, input: Partial<Pick<SessionTab, "label" | "provider" | "sectionId">>): Session {
+  const now = new Date().toISOString();
+  const tabs = session.tabs.map((tab) => tab.id === tabId ? { ...tab, ...input, updatedAt: now } : tab);
+  if (!tabs.some((tab) => tab.id === tabId)) throw new Error(`Tab not found: ${tabId}`);
+  return saveSession(paths, { ...session, activeTabId: tabId, updatedAt: now, tabs });
+}
+
+export function appendMessage(paths: DevThinkPaths, session: Session, message: ChatMessage, context?: { tabId?: string; sectionId?: SessionSection; id?: string }): Session {
+  const now = new Date().toISOString();
+  const tabId = context?.tabId || session.activeTabId;
+  if (!session.tabs.some((tab) => tab.id === tabId)) throw new Error(`Tab not found: ${tabId}`);
+  const nextMessages = [...session.messages, { ...message, id: context?.id || createCompactId("m"), sessionId: session.id, workspaceId: session.workspaceId, tabId, sectionId: context?.sectionId || "chat", createdAt: now }];
+  return saveSession(paths, { ...session, title: safeTitle(nextMessages), updatedAt: now, messages: nextMessages });
+}
+
+export function listSessions(paths: DevThinkPaths): Session[] {
+  if (!existsSync(paths.sessions)) return [];
+  return readdirSync(paths.sessions).filter((file) => file.endsWith(".json") && !file.endsWith(".memory.json")).map((file) => readSession(join(paths.sessions, file))).filter((session): session is Session => Boolean(session)).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+
+export function renderSessionMarkdown(session: Session): string {
+  const lines = [`# ${session.title}`, "", `- Workspace: ${session.workspaceId}`, `- Session: ${session.id}`, `- Active tab: ${session.activeTabId}`, `- Mode: ${session.mode}`, `- Provider: ${session.provider || "not configured"}`, `- Model: ${session.model || "not configured"}`, ""];
+  for (const message of session.messages) lines.push(`## ${message.role}`, "", message.content, "");
+  return `${lines.join("\n")}\n`;
+}
+
+export function exportSession(paths: DevThinkPaths, id: string, format: "json" | "markdown"): string {
+  const session = loadSession(paths, id);
+  if (!session) throw new Error(`Session not found: ${id}`);
+  return format === "json" ? `${JSON.stringify(session, null, 2)}\n` : renderSessionMarkdown(session);
+}

package/storage.ts

@@ -0,0 +1,51 @@
+/** DevThink local store: mirrors credential-free workbench records into a physical SQLite database. */
+import type { DevThinkPaths } from "./config.ts";
+
+type Statement = { run: (...values: unknown[]) => unknown };
+type Database = { exec: (sql: string) => unknown; prepare: (sql: string) => Statement; close: () => void };
+type DatabaseConstructor = new (path: string) => Database;
+
+const sqliteModule = await import(process.versions.bun ? "bun:sqlite" : "node:sqlite");
+const DatabaseDriver = (process.versions.bun ? sqliteModule.Database : sqliteModule.DatabaseSync) as unknown as DatabaseConstructor;
+
+export type StoredWorkspace = { id: string; title: string; createdAt: string; updatedAt: string };
+export type StoredTab = { id: string; sessionId: string; workspaceId: string; label: string; provider?: string; sectionId: string; createdAt: string; updatedAt: string };
+export type StoredMessage = { id: string; sessionId: string; workspaceId: string; tabId: string; sectionId: string; role: string; content: string; createdAt: string };
+export type StoredSession = { id: string; workspaceId: string; title: string; mode: string; model?: string; provider?: string; activeTabId: string; createdAt: string; updatedAt: string; tabs: StoredTab[]; messages: StoredMessage[] };
+
+function initialize(database: Database): void {
+  database.exec(`
+    PRAGMA journal_mode = WAL;
+    PRAGMA foreign_keys = ON;
+    CREATE TABLE IF NOT EXISTS workspaces (id TEXT PRIMARY KEY, title TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);
+    CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, workspace_id TEXT NOT NULL, title TEXT NOT NULL, mode TEXT NOT NULL, model TEXT, provider TEXT, active_tab_id TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);
+    CREATE TABLE IF NOT EXISTS tabs (id TEXT PRIMARY KEY, session_id TEXT NOT NULL, workspace_id TEXT NOT NULL, label TEXT NOT NULL, provider TEXT, section_id TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);
+    CREATE TABLE IF NOT EXISTS messages (id TEXT PRIMARY KEY, session_id TEXT NOT NULL, workspace_id TEXT NOT NULL, tab_id TEXT NOT NULL, section_id TEXT NOT NULL, role TEXT NOT NULL, content TEXT NOT NULL, created_at TEXT NOT NULL);
+    CREATE INDEX IF NOT EXISTS sessions_workspace_updated ON sessions(workspace_id, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS tabs_session_updated ON tabs(session_id, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS messages_session_created ON messages(session_id, created_at ASC);
+  `);
+}
+
+/** Executes a local SQLite transaction without allowing database failures to erase JSON-compatible records. */
+export function mirrorSession(paths: DevThinkPaths, workspace: StoredWorkspace, session: StoredSession): void {
+  let database: Database | undefined;
+  try {
+    database = new DatabaseDriver(paths.database);
+    initialize(database);
+    database.exec("BEGIN IMMEDIATE");
+    database.prepare("INSERT INTO workspaces (id, title, created_at, updated_at) VALUES (?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET title = excluded.title, updated_at = excluded.updated_at").run(workspace.id, workspace.title, workspace.createdAt, workspace.updatedAt);
+    database.prepare("INSERT INTO sessions (id, workspace_id, title, mode, model, provider, active_tab_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET workspace_id = excluded.workspace_id, title = excluded.title, mode = excluded.mode, model = excluded.model, provider = excluded.provider, active_tab_id = excluded.active_tab_id, updated_at = excluded.updated_at").run(session.id, session.workspaceId, session.title, session.mode, session.model ?? null, session.provider ?? null, session.activeTabId, session.createdAt, session.updatedAt);
+    database.prepare("DELETE FROM tabs WHERE session_id = ?").run(session.id);
+    database.prepare("DELETE FROM messages WHERE session_id = ?").run(session.id);
+    const addTab = database.prepare("INSERT INTO tabs (id, session_id, workspace_id, label, provider, section_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
+    const addMessage = database.prepare("INSERT INTO messages (id, session_id, workspace_id, tab_id, section_id, role, content, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
+    for (const tab of session.tabs) addTab.run(tab.id, tab.sessionId, tab.workspaceId, tab.label, tab.provider ?? null, tab.sectionId, tab.createdAt, tab.updatedAt);
+    for (const message of session.messages) addMessage.run(message.id, message.sessionId, message.workspaceId, message.tabId, message.sectionId, message.role, message.content, message.createdAt);
+    database.exec("COMMIT");
+  } catch {
+    try { database?.exec("ROLLBACK"); } catch { /* JSON compatibility record remains the authoritative fallback. */ }
+  } finally {
+    database?.close();
+  }
+}

package/stream.ts

@@ -0,0 +1,130 @@
+export type ChatEvent =
+  | { type: "start"; provider: string; model: string }
+  | { type: "text"; text: string }
+  | { type: "reasoning"; text: string }
+  | { type: "tool"; name: string; input: unknown }
+  | { type: "error"; message: string }
+  | { type: "finish"; reason?: string };
+
+export type StreamOptions = {
+  provider: string;
+  model: string;
+  signal?: AbortSignal;
+};
+
+function decodeJson(value: string): Record<string, unknown> | null {
+  try {
+    const parsed: unknown = JSON.parse(value);
+    return parsed && typeof parsed === "object" ? (parsed as Record<string, unknown>) : null;
+  } catch {
+    return null;
+  }
+}
+
+function extractSseFrames(buffer: { value: string }, incoming: string): string[] {
+  buffer.value += incoming;
+  const frames = buffer.value.split(/\r?\n\r?\n/);
+  buffer.value = frames.pop() || "";
+  return frames;
+}
+
+function extractData(frame: string): string | null {
+  const lines = frame.split(/\r?\n/).filter((line) => line.startsWith("data:"));
+  if (lines.length === 0) return null;
+  const value = lines.map((line) => line.slice(5).trimStart()).join("\n").trim();
+  return value && value !== "[DONE]" ? value : null;
+}
+
+function textAt(value: unknown): string {
+  return typeof value === "string" ? value : "";
+}
+
+function normalizeOpenAi(frame: Record<string, unknown>): ChatEvent[] {
+  const choices = Array.isArray(frame.choices) ? frame.choices : [];
+  const choice = choices[0] as Record<string, unknown> | undefined;
+  const delta = (choice?.delta || {}) as Record<string, unknown>;
+  const events: ChatEvent[] = [];
+  const reasoning = textAt(delta.reasoning_content || delta.reasoning);
+  const text = textAt(delta.content);
+  if (reasoning) events.push({ type: "reasoning", text: reasoning });
+  if (text) events.push({ type: "text", text });
+  const finish = choice?.finish_reason;
+  if (finish) events.push({ type: "finish", reason: textAt(finish) });
+  return events;
+}
+
+function normalizeAnthropic(frame: Record<string, unknown>): ChatEvent[] {
+  const type = textAt(frame.type);
+  if (type === "content_block_delta") {
+    const delta = (frame.delta || {}) as Record<string, unknown>;
+    const text = textAt(delta.text);
+    return text ? [{ type: "text", text }] : [];
+  }
+  if (type === "message_stop") return [{ type: "finish", reason: "stop" }];
+  if (type === "error") {
+    const error = (frame.error || {}) as Record<string, unknown>;
+    return [{ type: "error", message: textAt(error.message) || "Anthropic returned an error." }];
+  }
+  return [];
+}
+
+function normalizeGoogle(frame: Record<string, unknown>): ChatEvent[] {
+  const candidates = Array.isArray(frame.candidates) ? frame.candidates : [];
+  const content = ((candidates[0] as Record<string, unknown> | undefined)?.content || {}) as Record<string, unknown>;
+  const parts = Array.isArray(content.parts) ? content.parts : [];
+  const events: ChatEvent[] = [];
+  for (const part of parts) {
+    const item = part as Record<string, unknown>;
+    const text = textAt(item.text);
+    if (text) events.push({ type: "text", text });
+  }
+  const finish = textAt((candidates[0] as Record<string, unknown> | undefined)?.finishReason);
+  if (finish) events.push({ type: "finish", reason: finish });
+  return events;
+}
+
+export function normalizeFrame(provider: string, frame: Record<string, unknown>): ChatEvent[] {
+  const lower = provider.toLowerCase();
+  if (lower === "anthropic") return normalizeAnthropic(frame);
+  if (lower === "google") return normalizeGoogle(frame);
+  const data = (frame.data || frame) as Record<string, unknown>;
+  if (data !== frame && textAt(data.delta_content)) return [{ type: "text", text: textAt(data.delta_content) }];
+  if (data !== frame && textAt(data.reasoning_content)) return [{ type: "reasoning", text: textAt(data.reasoning_content) }];
+  if (data.error || frame.error) return [{ type: "error", message: textAt(data.error || frame.error) || "The provider returned an error." }];
+  return normalizeOpenAi(frame);
+}
+
+export async function* parseEventStream(response: Response, options: StreamOptions): AsyncGenerator<ChatEvent> {
+  if (!response.body) throw new Error("The provider returned an empty stream.");
+  yield { type: "start", provider: options.provider, model: options.model };
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  const buffer = { value: "" };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      for (const frame of extractSseFrames(buffer, decoder.decode(value, { stream: true }))) {
+        const payload = extractData(frame);
+        if (!payload) continue;
+        const parsed = decodeJson(payload);
+        if (!parsed) continue;
+        for (const event of normalizeFrame(options.provider, parsed)) yield event;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  yield { type: "finish", reason: "stop" };
+}
+
+export async function collectEvents(events: AsyncIterable<ChatEvent>): Promise<{ text: string; reasoning: string }> {
+  let text = "";
+  let reasoning = "";
+  for await (const event of events) {
+    if (event.type === "text") text += event.text;
+    if (event.type === "reasoning") reasoning += event.text;
+    if (event.type === "error") throw new Error(event.message);
+  }
+  return { text, reasoning };
+}

package/sync.ts

@@ -0,0 +1,27 @@
+import { getIdentity } from "./identity.ts";
+import { listSessions, loadWorkspace, type Session, type Workspace } from "./session.ts";
+import { isSecureRemoteEndpoint } from "./compatibility.ts";
+import type { DevThinkConfig, DevThinkPaths } from "./config.ts";
+
+export type SyncSnapshot = { version: 1; userId: string; deviceId: string; exportedAt: string; workspaces: Workspace[]; sessions: Session[] };
+export type RemoteSyncStatus = { enabled: boolean; endpoint?: string; ready: boolean; reason?: string };
+
+export function exportLocalSnapshot(paths: DevThinkPaths): SyncSnapshot {
+  const identity = getIdentity(paths);
+  const sessions = listSessions(paths);
+  const workspaces = [...new Set(sessions.map((session) => session.workspaceId))].flatMap((workspaceId) => {
+    const workspace = loadWorkspace(paths, workspaceId);
+    return workspace ? [workspace] : [];
+  });
+  return { version: 1, userId: identity.userId, deviceId: identity.deviceId, exportedAt: new Date().toISOString(), workspaces, sessions };
+}
+
+export function remoteSyncStatus(config: DevThinkConfig): RemoteSyncStatus {
+  const remote = config.web?.remoteSync;
+  if (!remote?.enabled) return { enabled: false, ready: false, reason: "Remote synchronization is disabled; local pairing remains available." };
+  if (!remote.endpoint) return { enabled: true, ready: false, reason: "Set web.remoteSync.endpoint to a user-operated HTTPS API that implements the DevThink sync contract." };
+  if (!isSecureRemoteEndpoint(remote.endpoint)) {
+    return { enabled: true, endpoint: remote.endpoint, ready: false, reason: "Remote synchronization endpoint is not a valid HTTPS URL." };
+  }
+  return { enabled: true, endpoint: new URL(remote.endpoint).toString(), ready: true };
+}

package/ui.ts

@@ -0,0 +1,122 @@
+import type { ChatEvent } from "./stream.ts";
+
+export const colors = {
+  background: "\u001b[38;5;236m",
+  panel: "\u001b[38;5;238m",
+  text: "\u001b[38;5;252m",
+  muted: "\u001b[38;5;245m",
+  cyan: "\u001b[38;5;116m",
+  blue: "\u001b[38;5;110m",
+  green: "\u001b[38;5;151m",
+  red: "\u001b[38;5;167m",
+  yellow: "\u001b[38;5;222m",
+  reset: "\u001b[0m",
+  bold: "\u001b[1m",
+};
+
+const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧"];
+
+/** Canonical DevThink ANSI mark transcribed from docs/logo.md. */
+const canonicalMark = String.raw`
+                                                    +
+                                                    +
+                                                   -+
+                                                   ++
+                                                   ++
+                                                  +++
+                                                  -++
+                                                ++++-
+                                              +++++++++
+                                          +-+++++++++++++--
+                                        --++++++-++++++++++++
+                                     +++++++-+   +++  +--++++++-
+                                  -+++++++-+     +++     -+-+++++++
+                               ++++++++++       -+++        --++++++++
+                            ++++++++-+          ++++           --+++++++-
+                         ++++++++++             ++++              --+++++++-
+                      ---++++++-               -++++                 -++++++--+
+                   ++++++++--                  +++++                    ++++++++--
+                +--+++++--                     +++++                       +++++++---
+              ++++++++-                        +++++                          +-+++++++
+             -+++++--                         -++++-                            --++++++
+             -+++++-                          +++++-                             +++++++
+             -++++++                         -+++++-                             +++++++
+             -++++++                         ++++++-                             +++++++
+             -++++++                         +++++++-                            +++++++
+             -++++++                         ++++++++-                           +++++++
+             -++++++                        -++++++++++-+                        +++++++
+             -++++++                        -+++++++++++++-                      +++++++
+             -++++++                        -+++++++++++++++++                   +++++++
+             -++++++                       -++++++++++++++++++++                 +++++++
+             -++++++                       -++++++++++++++++++++++               +++++++
+             -++++++                      -+++++++++++++++++++++++++-            +++++++
+             -++++++                    +++++++++++++++++-+--++++++++--          +++++++
+             -++++++                 +++++++++++++++           -+++++++++        +++++++
+             -++++++              +++++++++++-++                  --++++++-+      +-++++
+             -++++++           ++++++++++-+-                         +--++++--      --++
+             -++++++       +--++++++++++                                ---++++-+     +-
+             -++++++    ++-++++++++                                        ++++++++
+             -++++++ -+++++-+--                                                +-++-+
+             -+++++++++++++                                                      -++++++
+             -++++++++                                                          +-+++-+++-
+           -+++++++++++                                                       ++++++++- +---+
+        --++-+  -++++++-++                                                 ---++++++++     +-++
+     ++++          +-+++++++                                             -++++++-+             ++
+  -++                 ++++++++--                                     ++++++++-+-                  +
+                        +-++++++-+                                 --++++++++
+                           ++-+++++++                           ++++++++-+
+                              +-++++++++                     --++++++++
+                                 ++++++++++               +--++++++-
+                                    --+++++++-         ++++++++++
+                                       -+++++++-++++--++++++++
+                                          +-++++++++++++++-
+                                             --++++++++-
+                                                +-++-`;
+
+function color(code: string, value: string): string {
+  return `${code}${value}${colors.reset}`;
+}
+
+function pad(value: string, width: number): string {
+  return value.length >= width ? value.slice(0, width) : value + " ".repeat(width - value.length);
+}
+
+export function banner(version: string): string {
+  const mark = canonicalMark.split("\n").map((line) => color(colors.yellow, line)).join("\n");
+  const title = color(colors.yellow + colors.bold, "DEVTHINK");
+  return [mark, `${title} ${color(colors.muted, `v${version}`)}`, color(colors.muted, "Embedded gateway · terminal workbench · user-owned configuration")].join("\n");
+}
+
+export function box(title: string, content: string, width = 76): string {
+  const innerWidth = Math.max(20, width - 4);
+  const top = `╭─ ${color(colors.cyan, title)} ${"─".repeat(Math.max(0, innerWidth - title.length - 3))}╮`;
+  const body = content.split("\n").map((line) => `│ ${pad(line, innerWidth)} │`);
+  return [top, ...body, `╰${"─".repeat(width - 2)}╯`].join("\n");
+}
+
+export function statusBar(provider: string, model: string, mode: string): string {
+  return color(colors.muted, `[${provider || "not configured"}] [${model || "not configured"}] [${mode}]`);
+}
+
+export function spinnerFrame(index: number, message: string): string {
+  return `${color(colors.cyan, frames[index % frames.length])} ${message}`;
+}
+
+export function formatEvent(event: ChatEvent): string {
+  if (event.type === "text") return event.text;
+  if (event.type === "reasoning") return color(colors.muted, event.text);
+  if (event.type === "error") return color(colors.red, event.message);
+  if (event.type === "finish") return "";
+  if (event.type === "start") return color(colors.muted, `Connected to ${event.provider} / ${event.model}`);
+  return color(colors.blue, `${event.name}: ${JSON.stringify(event.input)}`);
+}
+
+export function suggestions(input: string, values: string[], limit = 8): string[] {
+  const query = input.trim().toLowerCase();
+  if (!query) return values.slice(0, limit);
+  return values.filter((value) => value.toLowerCase().includes(query)).slice(0, limit);
+}
+
+export function formatConfig(config: Record<string, unknown>): string {
+  return Object.entries(config).map(([key, value]) => `${color(colors.muted, pad(key, 20))} ${String(value)}`).join("\n");
+}