profclaw 2.0.0 → 2.4.0

package/dist/cli/ink/keybindings.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Keybindings Configuration
+ *
+ * Loads, saves, and matches keyboard shortcuts.
+ * User overrides are read from .profclaw/keybindings.json and merged
+ * with the default set so unknown keys are always preserved.
+ */
+export interface Keybinding {
+    key: string;
+    action: string;
+    description: string;
+}
+export interface KeyModifiers {
+    ctrl?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+}
+export declare const DEFAULT_KEYBINDINGS: Keybinding[];
+/**
+ * Load keybindings from the config file, merged with defaults.
+ * User-defined entries override defaults by `action`; entries in the config
+ * that don't match any default action are appended as custom bindings.
+ */
+export declare function loadKeybindings(configPath?: string): Keybinding[];
+/**
+ * Persist keybindings to the config file.
+ * Creates the .profclaw directory if it doesn't exist.
+ */
+export declare function saveKeybindings(bindings: Keybinding[], configPath?: string): void;
+/**
+ * Find the first keybinding matching a key + modifier combination.
+ * Returns undefined when no match is found.
+ */
+export declare function matchKeybinding(key: string, modifiers: KeyModifiers, bindings: Keybinding[]): Keybinding | undefined;
+//# sourceMappingURL=keybindings.d.ts.map

package/dist/cli/ink/keybindings.js

@@ -0,0 +1,105 @@
+/**
+ * Keybindings Configuration
+ *
+ * Loads, saves, and matches keyboard shortcuts.
+ * User overrides are read from .profclaw/keybindings.json and merged
+ * with the default set so unknown keys are always preserved.
+ */
+import fs from 'fs';
+import path from 'path';
+// ── Defaults ──────────────────────────────────────────────────────────────────
+export const DEFAULT_KEYBINDINGS = [
+    { key: 'ctrl+l', action: 'clear', description: 'Clear screen' },
+    { key: 'ctrl+c', action: 'cancel', description: 'Cancel current operation' },
+    { key: 'ctrl+d', action: 'exit', description: 'Quit' },
+    { key: 'alt+enter', action: 'multiline', description: 'Enter multiline mode' },
+    { key: 'shift+tab', action: 'toggle-thinking', description: 'Toggle thinking display' },
+    { key: 'ctrl+p', action: 'session-picker', description: 'Open session picker' },
+];
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function defaultConfigPath() {
+    return path.join(process.cwd(), '.profclaw', 'keybindings.json');
+}
+/**
+ * Normalise a key string to lowercase with sorted modifiers so comparisons
+ * are consistent regardless of how the caller orders modifier names.
+ * e.g. "Ctrl+Shift+L" → "ctrl+shift+l"
+ */
+function normaliseKey(key) {
+    const parts = key.toLowerCase().split('+').map(p => p.trim());
+    const modifiers = parts.filter(p => ['ctrl', 'alt', 'shift'].includes(p)).sort();
+    const rest = parts.filter(p => !['ctrl', 'alt', 'shift'].includes(p));
+    return [...modifiers, ...rest].join('+');
+}
+/**
+ * Build a normalised key string from a bare key name and a modifiers object
+ * (as produced by Ink's `useInput` hook).
+ */
+function buildKeyString(key, modifiers) {
+    const parts = [];
+    if (modifiers.ctrl)
+        parts.push('ctrl');
+    if (modifiers.alt)
+        parts.push('alt');
+    if (modifiers.shift)
+        parts.push('shift');
+    parts.push(key.toLowerCase());
+    return parts.join('+');
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Load keybindings from the config file, merged with defaults.
+ * User-defined entries override defaults by `action`; entries in the config
+ * that don't match any default action are appended as custom bindings.
+ */
+export function loadKeybindings(configPath) {
+    const filePath = configPath ?? defaultConfigPath();
+    let userBindings = [];
+    if (fs.existsSync(filePath)) {
+        try {
+            const raw = fs.readFileSync(filePath, 'utf8');
+            userBindings = JSON.parse(raw);
+        }
+        catch {
+            // Malformed JSON — fall back to defaults silently
+        }
+    }
+    if (userBindings.length === 0) {
+        return [...DEFAULT_KEYBINDINGS];
+    }
+    // Merge: for each default, check if user overrides by action
+    const userByAction = new Map(userBindings.map(b => [b.action, b]));
+    const merged = DEFAULT_KEYBINDINGS.map(def => {
+        const override = userByAction.get(def.action);
+        return override ? { ...def, ...override } : def;
+    });
+    // Append any custom user bindings whose action isn't in the defaults
+    const defaultActions = new Set(DEFAULT_KEYBINDINGS.map(b => b.action));
+    for (const binding of userBindings) {
+        if (!defaultActions.has(binding.action)) {
+            merged.push(binding);
+        }
+    }
+    return merged;
+}
+/**
+ * Persist keybindings to the config file.
+ * Creates the .profclaw directory if it doesn't exist.
+ */
+export function saveKeybindings(bindings, configPath) {
+    const filePath = configPath ?? defaultConfigPath();
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, JSON.stringify(bindings, null, 2), 'utf8');
+}
+/**
+ * Find the first keybinding matching a key + modifier combination.
+ * Returns undefined when no match is found.
+ */
+export function matchKeybinding(key, modifiers, bindings) {
+    const pressed = normaliseKey(buildKeyString(key, modifiers));
+    return bindings.find(b => normaliseKey(b.key) === pressed);
+}
+//# sourceMappingURL=keybindings.js.map

package/dist/cli/ink/markdown-renderer.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Markdown Renderer for Ink TUI
+ *
+ * Converts markdown text to Ink React elements with proper formatting.
+ * Ports the syntax highlighting and inline formatting patterns from
+ * src/cli/interactive/renderer.ts, adapted to output Ink Text/Box nodes
+ * instead of ANSI escape codes.
+ *
+ * Supports:
+ *   - **bold**, *italic*, `inline code`, ~~strikethrough~~
+ *   - ```lang ... ``` code blocks with syntax highlighting
+ *   - # ## ### headings
+ *   - > blockquotes
+ *   - - / * bullet lists and 1. numbered lists
+ *   - [text](url) links
+ *   - --- horizontal rules
+ */
+import type { ReactElement } from 'react';
+export interface RenderOptions {
+    maxWidth?: number;
+    syntaxHighlight?: boolean;
+    linkStyle?: 'inline' | 'footnote' | 'hidden';
+}
+/**
+ * Renders a single line of code with syntax highlighting.
+ * Returns an array of React elements (one per token).
+ */
+export declare function highlightCode(code: string, language: string): ReactElement;
+/**
+ * Convert a markdown string to Ink React elements.
+ *
+ * Handles:
+ *   - **bold**, *italic*, `inline code`, ~~strikethrough~~
+ *   - ```lang ... ``` code blocks with optional syntax highlighting
+ *   - # / ## / ### headings → bold cyan
+ *   - > blockquotes → dim italic with left border
+ *   - - / * bullet and 1. numbered lists with indent
+ *   - [text](url) links
+ *   - --- horizontal rules
+ */
+export declare function renderMarkdown(text: string, options?: RenderOptions): ReactElement;
+/**
+ * Strip all markdown formatting from text, returning plain readable text.
+ * Used by /copy and /save operations.
+ */
+export declare function stripMarkdown(text: string): string;
+//# sourceMappingURL=markdown-renderer.d.ts.map

package/dist/cli/ink/markdown-renderer.js

@@ -0,0 +1,380 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+// ── Syntax highlighting ───────────────────────────────────────────────────────
+const JS_KEYWORDS = new Set([
+    'const', 'let', 'var', 'function', 'async', 'await', 'return',
+    'import', 'export', 'from', 'default', 'class', 'extends', 'super',
+    'this', 'if', 'else', 'for', 'while', 'do', 'switch', 'case',
+    'break', 'continue', 'try', 'catch', 'finally', 'throw', 'new',
+    'delete', 'typeof', 'instanceof', 'yield', 'of', 'in', 'static',
+    'get', 'set', 'enum', 'interface', 'type', 'implements', 'declare',
+    'abstract', 'readonly', 'as', 'is', 'keyof', 'infer', 'satisfies',
+]);
+const PY_KEYWORDS = new Set([
+    'def', 'class', 'if', 'elif', 'else', 'for', 'while', 'try',
+    'except', 'finally', 'with', 'as', 'import', 'from', 'return',
+    'yield', 'raise', 'pass', 'break', 'continue', 'and', 'or', 'not',
+    'in', 'is', 'lambda', 'global', 'nonlocal', 'True', 'False', 'None',
+    'async', 'await', 'self',
+]);
+const COMMON_TYPES = new Set([
+    'string', 'number', 'boolean', 'void', 'null', 'undefined', 'any',
+    'never', 'unknown', 'object', 'Array', 'Map', 'Set', 'Promise',
+    'Record', 'Partial', 'Required', 'Readonly', 'Pick', 'Omit',
+    'int', 'float', 'str', 'bool', 'list', 'dict', 'tuple',
+    // From the spec
+    'Dict', 'List', 'Optional',
+]);
+function tokenizeLine(line, lang) {
+    const isPython = lang === 'python' || lang === 'py';
+    const isBash = lang === 'bash' || lang === 'shell' || lang === 'sh';
+    const isJson = lang === 'json';
+    const isYaml = lang === 'yaml' || lang === 'yml';
+    // Comments (whole line)
+    const commentMatch = line.match(/^(\s*)(\/\/.*|#.*)$/);
+    if (commentMatch) {
+        const tokens = [];
+        if (commentMatch[1])
+            tokens.push({ kind: 'plain', value: commentMatch[1] });
+        tokens.push({ kind: 'comment', value: commentMatch[2] });
+        return tokens;
+    }
+    // For JSON/YAML, do minimal tokenization (strings + numbers)
+    if (isJson || isYaml || isBash) {
+        return tokenizeSimple(line);
+    }
+    // Full tokenization for JS/TS/Python/Go/Rust
+    const tokens = [];
+    const keywords = isPython ? PY_KEYWORDS : JS_KEYWORDS;
+    // We walk the string and emit tokens as we go.
+    // Strategy: scan for strings first (they can contain keywords), then others.
+    let i = 0;
+    let plain = '';
+    const flushPlain = () => {
+        if (!plain)
+            return;
+        // Match: identifier (possibly followed by '('), standalone number, or any other char.
+        // NOTE: \s* is NOT used after identifiers — whitespace is captured by the `\s+` arm
+        // so it is emitted as a plain token and not silently swallowed.
+        const wordRe = /([a-zA-Z_]\w*)(\()?|\b(\d+\.?\d*)\b|(\s+)|([\S])/g;
+        let wm;
+        const plainResult = [];
+        let wp = 0;
+        while ((wm = wordRe.exec(plain)) !== null) {
+            if (wm.index > wp) {
+                plainResult.push({ kind: 'plain', value: plain.slice(wp, wm.index) });
+            }
+            wp = wm.index + wm[0].length;
+            if (wm[3] !== undefined) {
+                // standalone number (not part of an identifier)
+                plainResult.push({ kind: 'number', value: wm[3] });
+            }
+            else if (wm[4] !== undefined) {
+                // whitespace — always emit as plain so spacing is preserved
+                plainResult.push({ kind: 'plain', value: wm[4] });
+            }
+            else if (wm[5] !== undefined) {
+                // any other non-space character
+                plainResult.push({ kind: 'plain', value: wm[5] });
+            }
+            else if (wm[1] !== undefined) {
+                const word = wm[1];
+                const hasParens = wm[2] !== undefined;
+                if (keywords.has(word)) {
+                    plainResult.push({ kind: 'keyword', value: word });
+                    if (hasParens)
+                        plainResult.push({ kind: 'plain', value: '(' });
+                }
+                else if (COMMON_TYPES.has(word)) {
+                    plainResult.push({ kind: 'type', value: word });
+                    if (hasParens)
+                        plainResult.push({ kind: 'plain', value: '(' });
+                }
+                else if (hasParens) {
+                    plainResult.push({ kind: 'func', value: word });
+                    plainResult.push({ kind: 'plain', value: '(' });
+                }
+                else {
+                    plainResult.push({ kind: 'plain', value: word });
+                }
+            }
+        }
+        if (wp < plain.length) {
+            plainResult.push({ kind: 'plain', value: plain.slice(wp) });
+        }
+        tokens.push(...plainResult);
+        plain = '';
+    };
+    while (i < line.length) {
+        const ch = line[i];
+        // String literals (single, double, backtick)
+        if (ch === '"' || ch === "'" || ch === '`') {
+            flushPlain();
+            const quote = ch;
+            let str = quote;
+            i++;
+            while (i < line.length) {
+                const c = line[i];
+                str += c;
+                if (c === '\\') {
+                    i++;
+                    if (i < line.length) {
+                        str += line[i];
+                        i++;
+                    }
+                    continue;
+                }
+                if (c === quote) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            tokens.push({ kind: 'string', value: str });
+            continue;
+        }
+        plain += ch;
+        i++;
+    }
+    flushPlain();
+    return tokens;
+}
+function tokenizeSimple(line) {
+    const tokens = [];
+    const strRe = /(["'])(?:(?!\1|\\).|\\.)*?\1|\b(\d+\.?\d*)\b/g;
+    let last = 0;
+    let m;
+    while ((m = strRe.exec(line)) !== null) {
+        if (m.index > last) {
+            tokens.push({ kind: 'plain', value: line.slice(last, m.index) });
+        }
+        if (m[1] !== undefined) {
+            tokens.push({ kind: 'string', value: m[0] });
+        }
+        else {
+            tokens.push({ kind: 'number', value: m[0] });
+        }
+        last = m.index + m[0].length;
+    }
+    if (last < line.length) {
+        tokens.push({ kind: 'plain', value: line.slice(last) });
+    }
+    return tokens;
+}
+function tokenColor(kind) {
+    switch (kind) {
+        case 'comment': return '#546E7A';
+        case 'string': return '#C3E88D';
+        case 'number': return '#F78C6C';
+        case 'keyword': return '#C792EA';
+        case 'type': return '#FFCB6B';
+        case 'func': return '#82AAFF';
+        default: return undefined;
+    }
+}
+/**
+ * Renders a single line of code with syntax highlighting.
+ * Returns an array of React elements (one per token).
+ */
+export function highlightCode(code, language) {
+    const tokens = tokenizeLine(code, language);
+    return (_jsx(Text, { children: tokens.map((tok, i) => {
+            const color = tokenColor(tok.kind);
+            return color
+                ? _jsx(Text, { color: color, children: tok.value }, i)
+                : _jsx(Text, { children: tok.value }, i);
+        }) }));
+}
+function parseInline(text) {
+    const segments = [];
+    // Order matters: bold (**) before italic (*), strike (~~) before others
+    const re = /(\*\*(.+?)\*\*|~~(.+?)~~|\*([^*\n]+)\*(?!\*)|_([^_\n]+)_|`([^`]+)`|\[([^\]\n]+)\]\(([^)\n]+)\))/g;
+    let last = 0;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        if (m.index > last) {
+            segments.push({ type: 'text', value: text.slice(last, m.index) });
+        }
+        if (m[2] !== undefined) {
+            segments.push({ type: 'bold', value: m[2] });
+        }
+        else if (m[3] !== undefined) {
+            segments.push({ type: 'strike', value: m[3] });
+        }
+        else if (m[4] !== undefined) {
+            segments.push({ type: 'italic', value: m[4] });
+        }
+        else if (m[5] !== undefined) {
+            segments.push({ type: 'italic', value: m[5] });
+        }
+        else if (m[6] !== undefined) {
+            segments.push({ type: 'code', value: m[6] });
+        }
+        else if (m[7] !== undefined && m[8] !== undefined) {
+            segments.push({ type: 'link', label: m[7], url: m[8] });
+        }
+        last = m.index + m[0].length;
+    }
+    if (last < text.length) {
+        segments.push({ type: 'text', value: text.slice(last) });
+    }
+    return segments;
+}
+const InlineSegmentNode = ({ seg, linkStyle }) => {
+    switch (seg.type) {
+        case 'bold':
+            return _jsx(Text, { bold: true, children: seg.value });
+        case 'italic':
+            return _jsx(Text, { italic: true, children: seg.value });
+        case 'code':
+            return _jsx(Text, { color: "#F0C987", children: seg.value });
+        case 'strike':
+            return _jsx(Text, { strikethrough: true, dimColor: true, children: seg.value });
+        case 'link': {
+            if (linkStyle === 'hidden') {
+                return _jsx(Text, { children: seg.label });
+            }
+            if (linkStyle === 'footnote') {
+                return (_jsxs(Text, { children: [_jsx(Text, { color: "blue", underline: true, children: seg.label }), _jsx(Text, { dimColor: true, children: ' (' + seg.url + ')' })] }));
+            }
+            // Default: inline — label in blue + underline
+            return _jsx(Text, { color: "blue", underline: true, children: seg.label });
+        }
+        default:
+            return _jsx(Text, { children: seg.value });
+    }
+};
+const InlineText = ({ text, linkStyle }) => {
+    const segs = parseInline(text);
+    if (segs.length === 1 && segs[0].type === 'text') {
+        return _jsx(Text, { children: segs[0].value });
+    }
+    return (_jsx(Text, { children: segs.map((seg, i) => (_jsx(InlineSegmentNode, { seg: seg, linkStyle: linkStyle }, i))) }));
+};
+const BlockLine = ({ line, inCode, codeLang, linkStyle, syntaxHighlight, }) => {
+    // Inside code block
+    if (inCode) {
+        return (_jsxs(Box, { paddingLeft: 1, children: [_jsx(Text, { color: "#3C414B", children: "\u2502 " }), syntaxHighlight
+                    ? highlightCode(line, codeLang)
+                    : _jsx(Text, { color: "#F0C987", children: line })] }));
+    }
+    // H1
+    if (line.startsWith('# ')) {
+        return (_jsx(Text, { bold: true, color: "cyan", children: _jsx(InlineText, { text: line.slice(2), linkStyle: linkStyle }) }));
+    }
+    // H2
+    if (line.startsWith('## ')) {
+        return (_jsx(Text, { bold: true, color: "cyan", children: _jsx(InlineText, { text: line.slice(3), linkStyle: linkStyle }) }));
+    }
+    // H3+
+    if (line.startsWith('### ')) {
+        return (_jsx(Text, { bold: true, children: _jsx(InlineText, { text: line.slice(4), linkStyle: linkStyle }) }));
+    }
+    if (line.startsWith('#### ')) {
+        return (_jsx(Text, { bold: true, children: _jsx(InlineText, { text: line.slice(5), linkStyle: linkStyle }) }));
+    }
+    // Blockquote
+    if (line.startsWith('> ')) {
+        return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: "#3C414B", children: "\u2502 " }), _jsx(Text, { italic: true, dimColor: true, children: _jsx(InlineText, { text: line.slice(2), linkStyle: linkStyle }) })] }));
+    }
+    // Bullet list
+    const bullet = line.match(/^(\s*)([-*])\s(.*)/);
+    if (bullet) {
+        const indent = bullet[1].length;
+        return (_jsxs(Box, { paddingLeft: indent + 2, flexDirection: "row", gap: 1, children: [_jsx(Text, { dimColor: true, children: "\u203A" }), _jsx(InlineText, { text: bullet[3], linkStyle: linkStyle })] }));
+    }
+    // Numbered list
+    const num = line.match(/^(\s*)(\d+\.)\s(.*)/);
+    if (num) {
+        const indent = num[1].length;
+        return (_jsxs(Box, { paddingLeft: indent + 2, flexDirection: "row", gap: 1, children: [_jsx(Text, { dimColor: true, children: num[2] }), _jsx(InlineText, { text: num[3], linkStyle: linkStyle })] }));
+    }
+    // Horizontal rule
+    if (line.match(/^[-*_]{3,}$/)) {
+        return _jsx(Text, { dimColor: true, children: '─'.repeat(40) });
+    }
+    // Empty line — spacer
+    if (line.trim() === '') {
+        return _jsx(Text, { children: ' ' });
+    }
+    // Normal paragraph text
+    return _jsx(InlineText, { text: line, linkStyle: linkStyle });
+};
+// ── Code fence header/footer components ──────────────────────────────────────
+const CodeFenceOpen = ({ lang }) => (_jsxs(Box, { paddingLeft: 1, children: [_jsx(Text, { dimColor: true, children: '┌───' }), lang ? _jsxs(Text, { dimColor: true, children: [" ", lang] }) : null] }));
+const CodeFenceClose = () => (_jsx(Box, { paddingLeft: 1, children: _jsx(Text, { dimColor: true, children: "\u2514\u2500\u2500\u2500" }) }));
+// ── Main renderMarkdown function ──────────────────────────────────────────────
+/**
+ * Convert a markdown string to Ink React elements.
+ *
+ * Handles:
+ *   - **bold**, *italic*, `inline code`, ~~strikethrough~~
+ *   - ```lang ... ``` code blocks with optional syntax highlighting
+ *   - # / ## / ### headings → bold cyan
+ *   - > blockquotes → dim italic with left border
+ *   - - / * bullet and 1. numbered lists with indent
+ *   - [text](url) links
+ *   - --- horizontal rules
+ */
+export function renderMarkdown(text, options) {
+    const syntaxHighlight = options?.syntaxHighlight ?? true;
+    const linkStyle = options?.linkStyle ?? 'inline';
+    const lines = text.split('\n');
+    const nodes = [];
+    let inCode = false;
+    let codeLang = '';
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.startsWith('```')) {
+            if (inCode) {
+                inCode = false;
+                nodes.push(_jsx(CodeFenceClose, {}, `cfclose-${i}`));
+                codeLang = '';
+            }
+            else {
+                inCode = true;
+                codeLang = line.slice(3).trim();
+                nodes.push(_jsx(CodeFenceOpen, { lang: codeLang }, `cfopen-${i}`));
+            }
+            continue;
+        }
+        nodes.push(_jsx(Box, { children: _jsx(BlockLine, { line: line, inCode: inCode, codeLang: codeLang, linkStyle: linkStyle, syntaxHighlight: syntaxHighlight }) }, `line-${i}`));
+    }
+    return (_jsx(Box, { flexDirection: "column", children: nodes }));
+}
+// ── stripMarkdown ─────────────────────────────────────────────────────────────
+/**
+ * Strip all markdown formatting from text, returning plain readable text.
+ * Used by /copy and /save operations.
+ */
+export function stripMarkdown(text) {
+    return text
+        // Code fences — remove fence markers, keep content
+        .replace(/^```[a-z]*\n?/gm, '')
+        .replace(/^```\s*$/gm, '')
+        // Headings — remove # prefix
+        .replace(/^#{1,6}\s+/gm, '')
+        // Bold
+        .replace(/\*\*(.+?)\*\*/g, '$1')
+        // Strikethrough
+        .replace(/~~(.+?)~~/g, '$1')
+        // Italic (asterisk and underscore)
+        .replace(/\*([^*\n]+)\*/g, '$1')
+        .replace(/_([^_\n]+)_/g, '$1')
+        // Inline code
+        .replace(/`([^`]+)`/g, '$1')
+        // Links — keep label, discard URL
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+        // Blockquotes — remove leading >
+        .replace(/^>\s*/gm, '')
+        // Horizontal rules
+        .replace(/^[-*_]{3,}$/gm, '')
+        // Trim trailing whitespace per line
+        .split('\n')
+        .map((l) => l.trimEnd())
+        .join('\n')
+        // Collapse 3+ consecutive blank lines to 2
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+//# sourceMappingURL=markdown-renderer.js.map

package/dist/cli/ink/output-styles.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Output Styles — configurable formatting for TUI messages.
+ *
+ * Styles control how assistant messages, code blocks, and tool calls
+ * are presented in the terminal. Load from .profclaw/style.json or
+ * use one of the built-in named styles.
+ */
+export interface OutputStyle {
+    name: string;
+    /** Prefix prepended to each line of an assistant message, e.g. '│ ' */
+    messagePrefix: string;
+    /** Chalk color name for the message prefix, e.g. 'cyan' or 'gray' */
+    messagePrefixColor: string;
+    /** Whether to draw a top/bottom border around code blocks */
+    codeBlockBorder: boolean;
+    /** Chalk color name for the code language label, e.g. 'yellow' */
+    codeLabelColor: string;
+    /** Icon shown before a tool call name, e.g. '⚙' or '->' */
+    toolIcon: string;
+    /** Chalk color name for tool call output */
+    toolColor: string;
+    /** Reduce whitespace between consecutive messages */
+    compact: boolean;
+}
+export declare const BUILT_IN_STYLES: Record<string, OutputStyle>;
+/**
+ * Load an OutputStyle by name, or from a .profclaw/style.json config file.
+ *
+ * Resolution order:
+ *   1. If `name` matches a built-in style key — use it.
+ *   2. If a style.json file exists — merge it on top of the default style.
+ *      If the file has a `name` field that matches a built-in, use that as
+ *      the base instead of `default`.
+ *   3. Fall back to the `default` built-in style.
+ *
+ * @param name  Optional style name override (e.g. from `--style minimal`).
+ */
+export declare function loadOutputStyle(name?: string): OutputStyle;
+//# sourceMappingURL=output-styles.d.ts.map