profclaw 0.0.1-beta.3 → 2.3.0

package/dist/cli/ink/components/SuggestionBar.d.ts

@@ -0,0 +1,15 @@
+/**
+ * SuggestionBar
+ *
+ * Renders 2-3 dimmed follow-up prompt suggestions below the last assistant
+ * response. The user can press 1, 2, or 3 to select a suggestion.
+ */
+import React from 'react';
+import type { Suggestion } from '../../../agents/prompt-suggestions.js';
+export interface SuggestionBarProps {
+    suggestions: Suggestion[];
+    isActive: boolean;
+    onSelect: (text: string) => void;
+}
+export declare const SuggestionBar: React.FC<SuggestionBarProps>;
+//# sourceMappingURL=SuggestionBar.d.ts.map

package/dist/cli/ink/components/SuggestionBar.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+// ── Category colors ───────────────────────────────────────────────────────────
+function categoryColor(category) {
+    switch (category) {
+        case 'action': return 'yellow';
+        case 'deeper': return 'cyan';
+        case 'related': return 'magenta';
+        case 'follow-up':
+        default: return 'white';
+    }
+}
+// ── Component ─────────────────────────────────────────────────────────────────
+export const SuggestionBar = ({ suggestions, isActive, onSelect, }) => {
+    useInput((input) => {
+        const digit = parseInt(input, 10);
+        if (!isNaN(digit) && digit >= 1 && digit <= suggestions.length) {
+            const suggestion = suggestions[digit - 1];
+            if (suggestion) {
+                onSelect(suggestion.text);
+            }
+        }
+    }, { isActive });
+    if (suggestions.length === 0)
+        return null;
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 0, marginTop: 0, children: [_jsx(Text, { dimColor: true, children: "  \u254C suggestions \u254C" }), suggestions.map((s, i) => (_jsxs(Box, { flexDirection: "row", gap: 1, children: [_jsx(Text, { dimColor: true, bold: true, children: `  ${i + 1}.` }), _jsx(Text, { dimColor: true, color: categoryColor(s.category), children: s.text })] }, i))), _jsxs(Text, { dimColor: true, children: ["     press 1\u2013", suggestions.length, " to use"] })] }));
+};
+//# sourceMappingURL=SuggestionBar.js.map

package/dist/cli/ink/components/SystemHealth.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+export interface SystemMetrics {
+    version?: string;
+    uptime?: number;
+    mode?: string;
+    healthy?: boolean;
+    memoryUsedMb?: number;
+    memoryTotalMb?: number;
+    cpuPercent?: number;
+    queueBackend?: 'redis' | 'memory';
+    degraded?: boolean;
+}
+interface SystemHealthProps {
+    metrics: SystemMetrics;
+    loading?: boolean;
+    error?: string;
+}
+export declare function SystemHealth({ metrics, loading, error }: SystemHealthProps): React.ReactElement;
+export {};
+//# sourceMappingURL=SystemHealth.d.ts.map

package/dist/cli/ink/components/SystemHealth.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+function formatUptime(seconds) {
+    const d = Math.floor(seconds / 86400);
+    const h = Math.floor((seconds % 86400) / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    const parts = [];
+    if (d > 0)
+        parts.push(`${d}d`);
+    if (h > 0)
+        parts.push(`${h}h`);
+    parts.push(`${m}m`);
+    return parts.join(' ');
+}
+function HealthRow({ label, value, color = 'white', dimColor = false }) {
+    return (_jsxs(Box, { gap: 0, children: [_jsx(Text, { dimColor: true, children: '  ' + label.padEnd(16) }), _jsx(Text, { color: dimColor ? undefined : color, dimColor: dimColor, children: value })] }));
+}
+export function SystemHealth({ metrics, loading, error }) {
+    if (loading) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: "white", children: "System Health" }), _jsx(Text, { dimColor: true, children: "  Loading..." })] }));
+    }
+    if (error) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: "white", children: "System Health" }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "red", children: "  Unable to connect to profClaw server." }), _jsx(Text, { dimColor: true, children: "  Is it running? Try: profclaw serve" })] })] }));
+    }
+    const healthColor = metrics.healthy ? 'green' : 'red';
+    const healthLabel = metrics.healthy
+        ? '● healthy'
+        : metrics.degraded
+            ? '● degraded'
+            : '● unhealthy';
+    const memUsage = metrics.memoryUsedMb != null && metrics.memoryTotalMb != null
+        ? `${metrics.memoryUsedMb}MB / ${metrics.memoryTotalMb}MB`
+        : undefined;
+    const cpuColor = (metrics.cpuPercent ?? 0) > 80 ? 'red'
+        : (metrics.cpuPercent ?? 0) > 50 ? 'yellow'
+            : 'green';
+    return (_jsxs(Box, { flexDirection: "column", gap: 0, children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, color: "white", children: "System Health" }), metrics.degraded && (_jsx(Text, { color: "yellow", bold: true, children: "\u26A0 DEGRADED" }))] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [metrics.version && (_jsx(HealthRow, { label: "Version", value: metrics.version, dimColor: true })), _jsx(HealthRow, { label: "Status", value: healthLabel, color: healthColor }), _jsx(HealthRow, { label: "Mode", value: metrics.mode ?? 'mini', color: "cyan" }), metrics.uptime != null && (_jsx(HealthRow, { label: "Uptime", value: formatUptime(metrics.uptime), dimColor: true })), memUsage && (_jsx(HealthRow, { label: "Memory", value: memUsage, dimColor: true })), metrics.cpuPercent != null && (_jsx(HealthRow, { label: "CPU", value: `${metrics.cpuPercent.toFixed(1)}%`, color: cpuColor })), _jsx(HealthRow, { label: "Queue backend", value: metrics.queueBackend ?? 'memory', color: metrics.queueBackend === 'redis' ? 'green' : 'yellow' })] })] }));
+}
+//# sourceMappingURL=SystemHealth.js.map

package/dist/cli/ink/components/TaskList.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+export type TaskStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+export interface Task {
+    id: string;
+    title: string;
+    status: TaskStatus;
+    createdAt: string;
+    durationMs?: number;
+}
+interface TaskListProps {
+    tasks: Task[];
+    loading?: boolean;
+    error?: string;
+}
+export declare function TaskList({ tasks, loading, error }: TaskListProps): React.ReactElement;
+export {};
+//# sourceMappingURL=TaskList.d.ts.map

package/dist/cli/ink/components/TaskList.js

@@ -0,0 +1,59 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+function statusColor(status) {
+    const map = {
+        pending: 'gray',
+        running: 'yellow',
+        completed: 'green',
+        failed: 'red',
+        cancelled: 'gray',
+    };
+    return map[status];
+}
+function statusLabel(status) {
+    const map = {
+        pending: 'pending',
+        running: 'running',
+        completed: 'done',
+        failed: 'failed',
+        cancelled: 'cancel',
+    };
+    return map[status];
+}
+function formatDuration(ms) {
+    if (ms == null)
+        return '-';
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    return `${Math.floor(ms / 60000)}m${Math.floor((ms % 60000) / 1000)}s`;
+}
+function formatRelative(iso) {
+    const diff = Date.now() - new Date(iso).getTime();
+    const s = Math.floor(diff / 1000);
+    if (s < 60)
+        return `${s}s ago`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ago`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h ago`;
+    return `${Math.floor(h / 24)}d ago`;
+}
+function truncateId(id) {
+    if (!id)
+        return '—';
+    return id.length > 8 ? id.slice(0, 8) : id;
+}
+function truncateTitle(title, max = 30) {
+    if (!title)
+        return '(untitled)';
+    return title.length > max ? title.slice(0, max - 1) + '…' : title;
+}
+export function TaskList({ tasks, loading, error }) {
+    const sorted = [...tasks].sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    return (_jsxs(Box, { flexDirection: "column", gap: 0, children: [_jsx(Text, { bold: true, color: "white", children: "Recent Tasks" }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [loading && _jsx(Text, { dimColor: true, children: "  Loading tasks..." }), error && _jsxs(Text, { color: "red", children: ["  ", error] }), !loading && !error && sorted.length === 0 && (_jsx(Text, { dimColor: true, children: "  No tasks yet" })), !loading && !error && sorted.length > 0 && (_jsxs(_Fragment, { children: [_jsxs(Box, { gap: 2, marginBottom: 1, children: [_jsx(Text, { dimColor: true, bold: true, children: '  ID'.padEnd(10) }), _jsx(Text, { dimColor: true, bold: true, children: 'Title'.padEnd(32) }), _jsx(Text, { dimColor: true, bold: true, children: 'Status'.padEnd(10) }), _jsx(Text, { dimColor: true, bold: true, children: 'Created'.padEnd(10) }), _jsx(Text, { dimColor: true, bold: true, children: "Duration" })] }), sorted.map((t) => (_jsxs(Box, { gap: 2, children: [_jsx(Text, { dimColor: true, children: '  ' + truncateId(t.id).padEnd(8) }), _jsx(Text, { children: truncateTitle(t.title).padEnd(31) }), _jsx(Box, { width: 10, children: _jsx(Text, { color: statusColor(t.status), children: statusLabel(t.status).padEnd(8) }) }), _jsx(Text, { dimColor: true, children: formatRelative(t.createdAt).padEnd(10) }), _jsx(Text, { dimColor: true, children: formatDuration(t.durationMs) })] }, t.id)))] }))] })] }));
+}
+//# sourceMappingURL=TaskList.js.map

package/dist/cli/ink/components/ToolCall.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ToolCall Component
+ *
+ * Renders a single tool call with name, args preview, result, and duration.
+ * Color-coded: green for success, red for error, yellow for timeout/pending.
+ */
+import React from 'react';
+export type ToolCallStatus = 'pending' | 'running' | 'success' | 'error' | 'timeout';
+export interface ToolCallProps {
+    name: string;
+    args: Record<string, unknown>;
+    result?: unknown;
+    status: ToolCallStatus;
+    durationMs?: number;
+}
+export declare const ToolCall: React.FC<ToolCallProps>;
+//# sourceMappingURL=ToolCall.d.ts.map

package/dist/cli/ink/components/ToolCall.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+function argsPreview(args, maxLen = 60) {
+    const entries = Object.entries(args);
+    if (entries.length === 0)
+        return '{}';
+    const [, firstVal] = entries[0];
+    const preview = String(firstVal ?? '');
+    return preview.length > maxLen ? preview.slice(0, maxLen - 1) + '…' : preview;
+}
+function resultPreview(result, maxLen = 80) {
+    if (result === undefined || result === null)
+        return '';
+    const str = typeof result === 'string' ? result : JSON.stringify(result);
+    return str.length > maxLen ? str.slice(0, maxLen - 1) + '…' : str;
+}
+const STATUS_COLOR = {
+    pending: 'gray',
+    running: 'yellow',
+    success: 'green',
+    error: 'red',
+    timeout: 'yellow',
+};
+const STATUS_ICON = {
+    pending: '○',
+    running: '◎',
+    success: '✓',
+    error: '✗',
+    timeout: '⏱',
+};
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+export const ToolCall = ({ name, args, result, status, durationMs, }) => {
+    const color = STATUS_COLOR[status];
+    const icon = STATUS_ICON[status];
+    const preview = argsPreview(args);
+    const res = result !== undefined ? resultPreview(result) : undefined;
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, marginY: 0, children: [_jsxs(Box, { flexDirection: "row", gap: 1, children: [_jsx(Text, { color: color, children: icon }), _jsx(Text, { color: "yellow", bold: true, children: name }), preview.length > 0 && _jsx(Text, { dimColor: true, children: preview }), durationMs !== undefined && (_jsxs(Text, { dimColor: true, children: ["(", formatDuration(durationMs), ")"] }))] }), res !== undefined && res.length > 0 && (_jsx(Box, { paddingLeft: 3, children: _jsx(Text, { color: status === 'error' ? 'red' : 'gray', children: res }) }))] }));
+};
+//# sourceMappingURL=ToolCall.js.map

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

@@ -0,0 +1,23 @@
+/**
+ * Ink TUI — Barrel exports
+ *
+ * All public components and types for the Ink-based TUI layer.
+ */
+export { App } from './App.js';
+export { ChatApp } from './ChatApp.js';
+export type { ChatAppProps, PendingPermission, PickerOption } from './ChatApp.js';
+export { AgentStatus } from './components/AgentStatus.js';
+export type { AgentStatusProps, AgentStatusState } from './components/AgentStatus.js';
+export { CostBar } from './components/CostBar.js';
+export type { CostBarProps } from './components/CostBar.js';
+export { PermissionPrompt } from './components/PermissionPrompt.js';
+export type { PermissionPromptProps, PermissionDecision, PermissionLevel, } from './components/PermissionPrompt.js';
+export { PlanView } from './components/PlanView.js';
+export type { PlanViewProps, PlanStep, PlanStepStatus } from './components/PlanView.js';
+export { SessionHeader } from './components/SessionHeader.js';
+export type { SessionHeaderProps } from './components/SessionHeader.js';
+export { StreamingMessage } from './components/StreamingMessage.js';
+export type { StreamingMessageProps } from './components/StreamingMessage.js';
+export { ToolCall } from './components/ToolCall.js';
+export type { ToolCallProps, ToolCallStatus } from './components/ToolCall.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/ink/index.js

@@ -0,0 +1,15 @@
+/**
+ * Ink TUI — Barrel exports
+ *
+ * All public components and types for the Ink-based TUI layer.
+ */
+export { App } from './App.js';
+export { ChatApp } from './ChatApp.js';
+export { AgentStatus } from './components/AgentStatus.js';
+export { CostBar } from './components/CostBar.js';
+export { PermissionPrompt } from './components/PermissionPrompt.js';
+export { PlanView } from './components/PlanView.js';
+export { SessionHeader } from './components/SessionHeader.js';
+export { StreamingMessage } from './components/StreamingMessage.js';
+export { ToolCall } from './components/ToolCall.js';
+//# sourceMappingURL=index.js.map

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