profclaw 2.0.0 → 2.3.0

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

package/dist/cli/ink/output-styles.js

@@ -0,0 +1,119 @@
+/**
+ * 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.
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+// ── Built-in styles ────────────────────────────────────────────────────────────
+export const BUILT_IN_STYLES = {
+    /** Full-featured default style with color, borders, and icons */
+    default: {
+        name: 'default',
+        messagePrefix: '  ',
+        messagePrefixColor: 'cyan',
+        codeBlockBorder: true,
+        codeLabelColor: 'yellow',
+        toolIcon: '⚙',
+        toolColor: 'cyan',
+        compact: false,
+    },
+    /** Minimal style: no prefix, reduced whitespace */
+    minimal: {
+        name: 'minimal',
+        messagePrefix: '',
+        messagePrefixColor: 'gray',
+        codeBlockBorder: false,
+        codeLabelColor: 'gray',
+        toolIcon: '->',
+        toolColor: 'gray',
+        compact: true,
+    },
+    /** Bordered style: sidebar line on every message, bordered code blocks */
+    bordered: {
+        name: 'bordered',
+        messagePrefix: '│ ',
+        messagePrefixColor: 'cyan',
+        codeBlockBorder: true,
+        codeLabelColor: 'cyan',
+        toolIcon: '⚙',
+        toolColor: 'cyan',
+        compact: false,
+    },
+    /**
+     * Plain style: no decoration, suitable for piping output to other tools.
+     * Disables borders, icons, and color prefixes.
+     */
+    plain: {
+        name: 'plain',
+        messagePrefix: '',
+        messagePrefixColor: 'white',
+        codeBlockBorder: false,
+        codeLabelColor: 'white',
+        toolIcon: '[tool]',
+        toolColor: 'white',
+        compact: true,
+    },
+};
+// ── Loader ─────────────────────────────────────────────────────────────────────
+/**
+ * Resolve the style config file location. Checks (in order):
+ *   1. .profclaw/style.json in the current working directory
+ *   2. ~/.profclaw/style.json in the user home directory
+ */
+function findStyleConfigPath() {
+    const candidates = [
+        join(process.cwd(), '.profclaw', 'style.json'),
+        join(homedir(), '.profclaw', 'style.json'),
+    ];
+    for (const p of candidates) {
+        if (existsSync(p))
+            return p;
+    }
+    return null;
+}
+/**
+ * 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 function loadOutputStyle(name) {
+    // Direct named style lookup
+    if (name !== undefined && name in BUILT_IN_STYLES) {
+        return BUILT_IN_STYLES[name];
+    }
+    // Try loading from config file
+    const configPath = findStyleConfigPath();
+    if (configPath !== null) {
+        try {
+            const raw = readFileSync(configPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            // Determine which built-in to use as the base
+            const baseName = parsed.name ?? name ?? 'default';
+            const base = BUILT_IN_STYLES[baseName] ?? BUILT_IN_STYLES['default'];
+            // Merge file overrides on top of the base, then assign the final name
+            const merged = {
+                ...base,
+                ...parsed,
+                name: baseName,
+            };
+            return merged;
+        }
+        catch {
+            // Silently fall through to built-in default on parse errors
+        }
+    }
+    // Final fallback: named built-in or default
+    return BUILT_IN_STYLES[name ?? 'default'] ?? BUILT_IN_STYLES['default'];
+}
+//# sourceMappingURL=output-styles.js.map

package/dist/cli/interactive/auto-serve.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Auto-Serve
+ *
+ * Automatically starts the profClaw server if it's not running.
+ * Inspired by OpenClaw's pattern where the CLI "just works" -
+ * you type `openclaw` and it handles server lifecycle.
+ *
+ * @package profclaw-interactive (future standalone)
+ */
+/**
+ * Check if the profClaw server is reachable.
+ */
+export declare function checkServer(baseUrl: string): Promise<boolean>;
+/**
+ * Start the profClaw server as a background child process.
+ * Returns when the server is healthy or times out.
+ */
+export declare function autoStartServer(options: {
+    port?: number;
+    baseUrl: string;
+    silent?: boolean;
+}): Promise<{
+    success: boolean;
+    pid?: number;
+    error?: string;
+}>;
+/**
+ * Ensure the server is running. Auto-starts if needed.
+ * This is the main entry point for the "just works" pattern.
+ */
+export declare function ensureServer(baseUrl: string, options?: {
+    autoStart?: boolean;
+    silent?: boolean;
+}): Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+//# sourceMappingURL=auto-serve.d.ts.map