rippletide 1.0.0

package/babel.config.json

@@ -0,0 +1,6 @@
+{
+  "presets": [
+    "@babel/preset-react",
+    "@babel/preset-typescript"
+  ]
+}

package/bin/rippletide

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+// Simple CLI dispatcher: `rippletide eval` (or just `rippletide`) runs the evaluator.
+// Other commands can be added later if needed.
+
+const args = process.argv.slice(2);
+const cmd = args[0];
+
+async function main() {
+  if (!cmd || cmd === 'eval') {
+    // Lazy-load compiled Ink app
+    await import('../dist/index.js');
+    return;
+  }
+
+  if (cmd === '--help' || cmd === '-h') {
+    console.log(`
+Rippletide CLI
+
+Usage:
+  rippletide eval        Run the Rippletide evaluation UI
+
+Options:
+  -h, --help             Show this help message
+`);
+    return;
+  }
+
+  console.error(`Unknown command: ${cmd}`);
+  console.log(`Run "rippletide --help" for usage.`);
+  process.exit(1);
+}
+
+main().catch((err) => {
+  console.error('Error running rippletide:', err?.message || err);
+  process.exit(1);
+});

package/dist/App.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const App: React.FC;

package/dist/App.js

@@ -0,0 +1,174 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { Header } from './components/Header.js';
+import { TextInput } from './components/TextInput.js';
+import { SelectMenu } from './components/SelectMenu.js';
+import { Spinner } from './components/Spinner.js';
+import { ProgressBar } from './components/ProgressBar.js';
+import { Summary } from './components/Summary.js';
+import { api } from './api/client.js';
+const knowledgeSources = [
+    { label: 'Local Files (qanda.json)', value: 'files', description: 'Use qanda.json from current directory' },
+    { label: 'Current Repository', value: 'repo', description: 'Scan current git repository', disabled: true },
+    { label: 'Database', value: 'database', description: 'Connect to a database', disabled: true },
+    { label: 'API Endpoint', value: 'api', description: 'Fetch from REST API', disabled: true },
+    { label: 'GitHub Repository', value: 'github', description: 'Import from GitHub repo', disabled: true },
+    { label: 'Skip (No Knowledge)', value: 'skip', description: 'Run tests without knowledge base', disabled: true },
+];
+export const App = () => {
+    const [step, setStep] = useState('agent-endpoint');
+    const [agentEndpoint, setAgentEndpoint] = useState('');
+    const [knowledgeSource, setKnowledgeSource] = useState('');
+    const [knowledgeFound, setKnowledgeFound] = useState(false);
+    const [evaluationProgress, setEvaluationProgress] = useState(0);
+    const [evaluationResult, setEvaluationResult] = useState(null);
+    const [currentQuestion, setCurrentQuestion] = useState('');
+    const [currentLLMResponse, setCurrentLLMResponse] = useState('');
+    const [evaluationLogs, setEvaluationLogs] = useState([]);
+    useEffect(() => {
+        if (step === 'checking-knowledge') {
+            (async () => {
+                try {
+                    const result = await api.checkKnowledge();
+                    setKnowledgeFound(result.found);
+                }
+                catch (error) {
+                    console.error('Error checking knowledge:', error);
+                    setKnowledgeFound(false);
+                }
+                setStep('select-source');
+            })();
+        }
+    }, [step]);
+    useEffect(() => {
+        if (step === 'running-evaluation') {
+            (async () => {
+                try {
+                    const startTime = Date.now();
+                    const logs = [];
+                    setEvaluationProgress(5);
+                    await api.generateApiKey('CLI Evaluation');
+                    setEvaluationProgress(10);
+                    const agent = await api.createAgent(agentEndpoint);
+                    const agentId = agent.id;
+                    setEvaluationProgress(30);
+                    setEvaluationProgress(40);
+                    let testPrompts = [];
+                    if (knowledgeSource === 'files') {
+                        const knowledgeResult = await api.checkKnowledge();
+                        if (knowledgeResult.found && knowledgeResult.path) {
+                            try {
+                                const fs = await import('fs');
+                                const knowledgeData = JSON.parse(fs.readFileSync(knowledgeResult.path, 'utf-8'));
+                                if (Array.isArray(knowledgeData)) {
+                                    testPrompts = knowledgeData.slice(0, 5).map((item) => ({
+                                        question: item.question || item.prompt || item.input || 'Test question',
+                                        answer: item.answer || item.response || item.expectedAnswer
+                                    }));
+                                }
+                            }
+                            catch (error) {
+                                testPrompts = [];
+                            }
+                        }
+                    }
+                    const createdPrompts = await api.addTestPrompts(agentId, testPrompts);
+                    setEvaluationProgress(50);
+                    const evaluationResults = await api.runAllPromptEvaluations(agentId, createdPrompts, agentEndpoint, (current, total, question, llmResponse) => {
+                        const progress = 50 + Math.round((current / total) * 40);
+                        setEvaluationProgress(progress);
+                        if (question) {
+                            setCurrentQuestion(question);
+                        }
+                        if (llmResponse) {
+                            setCurrentLLMResponse(llmResponse);
+                            logs.push({ question: question || '', response: llmResponse });
+                            setEvaluationLogs([...logs]);
+                        }
+                    });
+                    setEvaluationProgress(100);
+                    let passed = 0;
+                    let failed = 0;
+                    evaluationResults.forEach((result) => {
+                        if (result.success) {
+                            passed++;
+                        }
+                        else {
+                            failed++;
+                        }
+                    });
+                    const duration = Math.round((Date.now() - startTime) / 1000);
+                    const durationStr = duration > 60
+                        ? `${Math.floor(duration / 60)}m ${duration % 60}s`
+                        : `${duration}s`;
+                    const result = {
+                        totalTests: createdPrompts.length,
+                        passed,
+                        failed,
+                        duration: durationStr,
+                        evaluationUrl: `http://localhost:5173/eval/${agentId}`,
+                        agentId,
+                    };
+                    setEvaluationResult(result);
+                    setStep('complete');
+                }
+                catch (error) {
+                    console.error('Error running evaluation:', error);
+                    setEvaluationResult({
+                        totalTests: 0,
+                        passed: 0,
+                        failed: 0,
+                        duration: 'Failed',
+                        evaluationUrl: 'http://localhost:5173',
+                    });
+                    setStep('complete');
+                }
+            })();
+        }
+    }, [step, agentEndpoint, knowledgeSource]);
+    const handleAgentEndpointSubmit = (value) => {
+        setAgentEndpoint(value);
+        setStep('checking-knowledge');
+    };
+    const handleSourceSelect = (value) => {
+        setKnowledgeSource(value);
+        setStep('running-evaluation');
+    };
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Header, null),
+        step === 'agent-endpoint' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(TextInput, { label: "Agent endpoint", placeholder: "http://localhost:8000", onSubmit: handleAgentEndpointSubmit }))),
+        step === 'checking-knowledge' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Spinner, { label: "Checking for knowledge base in current folder..." }))),
+        step === 'select-source' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "#eba1b5" }, "Choose your data source:")),
+            knowledgeFound && (React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "white" }, "qanda.json found in current directory"))),
+            React.createElement(SelectMenu, { title: "Data Source", options: knowledgeSources, onSelect: handleSourceSelect }))),
+        step === 'running-evaluation' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 2 },
+                React.createElement(Spinner, { label: "Running evaluation" })),
+            React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+                React.createElement(Box, null,
+                    React.createElement(Box, { width: 12 },
+                        React.createElement(Text, { dimColor: true }, "Endpoint:")),
+                    React.createElement(Text, null, agentEndpoint || 'http://localhost:8000')),
+                React.createElement(Box, null,
+                    React.createElement(Box, { width: 12 },
+                        React.createElement(Text, { dimColor: true }, "Data Source:")),
+                    React.createElement(Text, null, knowledgeSources.find(s => s.value === knowledgeSource)?.label || 'None'))),
+            React.createElement(ProgressBar, { progress: evaluationProgress }),
+            currentQuestion && (React.createElement(Box, { flexDirection: "column", marginTop: 1, marginBottom: 1 },
+                React.createElement(Box, null,
+                    React.createElement(Text, { bold: true, color: "#eba1b5" }, "Current Question:")),
+                React.createElement(Box, { paddingLeft: 2 },
+                    React.createElement(Text, { color: "white" }, currentQuestion)))),
+            currentLLMResponse && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+                React.createElement(Box, null,
+                    React.createElement(Text, { bold: true, color: "green" }, "LLM Response:")),
+                React.createElement(Box, { paddingLeft: 2 },
+                    React.createElement(Text, null, currentLLMResponse.length > 200 ? currentLLMResponse.substring(0, 200) + '...' : currentLLMResponse)))))),
+        step === 'complete' && evaluationResult && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Summary, { totalTests: evaluationResult.totalTests, passed: evaluationResult.passed, failed: evaluationResult.failed, duration: evaluationResult.duration, evaluationUrl: evaluationResult.evaluationUrl })))));
+};

package/dist/api/client.d.ts

@@ -0,0 +1,58 @@
+export interface EvaluationConfig {
+    agentEndpoint: string;
+    knowledgeSource?: string;
+}
+export interface EvaluationResult {
+    totalTests: number;
+    passed: number;
+    failed: number;
+    duration: string;
+    evaluationUrl: string;
+    agentId?: string;
+}
+export interface HallucinationCheckResult {
+    question: string;
+    llmResponse: string;
+    summary: string;
+    facts: string[];
+    status: 'passed' | 'failed' | 'ambiguous';
+    hallucinationLabel: string;
+    hallucinationFindings: any[];
+}
+export interface PromptEvaluationResult {
+    success: boolean;
+    question: string;
+    llmResponse?: string;
+    hallucinationResult?: HallucinationCheckResult;
+    error?: any;
+}
+export declare const api: {
+    generateApiKey(name?: string): Promise<any>;
+    healthCheck(): Promise<any>;
+    checkKnowledge(folderPath?: string): Promise<{
+        found: boolean;
+        path: string;
+    } | {
+        found: boolean;
+        path?: undefined;
+    }>;
+    createAgent(publicUrl: string): Promise<any>;
+    importKnowledge(agentId: string, knowledgeData: any): Promise<any>;
+    addTestPrompts(agentId: string, prompts?: string[] | Array<{
+        question: string;
+        answer?: string;
+    }>): Promise<any>;
+    checkHallucination(agentId: string, question: string, llmResponse: string, expectedAnswer?: string): Promise<HallucinationCheckResult>;
+    callLLMEndpoint(agentEndpoint: string, question: string): Promise<string>;
+    runPromptEvaluation(agentId: string, promptId: number, promptText: string, agentEndpoint: string, expectedAnswer?: string, onLLMResponse?: (response: string) => void): Promise<PromptEvaluationResult>;
+    runAllPromptEvaluations(agentId: string, prompts: any[], agentEndpoint: string, onProgress?: (current: number, total: number, question?: string, llmResponse?: string) => void): Promise<PromptEvaluationResult[]>;
+    getTestResults(agentId: string): Promise<any>;
+    runEvaluation(config: EvaluationConfig, onProgress?: (progress: number) => void): Promise<{
+        totalTests: any;
+        passed: number;
+        failed: number;
+        duration: string;
+        evaluationUrl: string;
+        agentId: any;
+    }>;
+};

package/dist/api/client.js

@@ -0,0 +1,316 @@
+import axios from 'axios';
+import * as fs from 'fs';
+import * as path from 'path';
+import { logger } from '../utils/logger.js';
+const BASE_URL = 'http://localhost:3001';
+let API_KEY = null;
+const client = axios.create({
+    baseURL: BASE_URL,
+    headers: {
+        'Content-Type': 'application/json',
+    },
+});
+client.interceptors.request.use((config) => {
+    if (API_KEY) {
+        config.headers['x-api-key'] = API_KEY;
+    }
+    return config;
+});
+export const api = {
+    async generateApiKey(name) {
+        try {
+            const response = await client.post('/api/api-keys/generate-cli', {
+                name: name || 'CLI Evaluation Key'
+            });
+            API_KEY = response.data.apiKey;
+            logger.info('API key generated successfully');
+            logger.debug('API Key:', API_KEY?.substring(0, 12) + '...');
+            return response.data;
+        }
+        catch (error) {
+            logger.error('Error generating API key:', error);
+            throw error;
+        }
+    },
+    async healthCheck() {
+        const response = await client.get('/health');
+        return response.data;
+    },
+    async checkKnowledge(folderPath = '.') {
+        try {
+            const knowledgeFiles = [
+                'knowledge-base/qanda.json',
+                'qanda.json',
+                'knowledge.json',
+            ];
+            for (const file of knowledgeFiles) {
+                const filePath = path.join(folderPath, file);
+                if (fs.existsSync(filePath)) {
+                    return { found: true, path: filePath };
+                }
+            }
+            return { found: false };
+        }
+        catch (error) {
+            logger.error('Error checking knowledge:', error);
+            return { found: false };
+        }
+    },
+    async createAgent(publicUrl) {
+        try {
+            const response = await client.post('/api/agents', {
+                name: `Agent Eval ${Date.now()}`,
+                seed: Math.floor(Math.random() * 1000),
+                numNodes: 100,
+                publicUrl: publicUrl,
+                label: 'eval',
+            });
+            return response.data;
+        }
+        catch (error) {
+            logger.error('Error creating agent:', error);
+            throw error;
+        }
+    },
+    async importKnowledge(agentId, knowledgeData) {
+        try {
+            const response = await client.post(`/api/agents/${agentId}/knowledge/import`, {
+                data: knowledgeData,
+            });
+            return response.data;
+        }
+        catch (error) {
+            logger.error('Error importing knowledge:', error);
+            return null;
+        }
+    },
+    async addTestPrompts(agentId, prompts) {
+        try {
+            const defaultPrompts = [
+                'What can you help me with?',
+                'Tell me about your capabilities',
+                'How do I get started?',
+                'What features do you support?',
+                'Can you explain your main functionality?',
+            ];
+            let promptsArray;
+            if (!prompts || prompts.length === 0) {
+                promptsArray = defaultPrompts.map(p => ({ prompt: p, expectedAnswer: null }));
+            }
+            else if (typeof prompts[0] === 'string') {
+                promptsArray = prompts.map(p => ({ prompt: p, expectedAnswer: null }));
+            }
+            else {
+                promptsArray = prompts.map(p => ({
+                    prompt: p.question,
+                    expectedAnswer: p.answer || null,
+                }));
+            }
+            const response = await client.post(`/api/agents/${agentId}/test-prompts`, {
+                prompts: promptsArray,
+            });
+            return response.data;
+        }
+        catch (error) {
+            logger.error('Error adding test prompts:', error);
+            if (error.response) {
+                logger.debug('Response data:', error.response.data);
+                logger.debug('Response status:', error.response.status);
+            }
+            throw error;
+        }
+    },
+    async checkHallucination(agentId, question, llmResponse, expectedAnswer) {
+        const response = await client.post(`/api/agents/${agentId}/hallucination`, {
+            question,
+            llmResponse,
+            expectedAnswer
+        });
+        return response.data;
+    },
+    async callLLMEndpoint(agentEndpoint, question) {
+        try {
+            const llmClient = axios.create({
+                timeout: 60000,
+            });
+            const response = await llmClient.post(agentEndpoint, {
+                message: question,
+                query: question,
+                question: question,
+                prompt: question,
+            });
+            let llmResponse = '';
+            if (typeof response.data === 'string') {
+                llmResponse = response.data;
+            }
+            else if (response.data.response) {
+                llmResponse = response.data.response;
+            }
+            else if (response.data.message) {
+                llmResponse = response.data.message;
+            }
+            else if (response.data.answer) {
+                llmResponse = response.data.answer;
+            }
+            else if (response.data.text) {
+                llmResponse = response.data.text;
+            }
+            else {
+                llmResponse = JSON.stringify(response.data);
+            }
+            return llmResponse;
+        }
+        catch (error) {
+            logger.error('Error calling LLM endpoint:', error?.message || error);
+            throw new Error(`Failed to call LLM endpoint: ${error?.message || 'Unknown error'}`);
+        }
+    },
+    async runPromptEvaluation(agentId, promptId, promptText, agentEndpoint, expectedAnswer, onLLMResponse) {
+        try {
+            logger.info(`Calling LLM for question: ${promptText}`);
+            const llmResponse = await api.callLLMEndpoint(agentEndpoint, promptText);
+            if (onLLMResponse) {
+                onLLMResponse(llmResponse);
+            }
+            logger.info(`LLM Response: ${llmResponse.substring(0, 100)}...`);
+            const hallucinationResult = await api.checkHallucination(agentId, promptText, llmResponse, expectedAnswer);
+            const status = hallucinationResult.status === 'passed' ? 'passed' : 'failed';
+            await client.post(`/api/agents/${agentId}/test-results/${promptId}`, {
+                status,
+                response: llmResponse,
+                hallucinationLabel: hallucinationResult.hallucinationLabel,
+                hallucinationFindings: hallucinationResult.hallucinationFindings
+            });
+            return {
+                success: status === 'passed',
+                question: promptText,
+                llmResponse,
+                hallucinationResult
+            };
+        }
+        catch (error) {
+            logger.debug(`Error running prompt ${promptId}:`, error?.response?.data || error.message);
+            try {
+                await client.post(`/api/agents/${agentId}/test-results/${promptId}`, {
+                    status: 'failed'
+                });
+            }
+            catch (e) {
+                logger.debug('Failed to store failed result:', e);
+            }
+            return {
+                success: false,
+                question: promptText,
+                error
+            };
+        }
+    },
+    async runAllPromptEvaluations(agentId, prompts, agentEndpoint, onProgress) {
+        const results = [];
+        try {
+            for (let i = 0; i < prompts.length; i++) {
+                const prompt = prompts[i];
+                if (onProgress) {
+                    onProgress(i + 1, prompts.length, prompt.prompt);
+                }
+                const result = await api.runPromptEvaluation(agentId, prompt.id, prompt.prompt, agentEndpoint, prompt.expectedAnswer, (llmResponse) => {
+                    if (onProgress) {
+                        onProgress(i + 1, prompts.length, prompt.prompt, llmResponse);
+                    }
+                });
+                results.push(result);
+                await new Promise(resolve => setTimeout(resolve, 500));
+            }
+        }
+        catch (error) {
+            logger.error('Error running evaluations:', error);
+        }
+        return results;
+    },
+    async getTestResults(agentId) {
+        try {
+            const response = await client.get(`/api/agents/${agentId}/test-results`);
+            return response.data;
+        }
+        catch (error) {
+            console.error('Error getting test results:', error);
+            return [];
+        }
+    },
+    async runEvaluation(config, onProgress) {
+        try {
+            const startTime = Date.now();
+            if (onProgress)
+                onProgress(10);
+            const agent = await api.createAgent(config.agentEndpoint);
+            const agentId = agent.id;
+            if (onProgress)
+                onProgress(30);
+            if (config.knowledgeSource === 'files') {
+                const knowledgeResult = await api.checkKnowledge();
+                if (knowledgeResult.found && knowledgeResult.path) {
+                    const knowledgeData = JSON.parse(fs.readFileSync(knowledgeResult.path, 'utf-8'));
+                    await api.importKnowledge(agentId, knowledgeData);
+                }
+            }
+            if (onProgress)
+                onProgress(40);
+            let testPrompts = [];
+            if (config.knowledgeSource === 'files') {
+                const knowledgeResult = await api.checkKnowledge();
+                if (knowledgeResult.found && knowledgeResult.path) {
+                    try {
+                        const knowledgeData = JSON.parse(fs.readFileSync(knowledgeResult.path, 'utf-8'));
+                        if (Array.isArray(knowledgeData)) {
+                            testPrompts = knowledgeData.slice(0, 5).map((item) => item.question || item.prompt || item.input || 'Test question');
+                        }
+                        else if (knowledgeData.questions) {
+                            testPrompts = knowledgeData.questions.slice(0, 5);
+                        }
+                    }
+                    catch (error) {
+                        logger.error('Error loading prompts from knowledge:', error);
+                    }
+                }
+            }
+            const createdPrompts = await api.addTestPrompts(agentId, testPrompts);
+            const promptIds = createdPrompts.map((p) => p.id);
+            const promptCount = promptIds.length;
+            if (onProgress)
+                onProgress(50);
+            const evaluationResults = await api.runAllPromptEvaluations(agentId, createdPrompts, config.agentEndpoint, (current, total) => {
+                const progress = 50 + Math.round((current / total) * 40);
+                if (onProgress)
+                    onProgress(progress);
+            });
+            if (onProgress)
+                onProgress(100);
+            let passed = 0;
+            let failed = 0;
+            evaluationResults.forEach((result) => {
+                if (result.success) {
+                    passed++;
+                }
+                else {
+                    failed++;
+                }
+            });
+            const duration = Math.round((Date.now() - startTime) / 1000);
+            const durationStr = duration > 60
+                ? `${Math.floor(duration / 60)}m ${duration % 60}s`
+                : `${duration}s`;
+            return {
+                totalTests: promptCount || 5,
+                passed,
+                failed,
+                duration: durationStr,
+                evaluationUrl: `http://localhost:5173/eval/${agentId}`,
+                agentId,
+            };
+        }
+        catch (error) {
+            logger.error('Evaluation error:', error);
+            throw error;
+        }
+    },
+};

package/dist/components/Header.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const Header: React.FC;

package/dist/components/Header.js

@@ -0,0 +1,7 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+export const Header = () => {
+    return (React.createElement(Box, { flexDirection: "column", marginBottom: 2 },
+        React.createElement(Text, { bold: true, color: "#eba1b5" }, "Rippletide Evaluation"),
+        React.createElement(Text, { color: "gray" }, "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501")));
+};

package/dist/components/InputPrompt.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface InputPromptProps {
+    label: string;
+    onSubmit: (value: string) => void;
+    placeholder?: string;
+}
+export declare const InputPrompt: React.FC<InputPromptProps>;
+export {};

package/dist/components/InputPrompt.js

@@ -0,0 +1,12 @@
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+export const InputPrompt = ({ label, onSubmit, placeholder }) => {
+    const [value, setValue] = useState('');
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "cyan" }, label)),
+        React.createElement(Box, null,
+            React.createElement(Text, { color: "gray" }, placeholder || 'Type your answer...')),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "Press Enter to submit"))));
+};

package/dist/components/ProgressBar.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface ProgressBarProps {
+    progress: number;
+    label?: string;
+}
+export declare const ProgressBar: React.FC<ProgressBarProps>;
+export {};

package/dist/components/ProgressBar.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+export const ProgressBar = ({ progress, label }) => {
+    const width = 40;
+    const filled = Math.round((progress / 100) * width);
+    const empty = width - filled;
+    return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+        label && (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { dimColor: true }, label))),
+        React.createElement(Box, null,
+            React.createElement(Text, { color: "#eba1b5" }, '='.repeat(filled)),
+            React.createElement(Text, { color: "gray" }, '-'.repeat(empty)),
+            React.createElement(Text, null, " "),
+            React.createElement(Text, { color: "#eba1b5" },
+                progress.toFixed(0),
+                "%"))));
+};

package/dist/components/SelectMenu.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+interface SelectOption {
+    label: string;
+    value: string;
+    description?: string;
+    disabled?: boolean;
+}
+interface SelectMenuProps {
+    title: string;
+    options: SelectOption[];
+    onSelect: (value: string) => void;
+}
+export declare const SelectMenu: React.FC<SelectMenuProps>;
+export {};