@datename/fastcode-termux 0.0.0-stage → 0.1.6

package/dist/session/log.js

@@ -0,0 +1,135 @@
+/**
+ * Append-only JSONL session log.
+ *
+ * Every entry is flushed as its own line, so a crash (or a kill from the
+ * Android task switcher) still leaves a readable transcript that can be
+ * resumed. A size cap keeps the sessions directory bounded; the oldest logs are
+ * pruned first.
+ *
+ *   FASTCODE_SESSION_LOG=0        disable logging
+ *   FASTCODE_SESSION_CACHE_MB=N   sessions cache cap in MB (default 256)
+ */
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { getPaths } from "../config/paths.js";
+const NL = String.fromCharCode(10);
+export function sessionCacheLimitBytes() {
+    const mb = Number(process.env["FASTCODE_SESSION_CACHE_MB"]);
+    return (Number.isFinite(mb) && mb > 0 ? mb : 256) * 1024 * 1024;
+}
+export function loggingEnabled() {
+    return process.env["FASTCODE_SESSION_LOG"] !== "0";
+}
+function newId() {
+    return new Date().toISOString().replace(/[:.]/g, "-") + "-" + Math.random().toString(36).slice(2, 6);
+}
+function openLog(id, file, meta) {
+    let closed = false;
+    const append = (entry) => {
+        if (closed || !loggingEnabled())
+            return;
+        try {
+            appendFileSync(file, JSON.stringify({ ts: Date.now(), ...entry }) + NL, "utf8");
+        }
+        catch {
+            // A read-only or full filesystem must not break the TUI.
+        }
+    };
+    append({ type: "session_start", id, cwd: process.cwd(), ...meta });
+    return {
+        id,
+        file,
+        append,
+        close() {
+            append({ type: "session_end" });
+            closed = true;
+            try {
+                pruneSessions();
+            }
+            catch {
+                // best effort
+            }
+        },
+    };
+}
+export function createSessionLog(meta = {}) {
+    const { sessions } = getPaths();
+    mkdirSync(sessions, { recursive: true });
+    const id = newId();
+    const file = join(sessions, id + ".jsonl");
+    return openLog(id, file, meta);
+}
+export function openSessionLog(file) {
+    const { sessions } = getPaths();
+    mkdirSync(sessions, { recursive: true });
+    return openLog(undefined, existsSync(file) ? file : join(sessions, file), {});
+}
+export function listSessions() {
+    const { sessions } = getPaths();
+    if (!existsSync(sessions))
+        return [];
+    return readdirSync(sessions)
+        .filter((name) => name.endsWith(".jsonl"))
+        .map((name) => {
+        const file = join(sessions, name);
+        let bytes = 0;
+        let modified = "";
+        let messages = 0;
+        try {
+            const info = statSync(file);
+            bytes = info.size;
+            modified = info.mtime.toISOString();
+            messages = readFileSync(file, "utf8").split(NL).filter((line) => line.includes('"type":"message"')).length;
+        }
+        catch {
+            // unreadable: report what we have
+        }
+        return { id: name.replace(/[.]jsonl$/, ""), file, bytes, modified, messages };
+    })
+        .sort((a, b) => (a.modified < b.modified ? 1 : -1));
+}
+export function resolveSessionFile(idOrFile) {
+    const { sessions } = getPaths();
+    const looksLikePath = idOrFile.includes("/") || idOrFile.includes(String.fromCharCode(92)) || idOrFile.endsWith(".jsonl");
+    return looksLikePath ? idOrFile : join(sessions, idOrFile + ".jsonl");
+}
+export function readSession(idOrFile) {
+    const file = resolveSessionFile(idOrFile);
+    if (!existsSync(file))
+        return [];
+    return readFileSync(file, "utf8")
+        .split(NL)
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return undefined;
+        }
+    })
+        .filter(Boolean);
+}
+export function loadSessionMessages(idOrFile) {
+    return readSession(idOrFile)
+        .filter((entry) => entry.type === "message" && typeof entry.content === "string")
+        .map((entry) => ({ role: entry.role, content: entry.content }));
+}
+export function latestSessionFile() {
+    const all = listSessions();
+    return all.length > 0 ? all[0].file : undefined;
+}
+export function pruneSessions(limit = sessionCacheLimitBytes()) {
+    const all = listSessions();
+    let total = all.reduce((sum, entry) => sum + entry.bytes, 0);
+    for (let i = all.length - 1; i >= 0 && total > limit; i -= 1) {
+        try {
+            rmSync(all[i].file, { force: true });
+            total -= all[i].bytes;
+        }
+        catch {
+            // keep pruning the rest
+        }
+    }
+    return total;
+}

package/dist/skills/manager.d.ts

@@ -0,0 +1,18 @@
+/** List skills currently installed under ~/.fastcode/skills. */
+export declare function listInstalledSkills(): any[];
+/** Look up a skill by name (matches folder name OR frontmatter name). */
+export declare function getSkill(name: any): any;
+/** Install a skill. Returns the parsed manifest on success. */
+export declare function installSkill(spec: any, opts?: any): Promise<{
+    name: any;
+    description: any;
+    source: any;
+    path: string;
+    body: any;
+}>;
+/** Remove an installed skill by name or folder. */
+export declare function uninstallSkill(name: any): boolean;
+/** Search the registry for skills matching a query. */
+export declare function searchRegistry(query: any, registry?: string): Promise<any>;
+/** Compose the system-prompt addendum for a list of enabled skill names. */
+export declare function buildSkillsPrompt(enabled: any): string;

package/dist/skills/manager.js

@@ -0,0 +1,201 @@
+/**
+ * Skill manager.
+ *
+ * Skills follow Anthropic's "Agent Skills" convention: a folder containing
+ * a SKILL.md file plus optional resource files. FastCode supports three
+ * install sources:
+ *
+ *   1. skills.sh / skillshub.wtf API (default registry)
+ *      `/skills install pdf`               → resolves via the registry
+ *      `/skills install owner/repo/skill`  → fetches raw SKILL.md
+ *   2. Direct https URLs ending in SKILL.md.
+ *   3. Local paths (just symlinks into ~/.fastcode/skills/).
+ *
+ * Installed skills can be enabled per-session and are then stitched into
+ * the system prompt at chat time, exactly like Claude does internally.
+ */
+import { readFileSync, writeFileSync, existsSync, readdirSync, rmSync, mkdirSync, } from "node:fs";
+import { join } from "node:path";
+import { getPaths } from "../config/paths.js";
+import { fetchJson } from "../lib/http.js";
+import { parseSkill } from "./parser.js";
+const DEFAULT_REGISTRY = "https://skillshub.wtf";
+/** List skills currently installed under ~/.fastcode/skills. */
+export function listInstalledSkills() {
+    const { skills } = getPaths();
+    if (!existsSync(skills))
+        return [];
+    const out = [];
+    for (const dir of readdirSync(skills, { withFileTypes: true })) {
+        if (!dir.isDirectory())
+            continue;
+        const folder = join(skills, dir.name);
+        const md = join(folder, "SKILL.md");
+        if (!existsSync(md))
+            continue;
+        const raw = readFileSync(md, "utf8");
+        const parsed = parseSkill(raw, dir.name);
+        const sourcePath = join(folder, ".fastcode-source");
+        const source = existsSync(sourcePath)
+            ? readFileSync(sourcePath, "utf8").trim()
+            : "local";
+        out.push({
+            name: parsed.name || dir.name,
+            description: parsed.description,
+            source,
+            path: folder,
+            body: parsed.body,
+        });
+    }
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+/** Look up a skill by name (matches folder name OR frontmatter name). */
+export function getSkill(name) {
+    return listInstalledSkills().find((s) => s.name === name || basename(s.path) === name);
+}
+/** Install a skill. Returns the parsed manifest on success. */
+export async function installSkill(spec, opts = {}) {
+    const { skills } = getPaths();
+    const registry = (opts.registry ?? DEFAULT_REGISTRY).replace(/\/+$/, "");
+    let parsed;
+    let source;
+    let folderName;
+    if (spec.startsWith("http://") || spec.startsWith("https://")) {
+        const body = await fetchText(spec);
+        parsed = parseSkill(body, slugify(spec));
+        source = spec;
+        folderName = slugify(parsed.name || slugify(spec));
+    }
+    else if (looksLikeRepoPath(spec)) {
+        // owner/repo or owner/repo/skill — fetch via registry's raw endpoint.
+        const url = `${registry}/${spec}?format=md`;
+        const body = await fetchText(url);
+        parsed = parseSkill(body, parts(spec).pop() ?? spec);
+        source = url;
+        folderName = slugify(parsed.name || parts(spec).pop() || spec);
+    }
+    else {
+        // Single-token name → search the registry.
+        const hits = await searchRegistry(spec, registry);
+        const hit = hits[0];
+        if (!hit)
+            throw new Error(`No skill found for "${spec}" in ${registry}`);
+        const url = hit.fetchUrl ?? `${registry}/${hit.slug}?format=md`;
+        const body = await fetchText(url);
+        parsed = parseSkill(body, hit.name);
+        source = url;
+        folderName = slugify(parsed.name || hit.name);
+    }
+    const targetDir = join(skills, folderName);
+    if (existsSync(targetDir) && !opts.force) {
+        throw new Error(`Skill "${folderName}" is already installed. Use --force to overwrite.`);
+    }
+    if (existsSync(targetDir))
+        rmSync(targetDir, { recursive: true, force: true });
+    mkdirSync(targetDir, { recursive: true });
+    writeFileSync(join(targetDir, "SKILL.md"), reassemble(parsed));
+    writeFileSync(join(targetDir, ".fastcode-source"), source);
+    return {
+        name: parsed.name || folderName,
+        description: parsed.description,
+        source,
+        path: targetDir,
+        body: parsed.body,
+    };
+}
+/** Remove an installed skill by name or folder. */
+export function uninstallSkill(name) {
+    const { skills } = getPaths();
+    const candidates = readdirSync(skills, { withFileTypes: true });
+    for (const dir of candidates) {
+        if (!dir.isDirectory())
+            continue;
+        if (dir.name !== name) {
+            // Also match by frontmatter name.
+            const md = join(skills, dir.name, "SKILL.md");
+            if (!existsSync(md))
+                continue;
+            const parsed = parseSkill(readFileSync(md, "utf8"), dir.name);
+            if (parsed.name !== name)
+                continue;
+        }
+        rmSync(join(skills, dir.name), { recursive: true, force: true });
+        return true;
+    }
+    return false;
+}
+/** Search the registry for skills matching a query. */
+export async function searchRegistry(query, registry = DEFAULT_REGISTRY) {
+    const base = registry.replace(/\/+$/, "");
+    try {
+        const json = await fetchJson(`${base}/api/v1/skills/search?q=${encodeURIComponent(query)}`);
+        return json.data ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Compose the system-prompt addendum for a list of enabled skill names. */
+export function buildSkillsPrompt(enabled) {
+    if (enabled.length === 0)
+        return "";
+    const installed = listInstalledSkills();
+    const chunks = [];
+    for (const name of enabled) {
+        const skill = installed.find((s) => s.name === name || basename(s.path) === name);
+        if (!skill)
+            continue;
+        chunks.push(`<skill name="${skill.name}">\n${skill.body.trim()}\n</skill>`);
+    }
+    if (chunks.length === 0)
+        return "";
+    return [
+        "",
+        "## Active skills",
+        "The following skills are loaded for this session. Follow their instructions when relevant:",
+        "",
+        chunks.join("\n\n"),
+    ].join("\n");
+}
+// ---------- helpers ----------
+async function fetchText(url) {
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`Fetch ${url} failed: ${res.status} ${res.statusText}`);
+    return await res.text();
+}
+function reassemble(parsed) {
+    const fmEntries = Object.entries(parsed.frontmatter);
+    if (fmEntries.length === 0 && parsed.name && parsed.description) {
+        return [
+            "---",
+            `name: ${parsed.name}`,
+            `description: ${parsed.description}`,
+            "---",
+            "",
+            parsed.body.trim(),
+            "",
+        ].join("\n");
+    }
+    if (fmEntries.length === 0)
+        return parsed.body;
+    const fmLines = fmEntries.map(([k, v]) => `${k}: ${v}`);
+    return ["---", ...fmLines, "---", "", parsed.body.trim(), ""].join("\n");
+}
+function slugify(s) {
+    return s
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 64) || "skill";
+}
+function looksLikeRepoPath(spec) {
+    return /^[\w-]+\/[\w.-]+(\/[\w.-]+)?$/.test(spec) && !spec.startsWith("/");
+}
+function parts(spec) {
+    return spec.split("/").filter(Boolean);
+}
+function basename(p) {
+    const i = Math.max(p.lastIndexOf("/"), p.lastIndexOf("\\"));
+    return i === -1 ? p : p.slice(i + 1);
+}

package/dist/skills/parser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * SKILL.md parser. Skills follow Anthropic's Agent Skills convention:
+ *
+ *   ---
+ *   name: my-skill
+ *   description: ...
+ *   ---
+ *   <markdown body>
+ *
+ * We accept both `---` and `+++` fences and tolerate missing frontmatter
+ * (treating the first H1 + paragraph as a fallback name/description).
+ */
+export declare function parseSkill(source: any, fallbackName: any): {
+    name: any;
+    description: any;
+    body: any;
+    frontmatter: {};
+};

package/dist/skills/parser.js

@@ -0,0 +1,65 @@
+/**
+ * SKILL.md parser. Skills follow Anthropic's Agent Skills convention:
+ *
+ *   ---
+ *   name: my-skill
+ *   description: ...
+ *   ---
+ *   <markdown body>
+ *
+ * We accept both `---` and `+++` fences and tolerate missing frontmatter
+ * (treating the first H1 + paragraph as a fallback name/description).
+ */
+export function parseSkill(source, fallbackName) {
+    const fmMatch = source.match(/^(?:---|\+\+\+)\s*\n([\s\S]*?)\n(?:---|\+\+\+)\s*\n?/);
+    let frontmatter = {};
+    let body = source;
+    if (fmMatch) {
+        frontmatter = parseFrontmatter(fmMatch[1] ?? "");
+        body = source.slice(fmMatch[0].length).trimStart();
+    }
+    const name = (frontmatter["name"] ?? fallbackName).trim();
+    const description = (frontmatter["description"] ??
+        extractFirstParagraph(body) ??
+        "").trim();
+    return { name, description, body, frontmatter };
+}
+function parseFrontmatter(yaml) {
+    // Tiny YAML-ish parser: only handles `key: value` lines, which is what
+    // SKILL.md frontmatter uses in practice. This avoids pulling in a YAML lib.
+    const out = {};
+    for (const lineRaw of yaml.split("\n")) {
+        const line = lineRaw.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const colon = line.indexOf(":");
+        if (colon === -1)
+            continue;
+        const key = line.slice(0, colon).trim();
+        let value = line.slice(colon + 1).trim();
+        if ((value.startsWith("\"") && value.endsWith("\"")) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        out[key] = value;
+    }
+    return out;
+}
+function extractFirstParagraph(body) {
+    const lines = body.split("\n");
+    let buf = [];
+    for (const line of lines) {
+        if (line.startsWith("#")) {
+            if (buf.length)
+                break;
+            continue;
+        }
+        if (!line.trim()) {
+            if (buf.length)
+                break;
+            continue;
+        }
+        buf.push(line.trim());
+    }
+    return buf.length ? buf.join(" ") : undefined;
+}

package/dist/types.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Shared types used across FastCode.
+ *
+ * The provider abstraction is intentionally narrow — it only exposes
+ * what the chat loop needs (streaming completions, model list, auth).
+ * Providers can layer richer behavior on top in their own modules.
+ */
+export type Role = "system" | "user" | "assistant";
+export interface ChatMessage {
+    role: Role;
+    content: string;
+}
+export interface ChatRequest {
+    model: string;
+    messages: ChatMessage[];
+    /** Optional system prompt. Some providers fold this into messages. */
+    system?: string;
+    /** Sampling temperature. */
+    temperature?: number;
+    /** Soft cap for output tokens. */
+    maxOutputTokens?: number;
+    /** AbortSignal for cancellation (Esc / Ctrl+C). */
+    signal?: AbortSignal;
+}
+export interface ChatChunk {
+    /** Token text appended to the response. */
+    delta: string;
+    /** True on the final chunk. */
+    done: boolean;
+    /** Provider-specific usage info on the final chunk. */
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+        /** Approximate cost in USD if known. */
+        costUsd?: number;
+    };
+}
+export type ChatStream = AsyncIterable<ChatChunk>;
+export interface ProviderModel {
+    id: string;
+    label?: string;
+    /** Optional context window in tokens. */
+    contextWindow?: number;
+    /** Pricing per 1M tokens, used for cost estimation. */
+    pricing?: {
+        inputUsdPerM?: number;
+        outputUsdPerM?: number;
+    };
+}
+export interface Provider {
+    /** Unique id, e.g. "anthropic". */
+    id: string;
+    /** Human label. */
+    label: string;
+    /** ENV var(s) that, when set, satisfy auth. */
+    authEnv: string[];
+    /** Base URL — many providers expose OpenAI-compatible endpoints. */
+    baseUrl: string;
+    /** Default model id when the user hasn't picked one. */
+    defaultModel: string;
+    /** Static or dynamic list of supported models. */
+    listModels(apiKey: string | undefined): Promise<ProviderModel[]>;
+    /** Stream a chat completion. */
+    stream(req: ChatRequest, apiKey: string | undefined): ChatStream;
+}
+export interface SlashCommand {
+    name: string;
+    description: string;
+    /** Optional aliases users can also type. */
+    aliases?: string[];
+    /** Hide from /help (useful for power-user commands). */
+    hidden?: boolean;
+    /** Execute the command. Return text to render, or undefined for no output. */
+    run(ctx: CommandContext): Promise<CommandResult> | CommandResult;
+}
+export interface CommandResult {
+    /** Text rendered as a system message in the transcript. */
+    message?: string;
+    /** Mark this turn as silent (no echo of the slash itself). */
+    silent?: boolean;
+    /** Quit the app after this command. */
+    quit?: boolean;
+}
+export interface CommandContext {
+    args: string[];
+    raw: string;
+    state: AppStateSnapshot;
+    actions: AppActions;
+}
+export interface AppStateSnapshot {
+    providerId: string;
+    model: string;
+    theme: string;
+    agentMode: boolean;
+    history: ChatMessage[];
+    systemPrompt: string;
+    totalCostUsd: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    enabledSkills: string[];
+    enabledPlugins: string[];
+    skillsRegistry: string;
+}
+export interface AppActions {
+    setProvider(id: string): void;
+    setModel(id: string): void;
+    setTheme(id: string): void;
+    setAgentMode(enabled: boolean): void;
+    setSystemPrompt(prompt: string): void;
+    setSkillsRegistry(url: string): void;
+    enableSkill(name: string): void;
+    disableSkill(name: string): void;
+    enablePlugin(name: string): void;
+    disablePlugin(name: string): void;
+    clearHistory(): void;
+    pushSystemMessage(text: string): void;
+    /** Begin the guided API-key flow (choose provider → model → key). */
+    startLogin(options: {
+        provider?: string;
+        model?: string;
+    }): void;
+}
+export interface SkillManifest {
+    name: string;
+    description: string;
+    /** Where the skill came from (e.g. "skills.sh", "anthropics/skills"). */
+    source: string;
+    /** Local on-disk path to the skill folder. */
+    path: string;
+    /** Raw SKILL.md body (the prompt content). */
+    body: string;
+}
+export interface Theme {
+    id: string;
+    label: string;
+    banner: [string, string, string];
+    user: string;
+    assistant: string;
+    system: string;
+    border: string;
+    accent: string;
+    muted: string;
+    error: string;
+    success: string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/Banner.d.ts

@@ -0,0 +1,5 @@
+export declare const Banner: ({ theme, subtitle, stable }: {
+    theme: any;
+    subtitle: any;
+    stable?: boolean;
+}) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;

package/dist/ui/Banner.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Animated FastCode banner shown at startup.
+ *
+ * We render the wordmark with ink-big-text + a gradient that slowly cycles
+ * through the theme's banner triple. The animation runs for ~1s and then
+ * settles on a stable gradient so we don't waste GPU cycles forever.
+ *
+ * The font is chosen to fit the terminal: `block` needs ~74 columns, so on a
+ * narrow phone terminal we fall back to progressively smaller fonts (see
+ * BANNER_FONTS). If even the smallest font is wider than the terminal, the
+ * banner is skipped entirely.
+ */
+import { useEffect, useState } from "react";
+import { Box, Text, useStdout } from "ink";
+import BigText from "ink-big-text";
+import Gradient from "ink-gradient";
+const FRAMES = 16;
+// (font, columns) needed to render the literal text "FastCode" with
+// letterSpacing 1 and space:false. Measured with cfonts; largest first.
+const BANNER_FONTS = [
+    { font: "block", columns: 74 },
+    { font: "simple", columns: 56 },
+    { font: "slick", columns: 49 },
+    { font: "shade", columns: 39 },
+    { font: "chrome", columns: 32 },
+    { font: "console", columns: 16 },
+];
+/** Pick the largest font that fits `columns` (2 columns reserved for padding). */
+function pickBannerFont(columns) {
+    const usable = columns - 2;
+    for (const entry of BANNER_FONTS) {
+        if (entry.columns <= usable)
+            return entry.font;
+    }
+    return null;
+}
+export const Banner = ({ theme, subtitle, stable = false }) => {
+    const [frame, setFrame] = useState(0);
+    const { stdout } = useStdout();
+    const columns = stdout?.columns ?? process.stdout.columns ?? 80;
+    const font = pickBannerFont(columns);
+    useEffect(() => {
+        if (stable)
+            return;
+        if (frame >= FRAMES)
+            return;
+        const t = setTimeout(() => setFrame((f) => f + 1), 60);
+        return () => clearTimeout(t);
+    }, [frame, stable]);
+    if (!font)
+        return null;
+    const t = stable ? 1 : Math.min(1, frame / FRAMES);
+    const colors = rotate(theme.banner, t);
+    return (_jsxs(Box, { flexDirection: "column", alignItems: "flex-start", marginBottom: 1, children: [_jsx(Gradient, { colors: colors, children: _jsx(BigText, { text: "FastCode", font: font, space: false }) }), _jsx(Text, { color: theme.muted, children: subtitle ?? "multi-LLM TUI · skills.sh · slash commands · /help to start" })] }));
+};
+/** Cycle the gradient stops by `t ∈ [0,1]` for a subtle shimmer effect. */
+function rotate(stops, t) {
+    const [a, b, c] = stops;
+    if (t < 0.33)
+        return [a, b, c];
+    if (t < 0.66)
+        return [b, c, a];
+    return [c, a, b];
+}

package/dist/ui/Message.d.ts

@@ -0,0 +1,7 @@
+export declare const MessageBubble: ({ theme, role, content, streaming, markdown, }: {
+    theme: any;
+    role: any;
+    content: any;
+    streaming: any;
+    markdown: any;
+}) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;

package/dist/ui/Message.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { renderMarkdown } from "../lib/markdown.js";
+const SIGIL = {
+    user: "▎ you",
+    assistant: "▍ FastCode",
+    system: "✦ system",
+};
+export const MessageBubble = ({ theme, role, content, streaming, markdown, }) => {
+    const color = role === "user" ? theme.user : role === "assistant" ? theme.assistant : theme.system;
+    const display = markdown ? renderMarkdown(content) : content;
+    return (_jsxs(Box, { flexDirection: "column", marginY: 0, children: [_jsxs(Text, { color: color, bold: true, children: [SIGIL[role], streaming ? _jsx(Text, { color: theme.muted, children: "  (streaming)" }) : null] }), _jsx(Box, { marginLeft: 2, flexDirection: "column", children: _jsx(Text, { color: color, children: display || (streaming ? "…" : "") }) })] }));
+};