@researchcomputer/pista 0.1.2

package/dist/commands.test.js

@@ -0,0 +1,36 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { getSlashCommandSuggestions, parseSlashCommand } from './commands.js';
+test('parseSlashCommand lowercases the command and preserves the rest', () => {
+    assert.deepEqual(parseSlashCommand('/Plugins Install owner/repo'), {
+        command: 'plugins',
+        args: ['Install', 'owner/repo'],
+        rest: 'Install owner/repo',
+    });
+});
+test('getSlashCommandSuggestions shows top-level commands for bare slash input', () => {
+    const suggestions = getSlashCommandSuggestions('/', false, 4);
+    assert.deepEqual(suggestions.map((item) => item.label), ['/help', '/init', '/name [name]', '/abort']);
+});
+test('getSlashCommandSuggestions prioritizes exact and prefix matches', () => {
+    const suggestions = getSlashCommandSuggestions('/plug', false, 4);
+    assert.deepEqual(suggestions.map((item) => item.label), ['/plugins', '/plugins add', '/plugins install', '/plugins browse']);
+});
+test('getSlashCommandSuggestions returns subcommand completions with trailing spaces when needed', () => {
+    const [jump] = getSlashCommandSuggestions('/jump', false, 1);
+    const [pluginsAdd] = getSlashCommandSuggestions('/plugins a', false, 1);
+    assert.equal(jump?.insertText, '/jump ');
+    assert.equal(jump?.commandText, '/jump');
+    assert.equal(pluginsAdd?.insertText, '/plugins add ');
+    assert.equal(pluginsAdd?.commandText, '/plugins add');
+});
+test('getSlashCommandSuggestions hides unavailable commands while the agent is running', () => {
+    const suggestions = getSlashCommandSuggestions('/', true, 10);
+    assert.deepEqual(suggestions.map((item) => item.label), ['/help', '/abort']);
+});
+test('getSlashCommandSuggestions hides the popup once arguments are being typed', () => {
+    assert.deepEqual(getSlashCommandSuggestions('/model gpt-5', false), []);
+});
+test('getSlashCommandSuggestions hides the popup after a completion adds a trailing space', () => {
+    assert.deepEqual(getSlashCommandSuggestions('/plugins add ', false), []);
+});

package/dist/components/assistant-message-render.js

@@ -0,0 +1,52 @@
+const FENCE_RE = /^(```|~~~)/;
+const HEADING_RE = /^(#{1,6})\s+(.*)$/;
+const BULLET_RE = /^(\s*)[-*+]\s+(.*)$/;
+const ORDERED_RE = /^(\s*)(\d+)\.\s+(.*)$/;
+const BLOCKQUOTE_RE = /^>\s?(.*)$/;
+const HORIZONTAL_RULE_RE = /^\s*([-*_])(?:\s*\1){2,}\s*$/;
+function stripInlineMarkdown(text) {
+    return text
+        .replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (_match, alt, url) => (alt ? `${alt} (${url})` : url))
+        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '$1 ($2)')
+        .replace(/`([^`]+)`/g, '$1')
+        .replace(/\*\*([^*]+)\*\*/g, '$1')
+        .replace(/__([^_]+)__/g, '$1')
+        .replace(/\*([^*]+)\*/g, '$1')
+        .replace(/_([^_]+)_/g, '$1')
+        .replace(/~~([^~]+)~~/g, '$1');
+}
+function formatMarkdownLine(line) {
+    if (HORIZONTAL_RULE_RE.test(line)) {
+        return '────────';
+    }
+    const heading = line.match(HEADING_RE);
+    if (heading) {
+        return stripInlineMarkdown(heading[2]).trim();
+    }
+    const bullet = line.match(BULLET_RE);
+    if (bullet) {
+        return `${bullet[1]}• ${stripInlineMarkdown(bullet[2])}`;
+    }
+    const ordered = line.match(ORDERED_RE);
+    if (ordered) {
+        return `${ordered[1]}${ordered[2]}. ${stripInlineMarkdown(ordered[3])}`;
+    }
+    const quote = line.match(BLOCKQUOTE_RE);
+    if (quote) {
+        return `| ${stripInlineMarkdown(quote[1])}`;
+    }
+    return stripInlineMarkdown(line);
+}
+export function renderMarkdownLines(content) {
+    const lines = content.replace(/\r\n/g, '\n').split('\n');
+    const rendered = [];
+    let inFence = false;
+    for (const line of lines) {
+        if (FENCE_RE.test(line.trim())) {
+            inFence = !inFence;
+            continue;
+        }
+        rendered.push(inFence ? line : formatMarkdownLine(line));
+    }
+    return rendered;
+}

package/dist/components/assistant-message-render.test.js

@@ -0,0 +1,9 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { renderMarkdownLines } from './assistant-message-render.js';
+test('renderMarkdownLines flattens common markdown formatting for terminal output', () => {
+    assert.deepEqual(renderMarkdownLines('# Title\n\nSee [docs](https://example.com) and **bold** text.'), ['Title', '', 'See docs (https://example.com) and bold text.']);
+});
+test('renderMarkdownLines preserves code blocks while normalizing block syntax', () => {
+    assert.deepEqual(renderMarkdownLines('> note\n- item\n1. step\n---\n```ts\nconst value = 1;\n```'), ['| note', '• item', '1. step', '────────', 'const value = 1;']);
+});

package/dist/components/assistant-message.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+import { renderMarkdownLines } from './assistant-message-render.js';
+export const AssistantMessage = React.memo(function AssistantMessage({ content, showSpinner = false, spinner, }) {
+    const body = content.trimEnd();
+    const lines = renderMarkdownLines(body);
+    return (_jsxs(Box, { flexDirection: "column", children: [body ? lines.map((line, index) => (_jsx(Text, { children: line || ' ' }, index))) : _jsx(Text, { dimColor: true, children: "[no content]" }), showSpinner && spinner ? (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { children: " " }), spinner] })) : null] }));
+});

package/dist/components/editor.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from 'ink';
+export function Editor({ value, cursor, placeholder, secret, }) {
+    const content = secret ? '*'.repeat(value.length) : value;
+    const chars = Array.from(content);
+    const safeCursor = Math.max(0, Math.min(cursor, chars.length));
+    if (chars.length === 0) {
+        return (_jsxs(Text, { dimColor: true, children: [_jsx(Text, { inverse: true, children: " " }), placeholder ?? ''] }));
+    }
+    const before = chars.slice(0, safeCursor).join('');
+    const current = chars[safeCursor] ?? ' ';
+    const after = chars.slice(safeCursor + 1).join('');
+    return (_jsxs(Text, { children: [before, _jsx(Text, { inverse: true, children: current }), after] }));
+}
+export function editBuffer(current, input, key) {
+    const chars = Array.from(current.value);
+    let cursor = Math.max(0, Math.min(current.cursor, chars.length));
+    const isBackspaceInput = input === '\x7f' || input === '\b' || input === '\x08' || (key.ctrl && input === 'h');
+    const shouldTreatDeleteAsBackspace = key.delete && !input && cursor === chars.length && cursor > 0;
+    const isBackspace = key.backspace || isBackspaceInput || shouldTreatDeleteAsBackspace;
+    if (isBackspace) {
+        if (cursor > 0) {
+            chars.splice(cursor - 1, 1);
+            cursor -= 1;
+        }
+        return { ...current, value: chars.join(''), cursor };
+    }
+    // Delete - only if it wasn't already handled as a backspace
+    if (key.delete) {
+        if (cursor < chars.length) {
+            chars.splice(cursor, 1);
+        }
+        return { ...current, value: chars.join(''), cursor };
+    }
+    // Navigation
+    if (key.leftArrow) {
+        return { ...current, cursor: Math.max(0, cursor - 1) };
+    }
+    if (key.rightArrow) {
+        return { ...current, cursor: Math.min(chars.length, cursor + 1) };
+    }
+    if (key.home) {
+        return { ...current, cursor: 0 };
+    }
+    if (key.end) {
+        return { ...current, cursor: chars.length };
+    }
+    // Ignore control keys
+    if (key.ctrl || key.meta || key.return || key.tab || key.escape) {
+        return current;
+    }
+    // Character insertion
+    if (input && input.length > 0) {
+        const inputChars = Array.from(input).filter(c => {
+            const code = c.charCodeAt(0);
+            return code >= 32 && code !== 127;
+        });
+        if (inputChars.length > 0) {
+            chars.splice(cursor, 0, ...inputChars);
+            cursor += inputChars.length;
+        }
+        return { ...current, value: chars.join(''), cursor };
+    }
+    return current;
+}

package/dist/components/editor.test.js

@@ -0,0 +1,40 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { editBuffer } from './editor.js';
+function key(overrides = {}) {
+    return {
+        leftArrow: false,
+        rightArrow: false,
+        home: false,
+        end: false,
+        shift: false,
+        backspace: false,
+        delete: false,
+        return: false,
+        ctrl: false,
+        meta: false,
+        tab: false,
+        escape: false,
+        ...overrides,
+    };
+}
+test('backspace removes the character before the cursor', () => {
+    const result = editBuffer({ value: 'abc', cursor: 3 }, '', key({ backspace: true }));
+    assert.deepEqual(result, { value: 'ab', cursor: 2 });
+});
+test('DEL input is treated as backspace', () => {
+    const result = editBuffer({ value: 'abc', cursor: 3 }, '\x7f', key());
+    assert.deepEqual(result, { value: 'ab', cursor: 2 });
+});
+test('delete at end of line behaves like backspace for terminals that map it that way', () => {
+    const result = editBuffer({ value: 'abc', cursor: 3 }, '', key({ delete: true }));
+    assert.deepEqual(result, { value: 'ab', cursor: 2 });
+});
+test('delete inside the line still removes the character at the cursor', () => {
+    const result = editBuffer({ value: 'abcd', cursor: 1 }, '', key({ delete: true }));
+    assert.deepEqual(result, { value: 'acd', cursor: 1 });
+});
+test('ctrl+key combinations are ignored by the editor buffer', () => {
+    const result = editBuffer({ value: 'abcd', cursor: 2 }, 'p', key({ ctrl: true }));
+    assert.deepEqual(result, { value: 'abcd', cursor: 2 });
+});

package/dist/components/frame.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+export const Frame = React.memo(function Frame({ children, borderColor, topLeft, topRight, bottomLeft, bottomRight, paddingX = 1, }) {
+    const termWidth = process.stdout.columns || 80;
+    const usableWidth = termWidth - 2; // account for outer padding in app
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", children: [_jsx(TopBorder, { width: usableWidth, color: borderColor, left: topLeft, right: topRight }), _jsx(Box, { flexDirection: "column", paddingX: paddingX, children: children }), _jsx(BottomBorder, { width: usableWidth, color: borderColor, left: bottomLeft, right: bottomRight })] }));
+});
+function TopBorder({ width, color, left, right }) {
+    const leftText = left ? ` ${left} ` : '';
+    const rightText = right ? ` ${right} ` : '';
+    const fillLen = Math.max(0, width - 3 - leftText.length - rightText.length);
+    const fill = '─'.repeat(fillLen);
+    return (_jsxs(Text, { color: color, children: ["\u256D\u2500", leftText, fill, rightText, "\u256E"] }));
+}
+function BottomBorder({ width, color, left, right }) {
+    const leftText = left ? ` ${left} ` : '';
+    const rightText = right ? ` ${right} ` : '';
+    const fillLen = Math.max(0, width - 3 - leftText.length - rightText.length);
+    const fill = '─'.repeat(fillLen);
+    return (_jsxs(Text, { color: color, children: ["\u2570\u2500", leftText, fill, rightText, "\u256F"] }));
+}

package/dist/components/header.js

@@ -0,0 +1,63 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+import { Frame } from './frame.js';
+function stripEndpoint(endpoint) {
+    try {
+        const url = new URL(endpoint);
+        return url.hostname;
+    }
+    catch {
+        return endpoint;
+    }
+}
+function truncateStr(value, max) {
+    if (value.length <= max)
+        return value;
+    if (max <= 1)
+        return '…';
+    return value.slice(0, max - 1) + '…';
+}
+function statusColor(status) {
+    if (status === 'Error')
+        return 'redBright';
+    if (status === 'Idle')
+        return 'greenBright';
+    return 'yellowBright';
+}
+export function formatPendingToolsLine(pendingTools, termWidth) {
+    if (pendingTools.length === 0)
+        return ' ';
+    const joined = pendingTools.join(', ');
+    const maxToolWidth = termWidth - 8;
+    if (joined.length <= maxToolWidth) {
+        return `▸ ${joined}`;
+    }
+    const shown = [];
+    let len = 0;
+    for (const tool of pendingTools) {
+        const next = shown.length > 0 ? len + 2 + tool.length : tool.length;
+        const remaining = pendingTools.length - shown.length - 1;
+        const suffixLen = remaining > 0 ? ` …${remaining} more`.length : 0;
+        if (next + suffixLen > maxToolWidth && shown.length > 0) {
+            return `▸ ${shown.join(', ')} …${remaining + 1} more`;
+        }
+        shown.push(tool);
+        len = next;
+    }
+    return `▸ ${shown.join(', ')}`;
+}
+export const Header = React.memo(function Header({ agentName, sessionId, model, apiStyle, endpoint, permissionMode, thinkingLevel, status, pendingTools, }) {
+    const color = statusColor(status);
+    const termWidth = process.stdout.columns || 80;
+    // Build config line with progressive truncation for narrow terminals
+    const configParts = [model, apiStyle];
+    if (termWidth >= 60 && permissionMode !== 'default')
+        configParts.push(permissionMode);
+    if (termWidth >= 70 && thinkingLevel !== 'off')
+        configParts.push(`thinking:${thinkingLevel}`);
+    const host = truncateStr(stripEndpoint(endpoint), Math.max(10, termWidth - 30));
+    const toolsLine = formatPendingToolsLine(pendingTools, termWidth);
+    const toolsActive = pendingTools.length > 0;
+    return (_jsxs(Frame, { borderColor: "gray", children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { bold: true, color: "cyanBright", children: ["\u25CF ", truncateStr(agentName, Math.max(4, termWidth - status.length - 8))] }), _jsxs(Text, { color: color, children: ["\u25CF ", status] })] }), _jsx(Text, { dimColor: true, wrap: "truncate", children: configParts.join(' · ') }), _jsxs(Text, { dimColor: true, wrap: "truncate", children: [host, "  session:", sessionId.slice(0, 8)] }), _jsx(Text, { color: toolsActive ? 'yellow' : undefined, dimColor: !toolsActive, wrap: "truncate", children: toolsLine })] }));
+});

package/dist/components/header.test.js

@@ -0,0 +1,12 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { formatPendingToolsLine } from './header.js';
+test('formatPendingToolsLine keeps a placeholder row when there are no pending tools', () => {
+    assert.equal(formatPendingToolsLine([], 80), ' ');
+});
+test('formatPendingToolsLine shows the full tool list when it fits', () => {
+    assert.equal(formatPendingToolsLine(['shell', 'grep'], 80), '▸ shell, grep');
+});
+test('formatPendingToolsLine truncates long tool lists for narrow terminals', () => {
+    assert.equal(formatPendingToolsLine(['very-long-tool-name', 'another-tool', 'third-tool'], 24), '▸ very-long-tool-name …2 more');
+});

package/dist/components/log-row.js

@@ -0,0 +1,28 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+import { logColor } from '../utils.js';
+import { AssistantMessage } from './assistant-message.js';
+const SYMBOLS = {
+    system: '◆',
+    user: '▷',
+    assistant: '●',
+    tool: '▸',
+    error: '✗',
+};
+function formatTime(timestamp) {
+    const d = new Date(timestamp);
+    const h = String(d.getHours()).padStart(2, '0');
+    const m = String(d.getMinutes()).padStart(2, '0');
+    const s = String(d.getSeconds()).padStart(2, '0');
+    return `${h}:${m}:${s}`;
+}
+export const LogRow = React.memo(function LogRow({ entry }) {
+    const color = logColor(entry.kind);
+    const symbol = SYMBOLS[entry.kind] ?? '·';
+    const time = formatTime(entry.timestamp);
+    const bodyLines = (entry.body || '[no content]').split('\n');
+    const termWidth = process.stdout.columns || 80;
+    const showTime = termWidth >= 50;
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { color: color, bold: true, children: [symbol, " ", entry.title] }), showTime ? _jsx(Text, { dimColor: true, children: time }) : null] }), _jsx(Box, { paddingLeft: 2, flexDirection: "column", children: entry.kind === 'assistant' ? (_jsx(AssistantMessage, { content: entry.body || '[no content]' })) : (bodyLines.map((line, index) => (_jsx(Text, { wrap: "truncate", children: line || ' ' }, `${entry.id}-${index}`)))) })] }));
+});

package/dist/components/picker.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Frame } from './frame.js';
+export function PickerPanel({ pickerState }) {
+    const descriptionLines = pickerState.description ? pickerState.description.split('\n') : [];
+    return (_jsxs(Frame, { borderColor: "blueBright", topLeft: pickerState.title, bottomLeft: "\u2191\u2193 choose \u00B7 Enter confirm \u00B7 Esc", children: [descriptionLines.length > 0 ? (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: descriptionLines.map((line, index) => (_jsx(Text, { dimColor: true, children: line || ' ' }, `desc-${index}`))) })) : null, _jsx(Box, { flexDirection: "column", children: pickerState.items.length === 0 ? (_jsx(Text, { dimColor: true, children: pickerState.emptyMessage ?? 'No items available.' })) : (pickerState.items.map((item, index) => {
+                    const selected = index === pickerState.selectedIndex;
+                    return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: "cyanBright", children: selected ? ' › ' : '   ' }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: selected, color: selected ? 'white' : 'gray', children: item.label }), item.description ? (_jsx(Text, { dimColor: true, italic: true, children: item.description })) : null] })] }, item.id));
+                })) })] }));
+}

package/dist/components/prompt.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Frame } from './frame.js';
+import { Editor } from './editor.js';
+export function PromptPanel({ promptState }) {
+    const descriptionLines = promptState.description ? promptState.description.split('\n') : [];
+    return (_jsxs(Frame, { borderColor: "yellow", topLeft: promptState.title, bottomLeft: "Enter submit \u00B7 Esc cancel", children: [descriptionLines.length > 0 ? (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: descriptionLines.map((line, index) => (_jsx(Text, { dimColor: true, children: line || ' ' }, `desc-${index}`))) })) : null, _jsxs(Box, { children: [_jsx(Text, { color: "yellowBright", bold: true, children: ': ' }), _jsx(Editor, { value: promptState.value, cursor: promptState.cursor, placeholder: promptState.placeholder, secret: promptState.secret })] })] }));
+}

package/dist/components/scrollbar.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+export const Scrollbar = React.memo(function Scrollbar({ trackHeight, totalEntries, visibleEntries, offset, }) {
+    if (totalEntries <= visibleEntries || trackHeight < 1) {
+        return (_jsx(Box, { flexDirection: "column", width: 2, children: Array.from({ length: trackHeight }, (_, i) => (_jsx(Text, { dimColor: true, children: " " }, i))) }));
+    }
+    const thumbSize = Math.max(1, Math.round((visibleEntries / totalEntries) * trackHeight));
+    const maxOffset = totalEntries - visibleEntries;
+    const thumbPosition = Math.round(((maxOffset - offset) / maxOffset) * (trackHeight - thumbSize));
+    return (_jsx(Box, { flexDirection: "column", width: 2, children: Array.from({ length: trackHeight }, (_, i) => {
+            const isThumb = i >= thumbPosition && i < thumbPosition + thumbSize;
+            return (_jsx(Text, { dimColor: !isThumb, children: isThumb ? ' █' : ' ░' }, i));
+        }) }));
+});

package/dist/components/slash-command-menu.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Frame } from './frame.js';
+export function SlashCommandMenu({ items, selectedIndex, }) {
+    return (_jsx(Frame, { borderColor: "magentaBright", topLeft: "Commands", bottomLeft: "\u2191\u2193 choose \u00B7 Tab/Enter complete", children: _jsx(Box, { flexDirection: "column", children: items.map((item, index) => {
+                const selected = index === selectedIndex;
+                return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: "magentaBright", children: selected ? ' › ' : '   ' }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: selected, color: selected ? 'white' : 'gray', children: item.label }), _jsx(Text, { dimColor: true, children: item.description })] })] }, item.id));
+            }) }) }));
+}

package/dist/config.js

@@ -0,0 +1,168 @@
+import process from 'node:process';
+import { randomUUID } from 'node:crypto';
+import { resolve } from 'node:path';
+import { loadResolvedPreferences, normalizeAgentName, normalizeEndpoint, resolveConfiguredSkills } from './utils.js';
+export const COMPAT_DEFAULT_ENDPOINT = 'https://api.research.computer/v1';
+export const COMPAT_DEFAULT_MODEL = 'zai-org/GLM-4.7-Flash';
+export const COMPAT_DEFAULT_API_STYLE = 'chat';
+export function parsePermissionMode(value) {
+    if (!value)
+        return undefined;
+    if (value === 'default' || value === 'allowAll' || value === 'rulesOnly')
+        return value;
+    return undefined;
+}
+export function parseThinkingLevel(value) {
+    if (!value)
+        return undefined;
+    if (value === 'off' ||
+        value === 'minimal' ||
+        value === 'low' ||
+        value === 'medium' ||
+        value === 'high' ||
+        value === 'xhigh') {
+        return value;
+    }
+    return undefined;
+}
+export function parseCompatApiStyle(value) {
+    if (!value)
+        return undefined;
+    if (value === 'chat' || value === 'responses')
+        return value;
+    return undefined;
+}
+export function describeConfig(config) {
+    const skillNames = config.skills.map((skill) => skill.id).join(', ') || 'none';
+    return [
+        `Agent ${config.agentName}`,
+        `CWD ${config.cwd}`,
+        `Session ${config.sessionId}`,
+        `Permissions ${config.permissionMode}`,
+        `Thinking ${config.thinkingLevel}`,
+        `Endpoint ${config.selection.endpoint}`,
+        `Model ${config.selection.model}`,
+        `API style ${config.selection.apiStyle}`,
+        `Skills ${skillNames}`,
+    ].join('\n');
+}
+function requireValue(flag, value) {
+    if (!value) {
+        throw new Error(`Missing value for ${flag}`);
+    }
+    return value;
+}
+export function parseArgs(argv) {
+    const resolvedCwd = resolveCliCwd(argv);
+    const storedPreferences = loadResolvedPreferences(resolvedCwd);
+    const envApiStyle = parseCompatApiStyle(process.env.PISTA_API_STYLE);
+    const selection = {
+        endpoint: process.env.PISTA_ENDPOINT ?? storedPreferences.selection?.endpoint ?? COMPAT_DEFAULT_ENDPOINT,
+        model: process.env.PISTA_MODEL ?? storedPreferences.selection?.model ?? COMPAT_DEFAULT_MODEL,
+        apiStyle: envApiStyle ?? storedPreferences.selection?.apiStyle ?? COMPAT_DEFAULT_API_STYLE,
+    };
+    const config = {
+        agentName: normalizeAgentName(process.env.PISTA_NAME ?? 'Pista'),
+        cwd: resolvedCwd,
+        sessionId: process.env.PISTA_SESSION_ID ?? randomUUID(),
+        permissionMode: parsePermissionMode(process.env.PISTA_PERMISSION_MODE) ?? 'default',
+        thinkingLevel: parseThinkingLevel(process.env.PISTA_THINKING) ?? 'off',
+        selection,
+        skills: resolveConfiguredSkills(storedPreferences.skills),
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        const nextValue = argv[index + 1];
+        if (arg === '--help' || arg === '-h') {
+            printHelp();
+            return null;
+        }
+        switch (arg) {
+            case '--cwd':
+                config.cwd = resolve(requireValue(arg, nextValue));
+                index += 1;
+                break;
+            case '--name':
+                config.agentName = normalizeAgentName(requireValue(arg, nextValue));
+                index += 1;
+                break;
+            case '--session':
+                config.sessionId = requireValue(arg, nextValue);
+                index += 1;
+                break;
+            case '--permission-mode': {
+                const permissionMode = parsePermissionMode(requireValue(arg, nextValue));
+                if (!permissionMode) {
+                    throw new Error('Expected permission mode to be one of: default, allowAll, rulesOnly');
+                }
+                config.permissionMode = permissionMode;
+                index += 1;
+                break;
+            }
+            case '--thinking': {
+                const thinkingLevel = parseThinkingLevel(requireValue(arg, nextValue));
+                if (!thinkingLevel) {
+                    throw new Error('Expected thinking level to be one of: off, minimal, low, medium, high, xhigh');
+                }
+                config.thinkingLevel = thinkingLevel;
+                index += 1;
+                break;
+            }
+            case '--model':
+            case '-m':
+                config.selection.model = requireValue(arg, nextValue);
+                index += 1;
+                break;
+            case '--endpoint':
+                config.selection.endpoint = normalizeEndpoint(requireValue(arg, nextValue));
+                index += 1;
+                break;
+            case '--api-style': {
+                const apiStyle = parseCompatApiStyle(requireValue(arg, nextValue));
+                if (!apiStyle) {
+                    throw new Error('Expected API style to be "chat" or "responses".');
+                }
+                config.selection.apiStyle = apiStyle;
+                index += 1;
+                break;
+            }
+            default:
+                throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    validateConfig(config);
+    return config;
+}
+function validateConfig(config) {
+    normalizeEndpoint(config.selection.endpoint);
+    if (!config.selection.model.trim()) {
+        throw new Error('Model id is required.');
+    }
+}
+function resolveCliCwd(argv) {
+    let cwd = resolve(process.env.PISTA_CWD ?? process.cwd());
+    for (let index = 0; index < argv.length; index += 1) {
+        if (argv[index] === '--cwd') {
+            cwd = resolve(requireValue('--cwd', argv[index + 1]));
+            index += 1;
+        }
+    }
+    return cwd;
+}
+function printHelp() {
+    process.stdout.write([
+        'Usage: pista [options]',
+        '',
+        'Options:',
+        '  --model, -m <id>             Model id (default: gpt-4o-mini)',
+        '  --name <agent-name>          Display name for the coding agent',
+        '  --endpoint <url>             Base URL (default: https://api.research.computer/v1)',
+        '  --api-style <chat|responses> API style (default: chat)',
+        '  --cwd <path>                 Working directory for the agent',
+        '  --session <id>               Session id',
+        '  --permission-mode <mode>     default | allowAll | rulesOnly',
+        '  --thinking <level>           off | minimal | low | medium | high | xhigh',
+        '  --help, -h                   Show this help',
+        '',
+    ].join('\n'));
+}

package/dist/config.test.js

@@ -0,0 +1,45 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { parseArgs } from './config.js';
+test('parseArgs reads PISTA_* environment overrides', () => {
+    const previous = {
+        PISTA_MODEL: process.env.PISTA_MODEL,
+        PISTA_NAME: process.env.PISTA_NAME,
+        PISTA_ENDPOINT: process.env.PISTA_ENDPOINT,
+        PISTA_API_STYLE: process.env.PISTA_API_STYLE,
+        PISTA_CWD: process.env.PISTA_CWD,
+        PISTA_SESSION_ID: process.env.PISTA_SESSION_ID,
+        PISTA_PERMISSION_MODE: process.env.PISTA_PERMISSION_MODE,
+        PISTA_THINKING: process.env.PISTA_THINKING,
+    };
+    process.env.PISTA_MODEL = 'env-model';
+    process.env.PISTA_NAME = 'Env Agent';
+    process.env.PISTA_ENDPOINT = 'https://env.example/v1';
+    process.env.PISTA_API_STYLE = 'responses';
+    process.env.PISTA_CWD = '/tmp/pista-cwd';
+    process.env.PISTA_SESSION_ID = 'env-session';
+    process.env.PISTA_PERMISSION_MODE = 'allowAll';
+    process.env.PISTA_THINKING = 'high';
+    try {
+        const config = parseArgs([]);
+        assert.ok(config);
+        assert.equal(config.selection.model, 'env-model');
+        assert.equal(config.agentName, 'Env Agent');
+        assert.equal(config.selection.endpoint, 'https://env.example/v1');
+        assert.equal(config.selection.apiStyle, 'responses');
+        assert.equal(config.cwd, '/tmp/pista-cwd');
+        assert.equal(config.sessionId, 'env-session');
+        assert.equal(config.permissionMode, 'allowAll');
+        assert.equal(config.thinkingLevel, 'high');
+    }
+    finally {
+        for (const [key, value] of Object.entries(previous)) {
+            if (value === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = value;
+            }
+        }
+    }
+});

package/dist/index.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import process from 'node:process';
+import { render } from 'ink';
+import { App } from './app.js';
+import { parseArgs } from './config.js';
+import { errorMessage } from './utils.js';
+async function main() {
+    const config = parseArgs(process.argv.slice(2));
+    if (!config)
+        return;
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error('This example CLI requires an interactive TTY.');
+    }
+    const app = render(_jsx(App, { initialConfig: config }), {
+        exitOnCtrlC: false,
+        incrementalRendering: true,
+        patchConsole: true,
+        maxFps: 30,
+    });
+    await app.waitUntilExit();
+}
+void main().catch((error) => {
+    process.stderr.write(`Error: ${errorMessage(error)}\n`);
+    process.exit(1);
+});

package/dist/model.js

@@ -0,0 +1,17 @@
+export function resolveModel(selection, thinkingLevel = 'off') {
+    return {
+        id: selection.model,
+        name: selection.model,
+        api: selection.apiStyle === 'responses' ? 'openai-responses' : 'openai-completions',
+        provider: 'openai-compatible',
+        baseUrl: selection.endpoint,
+        reasoning: thinkingLevel !== 'off',
+        input: ['text', 'image'],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 128_000,
+        maxTokens: 32_768,
+    };
+}
+export function describeSelection(selection) {
+    return `${selection.model} (${selection.apiStyle}) @ ${selection.endpoint}`;
+}