hn-bits 0.2.0

package/dist/lib/config.js

@@ -0,0 +1,52 @@
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export const DEFAULT_OLLAMA_CONFIG = {
+    host: 'http://localhost:11434',
+    model: 'llama3.2',
+};
+const DEFAULTS = {
+    ollama: DEFAULT_OLLAMA_CONFIG,
+};
+/** Shown in the summary panel / Ask AI view when no config file is present. */
+export const AI_SETUP_HINT_LINES = [
+    'AI not configured.',
+    '1. Install Ollama and pull a model:  ollama pull llama3.2',
+    '2. Create ~/.config/hn-bits/config.json:',
+    '   { "ollama": { "host": "http://localhost:11434", "model": "llama3.2" } }',
+];
+export function configPath() {
+    return process.env.HN_BITS_CONFIG || join(homedir(), '.config', 'hn-bits', 'config.json');
+}
+function readConfigFile(path) {
+    try {
+        return readFileSync(path, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+/** Loads AI config from disk. Returns null if absent; never throws — invalid JSON warns and falls back to absent. */
+export function loadConfig() {
+    const raw = readConfigFile(configPath());
+    if (raw == null)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return {
+            ollama: {
+                host: parsed.ollama?.host ?? DEFAULTS.ollama.host,
+                model: parsed.ollama?.model ?? DEFAULTS.ollama.model,
+            },
+            telegram: parsed.telegram,
+            desktopNotifications: parsed.desktopNotifications && {
+                enabled: parsed.desktopNotifications.enabled,
+                timeoutSeconds: parsed.desktopNotifications.timeoutSeconds ?? 10,
+            },
+        };
+    }
+    catch (err) {
+        console.warn(`config invalid: ${err.message} — AI disabled`);
+        return null;
+    }
+}

package/dist/lib/configKeys.js

@@ -0,0 +1,31 @@
+export const CONFIG_KEYS = {
+    'ollama.host': { path: ['ollama', 'host'], type: 'string' },
+    'ollama.model': { path: ['ollama', 'model'], type: 'string' },
+    'telegram.enabled': { path: ['telegram', 'enabled'], type: 'boolean' },
+    'telegram.botToken': { path: ['telegram', 'botToken'], type: 'string', sensitive: true },
+    'telegram.chatId': { path: ['telegram', 'chatId'], type: 'string' },
+    'desktopNotifications.enabled': { path: ['desktopNotifications', 'enabled'], type: 'boolean' },
+    'desktopNotifications.timeoutSeconds': { path: ['desktopNotifications', 'timeoutSeconds'], type: 'number' },
+};
+/** Coerces a CLI string argument to the key's declared type. Throws on invalid input. */
+export function parseValue(def, raw) {
+    if (def.type === 'boolean') {
+        if (raw !== 'true' && raw !== 'false')
+            throw new Error(`expected 'true' or 'false', got '${raw}'`);
+        return raw === 'true';
+    }
+    if (def.type === 'number') {
+        const value = Number(raw);
+        if (Number.isNaN(value))
+            throw new Error(`expected a number, got '${raw}'`);
+        return value;
+    }
+    return raw;
+}
+/** Renders a value for `config list`; sensitive values are masked. */
+export function formatValue(def, value) {
+    const rendered = String(value);
+    if (!def.sensitive)
+        return rendered;
+    return `${rendered.slice(0, 6)}…(hidden)`;
+}

package/dist/lib/configStore.js

@@ -0,0 +1,64 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { configPath, DEFAULT_OLLAMA_CONFIG, loadConfig } from './config.js';
+import { CONFIG_KEYS, formatValue, parseValue } from './configKeys.js';
+function requireKeyDef(key) {
+    const def = CONFIG_KEYS[key];
+    if (!def)
+        throw new Error(`unknown config key: '${key}'`);
+    return def;
+}
+/** Raw parsed config, never merged with defaults — {} if the file is absent or invalid. */
+export function readRawConfig() {
+    try {
+        return JSON.parse(readFileSync(configPath(), 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeRawConfig(config) {
+    const path = configPath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`);
+}
+function resolveValue(key) {
+    const [section, field] = requireKeyDef(key).path;
+    const merged = loadConfig();
+    if (section === 'ollama') {
+        const ollama = merged?.ollama ?? DEFAULT_OLLAMA_CONFIG;
+        return ollama[field];
+    }
+    const sectionValue = merged?.[section];
+    return sectionValue?.[field];
+}
+/** Raw, unmasked value for `config get` — meant to be scripted/piped. */
+export function getConfigValue(key) {
+    const value = resolveValue(key);
+    return value === undefined ? undefined : String(value);
+}
+export function setConfigValue(key, rawValue) {
+    const def = requireKeyDef(key);
+    const value = parseValue(def, rawValue);
+    const [section, field] = def.path;
+    const config = readRawConfig();
+    config[section] = { ...config[section], [field]: value };
+    writeRawConfig(config);
+}
+export function unsetConfigValue(key) {
+    const [section, field] = requireKeyDef(key).path;
+    const config = readRawConfig();
+    const sectionValue = config[section];
+    if (!sectionValue)
+        return;
+    delete sectionValue[field];
+    if (Object.keys(sectionValue).length === 0)
+        delete config[section];
+    writeRawConfig(config);
+}
+export function listConfigEntries() {
+    return Object.entries(CONFIG_KEYS).map(([key, def]) => {
+        const value = resolveValue(key);
+        return { key, value: value === undefined ? undefined : formatValue(def, value) };
+    });
+}

package/dist/lib/contactHighlight.js

@@ -0,0 +1,18 @@
+// Wrapped lines have no internal newlines and rarely straddle a URL/email boundary;
+// when they do, only the head of the match (up to the wrap point) gets colored.
+const CONTACT_PATTERN = /(https?:\/\/\S+)|([\w.+-]+@[\w-]+\.[\w.-]+)/g;
+/** Splits a single line of already-wrapped text into plain/link/email tokens. */
+export function tokenizeContacts(line) {
+    const tokens = [];
+    let lastIndex = 0;
+    for (const match of line.matchAll(CONTACT_PATTERN)) {
+        const index = match.index;
+        if (index > lastIndex)
+            tokens.push({ text: line.slice(lastIndex, index) });
+        tokens.push({ text: match[0], kind: match[1] ? 'link' : 'email' });
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < line.length)
+        tokens.push({ text: line.slice(lastIndex) });
+    return tokens.length > 0 ? tokens : [{ text: line }];
+}

package/dist/lib/format.js

@@ -0,0 +1,20 @@
+const MINUTE = 60;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+export function formatAge(unixSeconds, now = new Date()) {
+    const delta = Math.floor(now.getTime() / 1000) - unixSeconds;
+    if (delta < HOUR)
+        return `${Math.floor(delta / MINUTE)}m`;
+    if (delta < DAY)
+        return `${Math.floor(delta / HOUR)}h`;
+    return `${Math.floor(delta / DAY)}d`;
+}
+export function truncateTitle(title, maxWidth) {
+    if (maxWidth <= 0)
+        return '';
+    if (title.length <= maxWidth)
+        return title;
+    if (maxWidth === 1)
+        return '…';
+    return `${title.slice(0, maxWidth - 1)}…`;
+}

package/dist/lib/html.js

@@ -0,0 +1,37 @@
+const ENTITIES = {
+    '&': '&',
+    '>': '>',
+    '&lt;': '<',
+    '&quot;': '"',
+    "&#x27;": "'",
+    '&#x2F;': '/',
+};
+function decodeEntities(text) {
+    return text.replace(/&amp;|&gt;|&lt;|&quot;|&#x27;|&#x2F;/g, (match) => ENTITIES[match]);
+}
+function extractCodeBlocks(html) {
+    return html.replace(/<pre><code>([\s\S]*?)<\/code><\/pre>/gi, (_match, code) => code
+        .split('\n')
+        .map((line) => `    ${line}`)
+        .join('\n'));
+}
+function extractAnchors(html) {
+    return html.replace(/<a\s+href="([^"]*)"[^>]*>.*?<\/a>/gi, '$1');
+}
+function stripTags(html) {
+    return html.replace(/<\/?i>/gi, '').replace(/<p>/gi, '\n\n').replace(/<[^>]+>/g, '');
+}
+function prefixQuotedLines(text) {
+    return text
+        .split('\n')
+        .map((line) => (line.startsWith('>') ? `│ ${line.slice(1).trim()}` : line))
+        .join('\n');
+}
+/** Renders HN comment HTML as plain text. Dumb and total — never throws. */
+export function htmlToText(html) {
+    const withCode = extractCodeBlocks(html);
+    const withUrls = extractAnchors(withCode);
+    const stripped = stripTags(withUrls);
+    const decoded = decodeEntities(stripped);
+    return prefixQuotedLines(decoded).replace(/^\n+|\n+$/g, '');
+}

package/dist/lib/listNavigation.js

@@ -0,0 +1,18 @@
+export function clampSelection(current, delta, length) {
+    if (length === 0)
+        return 0;
+    return Math.min(Math.max(current + delta, 0), length - 1);
+}
+const FEED_KEYS = { t: 'top', n: 'new', b: 'best' };
+export function mapFeedKey(key) {
+    return FEED_KEYS[key];
+}
+const FEED_ORDER = ['top', 'new', 'best', 'ask', 'show'];
+export function nextFeed(current) {
+    const index = FEED_ORDER.indexOf(current);
+    return FEED_ORDER[(index + 1) % FEED_ORDER.length];
+}
+export function previousFeed(current) {
+    const index = FEED_ORDER.indexOf(current);
+    return FEED_ORDER[(index - 1 + FEED_ORDER.length) % FEED_ORDER.length];
+}

package/dist/lib/url.js

@@ -0,0 +1,10 @@
+export function getHostname(url) {
+    if (!url)
+        return undefined;
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/lib/viewport.js

@@ -0,0 +1,81 @@
+// Clamp/advance the window start so `selected` stays visible.
+// Called every render with the current height, so terminal shrink is handled for free.
+export function ensureVisible(offset, selected, height, count) {
+    const maxOffset = Math.max(0, count - height);
+    let next = offset;
+    if (selected < next)
+        next = selected;
+    if (selected >= next + height)
+        next = selected - height + 1;
+    return Math.min(Math.max(next, 0), maxOffset);
+}
+export function visibleSlice(items, offset, height) {
+    return items.slice(offset, offset + height);
+}
+export function shouldFetchMore(selected, fetchedCount, totalCount, threshold) {
+    return fetchedCount < totalCount && selected >= fetchedCount - threshold;
+}
+// Deterministic greedy word-wrap; words longer than `width` are hard-broken.
+export function wrapPlainText(text, width) {
+    const safeWidth = Math.max(1, width);
+    return text.split('\n').flatMap((line) => wrapLine(line, safeWidth));
+}
+function wrapLine(line, width) {
+    const rows = [];
+    let current = '';
+    for (const word of line.split(' ')) {
+        const candidate = current.length === 0 ? word : `${current} ${word}`;
+        if (candidate.length <= width) {
+            current = candidate;
+            continue;
+        }
+        if (current.length > 0)
+            rows.push(current);
+        current = word;
+        while (current.length > width) {
+            rows.push(current.slice(0, width));
+            current = current.slice(width);
+        }
+    }
+    if (current.length > 0)
+        rows.push(current);
+    return rows.length > 0 ? rows : [''];
+}
+function lineStart(heights, index) {
+    return heights.slice(0, index).reduce((sum, h) => sum + h, 0);
+}
+function totalLines(heights) {
+    return heights.reduce((sum, h) => sum + h, 0);
+}
+// Line-based analogue of ensureVisible: keeps the selected row's first line visible.
+export function ensureVisibleLines(heights, selected, topLine, viewportLines) {
+    const start = lineStart(heights, selected);
+    const maxTop = Math.max(0, totalLines(heights) - viewportLines);
+    let next = topLine;
+    if (start < next)
+        next = start;
+    if (start >= next + viewportLines)
+        next = start - viewportLines + 1;
+    return Math.min(Math.max(next, 0), maxTop);
+}
+// Which rows intersect [topLine, topLine + viewportLines), and how many lines to clip at each edge.
+export function sliceByLines(heights, topLine, viewportLines) {
+    const empty = { first: 0, last: -1, clipTop: 0, clipBottom: 0 };
+    if (heights.length === 0 || viewportLines <= 0)
+        return empty;
+    const starts = heights.map((_, i) => lineStart(heights, i));
+    const total = totalLines(heights);
+    const windowStart = Math.max(0, Math.min(topLine, total));
+    const windowEnd = Math.min(total, windowStart + viewportLines);
+    if (windowEnd <= windowStart)
+        return empty;
+    let first = 0;
+    while (first < heights.length && starts[first] + heights[first] <= windowStart)
+        first++;
+    let last = first;
+    while (last + 1 < heights.length && starts[last + 1] < windowEnd)
+        last++;
+    const clipTop = windowStart - starts[first];
+    const clipBottom = Math.max(0, starts[last] + heights[last] - windowEnd);
+    return { first, last, clipTop, clipBottom };
+}

package/dist/ui/App.js

@@ -0,0 +1,75 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { useApp, useInput } from 'ink';
+import { loadConfig } from '../lib/config.js';
+import { AskAI } from './AskAI.js';
+import { Comments } from './Comments.js';
+import { HelpOverlay } from './HelpOverlay.js';
+import { COMMENTS_KEYS, LIST_KEYS, SEARCH_RESULTS_KEYS, footerHint } from './keymap.js';
+import { Body, Footer, Header, Screen } from './Layout.js';
+import { SearchInput } from './SearchInput.js';
+import { SearchResults } from './SearchResults.js';
+import { StoryList } from './StoryList.js';
+import { TabBar } from './TabBar.js';
+export function App({ initialQuery }) {
+    const [feed, setFeed] = useState('top');
+    const [view, setView] = useState(initialQuery ? { name: 'search', query: initialQuery, from: 'cli' } : { name: 'list' });
+    const [helpOpen, setHelpOpen] = useState(false);
+    const [config] = useState(loadConfig);
+    const { exit } = useApp();
+    useInput((input) => {
+        if (helpOpen)
+            return setHelpOpen(false);
+        if (view.name === 'search-input' || view.name === 'ask')
+            return;
+        if (input === 'q')
+            return exit();
+        if (input === '?')
+            return setHelpOpen(true);
+    });
+    const ctx = { feed, config, setFeed, setView, exit };
+    return (_jsxs(Screen, { children: [_jsx(Header, { children: _jsx(TabBar, { active: feed }) }), _jsx(Body, { children: helpOpen ? _jsx(HelpOverlay, { ...helpFor(view) }) : renderBody(view, ctx) }), _jsx(Footer, { children: renderFooter(view, ctx) })] }));
+}
+function renderBody(view, ctx) {
+    if (view.name === 'list')
+        return renderList(ctx);
+    if (view.name === 'search')
+        return renderSearch(view, ctx);
+    if (view.name === 'search-input')
+        return null;
+    if (view.name === 'ask')
+        return renderAskAI(view, ctx);
+    return renderComments(view, ctx);
+}
+function renderFooter(view, ctx) {
+    if (view.name === 'search-input') {
+        return (_jsx(SearchInput, { onSubmit: (query) => ctx.setView({ name: 'search', query, from: view.from }), onCancel: () => ctx.setView({ name: 'list' }) }));
+    }
+    if (view.name === 'ask')
+        return null;
+    if (view.name === 'list')
+        return footerHint(LIST_KEYS);
+    if (view.name === 'comments')
+        return footerHint(COMMENTS_KEYS);
+    return footerHint(SEARCH_RESULTS_KEYS);
+}
+function helpFor(view) {
+    if (view.name === 'comments')
+        return { title: 'comments', keys: COMMENTS_KEYS };
+    if (view.name === 'search')
+        return { title: 'search results', keys: SEARCH_RESULTS_KEYS };
+    return { title: 'story list', keys: LIST_KEYS };
+}
+function renderList({ feed, config, setFeed, setView }) {
+    return (_jsx(StoryList, { feed: feed, config: config, onFeedChange: setFeed, onSelectStory: (story) => setView({ name: 'comments', story, returnTo: { name: 'list' } }), onSearchRequested: () => setView({ name: 'search-input', from: 'tui' }), onAskAI: (story) => setView({ name: 'ask', story, comments: null, returnTo: { name: 'list' } }) }));
+}
+function renderSearch(view, { config, setView, exit }) {
+    const returnTo = { name: 'search', query: view.query, from: view.from };
+    return (_jsx(SearchResults, { query: view.query, config: config, onSelectStory: (story) => setView({ name: 'comments', story, returnTo }), onExit: () => (view.from === 'tui' ? setView({ name: 'list' }) : exit()), onSearchAgain: () => setView({ name: 'search-input', from: view.from }), onAskAI: (story) => setView({ name: 'ask', story, comments: null, returnTo }) }));
+}
+function renderComments(view, { config, setView }) {
+    return (_jsx(Comments, { story: view.story, config: config, onBack: () => setView(view.returnTo), onAskAI: (comments) => setView({ name: 'ask', story: view.story, comments, returnTo: view }) }));
+}
+function renderAskAI(view, { config, setView }) {
+    return (_jsx(AskAI, { story: view.story, comments: view.comments, config: config, onBack: () => setView(view.returnTo) }));
+}

package/dist/ui/AskAI.js

@@ -0,0 +1,186 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { Box, Text, useInput, useWindowSize } from 'ink';
+import { buildAskAIContext } from '../ai/context.js';
+import { chatStream, checkOllama, describeError } from '../ai/ollama.js';
+import { fetchComments } from '../api/algolia.js';
+import { ExtractionError, extractArticle } from '../lib/article.js';
+import { AI_SETUP_HINT_LINES } from '../lib/config.js';
+import { truncateTitle } from '../lib/format.js';
+import { htmlToText } from '../lib/html.js';
+import { wrapPlainText } from '../lib/viewport.js';
+import { HEADER_ROWS } from './Layout.js';
+import { theme } from './theme.js';
+async function resolveArticle(story) {
+    if (story.url) {
+        try {
+            return { article: await extractArticle(story.url) };
+        }
+        catch (err) {
+            return { article: null, reason: err instanceof ExtractionError ? err.reason : 'unknown' };
+        }
+    }
+    if (story.text)
+        return { article: { text: htmlToText(story.text) } };
+    return { article: null, reason: 'text post' };
+}
+export function AskAI({ story, comments, config, onBack }) {
+    const { columns, rows } = useWindowSize();
+    const [status, setStatus] = useState(config ? 'preparing' : 'hint');
+    const [unavailableDetail, setUnavailableDetail] = useState('');
+    const [systemContext, setSystemContext] = useState('');
+    const [history, setHistory] = useState([]);
+    const [input, setInput] = useState('');
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const controllerRef = useRef(null);
+    const token = useRef(0);
+    useEffect(() => {
+        if (config)
+            void prepare(config);
+        return () => controllerRef.current?.abort();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    async function prepare(cfg) {
+        const myToken = ++token.current;
+        setStatus('preparing');
+        const health = await checkOllama(cfg.ollama);
+        if (myToken !== token.current)
+            return;
+        if (!health.ok) {
+            setUnavailableDetail(health.detail);
+            setStatus('unavailable');
+            return;
+        }
+        const { article, reason } = await resolveArticle(story);
+        if (myToken !== token.current)
+            return;
+        let thread = comments;
+        if (thread == null) {
+            try {
+                thread = await fetchComments(story.id);
+            }
+            catch {
+                thread = [];
+            }
+        }
+        if (myToken !== token.current)
+            return;
+        setSystemContext(buildAskAIContext({ story, article, articleUnavailableReason: reason, comments: thread }));
+        setStatus('idle');
+    }
+    async function send() {
+        const text = input.trim();
+        if (!config || !text)
+            return;
+        setInput('');
+        setScrollOffset(0);
+        const messages = [
+            { role: 'system', content: systemContext },
+            ...history.map((turn) => ({ role: turn.role, content: turn.content })),
+            { role: 'user', content: text },
+        ];
+        setHistory((h) => [...h, { role: 'user', content: text }, { role: 'assistant', content: '' }]);
+        setStatus('streaming');
+        const controller = new AbortController();
+        controllerRef.current = controller;
+        const myToken = ++token.current;
+        function replaceLastAssistant(update) {
+            setHistory((h) => {
+                const copy = h.slice();
+                const last = copy[copy.length - 1];
+                if (last)
+                    copy[copy.length - 1] = update(last);
+                return copy;
+            });
+        }
+        try {
+            let content = '';
+            for await (const delta of chatStream(config.ollama, messages, controller.signal)) {
+                if (myToken !== token.current)
+                    return;
+                content += delta;
+                replaceLastAssistant((turn) => ({ ...turn, content }));
+            }
+            if (myToken === token.current)
+                setStatus('idle');
+        }
+        catch (err) {
+            if (myToken !== token.current)
+                return;
+            replaceLastAssistant((turn) => ({ ...turn, content: describeError(err) }));
+            setStatus('idle');
+        }
+    }
+    function abortStreaming() {
+        controllerRef.current?.abort();
+        token.current++;
+        setHistory((h) => {
+            const copy = h.slice();
+            const last = copy[copy.length - 1];
+            if (last?.role === 'assistant')
+                copy[copy.length - 1] = { ...last, cancelled: true };
+            return copy;
+        });
+        setStatus('idle');
+    }
+    useInput((rawInput, key) => {
+        if (status === 'streaming') {
+            if (key.escape)
+                abortStreaming();
+            return;
+        }
+        if (key.escape)
+            return onBack();
+        if (status !== 'idle')
+            return;
+        if (key.return)
+            return void send();
+        if (input === '' && key.upArrow)
+            return setScrollOffset((s) => s + 1);
+        if (input === '' && key.downArrow)
+            return setScrollOffset((s) => Math.max(0, s - 1));
+        if (key.backspace || key.delete)
+            return setInput((v) => v.slice(0, -1));
+        if (rawInput && !key.ctrl && !key.meta)
+            setInput((v) => v + rawInput);
+    });
+    const width = columns;
+    const headerRows = 2; // title line + blank
+    const dividerRows = 2; // blank + rule
+    const inputRows = 1;
+    const footerRows = 1;
+    // App's Footer box renders one more (empty) row below this view's own box — see App.tsx renderFooter.
+    const appFooterRows = 1;
+    const boxHeight = Math.max(1, rows - HEADER_ROWS - appFooterRows);
+    const historyRows = Math.max(1, boxHeight - headerRows - dividerRows - inputRows - footerRows);
+    const headerSuffix = status === 'preparing' ? ' · preparing…' : '';
+    const headerLabel = config
+        ? `ask · ${truncateTitle(story.title, Math.max(1, width - 20))} · ${config.ollama.model}${headerSuffix}`
+        : 'ask';
+    const historyLines = buildHistoryLines(history, width, status === 'streaming');
+    const maxScroll = Math.max(0, historyLines.length - historyRows);
+    const live = status === 'streaming';
+    const effectiveScroll = live ? maxScroll : Math.min(scrollOffset, maxScroll);
+    const start = Math.max(0, historyLines.length - historyRows - effectiveScroll);
+    const visibleLines = historyLines.slice(start, start + historyRows);
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: boxHeight, children: [_jsx(Text, { color: theme.colors.title, children: headerLabel }), _jsx(Text, { children: " " }), status === 'hint' &&
+                AI_SETUP_HINT_LINES.map((line) => (_jsx(Text, { dimColor: true, children: line }, line))), status === 'unavailable' && _jsx(Text, { color: theme.colors.error, children: unavailableDetail }), (status === 'idle' || status === 'streaming' || status === 'preparing') &&
+                visibleLines.map((line, i) => _jsx(Text, { children: line }, i)), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: '─'.repeat(Math.max(1, width - 1)) }), _jsxs(Text, { dimColor: status !== 'idle', children: ['> ', input, status === 'idle' ? '▊' : ''] }), _jsx(Text, { dimColor: true, children: "enter send \u00B7 \u2191/\u2193 scroll \u00B7 esc back/abort \u00B7 ctrl+c quit" })] }));
+}
+function buildHistoryLines(history, width, live) {
+    const lines = [];
+    history.forEach((turn, i) => {
+        const label = turn.role === 'user' ? 'you  ' : 'ai   ';
+        const isLastAssistant = live && i === history.length - 1 && turn.role === 'assistant';
+        const text = isLastAssistant && !turn.content ? '▍(streaming)' : turn.content;
+        const wrapped = wrapPlainText(text, Math.max(1, width - label.length));
+        wrapped.forEach((line, j) => {
+            const suffix = isLastAssistant && j === wrapped.length - 1 && turn.content ? ' ▍' : '';
+            lines.push(`${j === 0 ? label : ' '.repeat(label.length)}${line}${suffix}`);
+        });
+        if (turn.cancelled)
+            lines.push(`${' '.repeat(label.length)}· cancelled`);
+        lines.push('');
+    });
+    return lines;
+}