erosolar-cli 1.0.1

package/dist/tools/fileTools.js

@@ -0,0 +1,232 @@
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, mkdirSync } from 'node:fs';
+import { join, dirname, relative } from 'node:path';
+import { buildDiffSegments, formatDiffLines } from './diffUtils.js';
+export function createFileTools(workingDir) {
+    return [
+        {
+            name: 'read_file',
+            description: 'Read the contents of a file at the specified path',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'The file path (relative to working directory or absolute)',
+                    },
+                },
+                required: ['path'],
+            },
+            handler: async (args) => {
+                const filePath = resolveFilePath(workingDir, args.path);
+                if (!existsSync(filePath)) {
+                    return `Error: File not found: ${filePath}`;
+                }
+                try {
+                    const content = readFileSync(filePath, 'utf-8');
+                    return `File: ${filePath}\n\n${content}`;
+                }
+                catch (error) {
+                    return `Error reading file: ${error instanceof Error ? error.message : String(error)}`;
+                }
+            },
+        },
+        {
+            name: 'write_file',
+            description: 'Write content to a file at the specified path (creates directories if needed)',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'The file path (relative to working directory or absolute)',
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'The content to write to the file',
+                    },
+                },
+                required: ['path', 'content'],
+            },
+            handler: async (args) => {
+                const filePath = resolveFilePath(workingDir, args.path);
+                try {
+                    const dir = dirname(filePath);
+                    if (!existsSync(dir)) {
+                        mkdirSync(dir, { recursive: true });
+                    }
+                    const nextContent = typeof args.content === 'string' ? args.content : '';
+                    const filePreviouslyExisted = existsSync(filePath);
+                    const previousContent = filePreviouslyExisted ? readFileSync(filePath, 'utf-8') : '';
+                    const diffSegments = buildDiffSegments(previousContent, nextContent);
+                    writeFileSync(filePath, nextContent, 'utf-8');
+                    return buildWriteSummary(filePath, diffSegments, workingDir, filePreviouslyExisted);
+                }
+                catch (error) {
+                    return `Error writing file: ${error instanceof Error ? error.message : String(error)}`;
+                }
+            },
+        },
+        {
+            name: 'list_files',
+            description: 'List files and directories at the specified path',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'The directory path (defaults to current working directory)',
+                    },
+                    recursive: {
+                        type: 'boolean',
+                        description: 'Whether to list files recursively',
+                    },
+                },
+            },
+            handler: async (args) => {
+                const dirPath = args.path ? resolveFilePath(workingDir, args.path) : workingDir;
+                const recursive = args.recursive === true;
+                if (!existsSync(dirPath)) {
+                    return `Error: Directory not found: ${dirPath}`;
+                }
+                try {
+                    const files = listFilesRecursive(dirPath, recursive ? 5 : 1, workingDir);
+                    return `Directory: ${dirPath}\n\n${files.join('\n')}`;
+                }
+                catch (error) {
+                    return `Error listing files: ${error instanceof Error ? error.message : String(error)}`;
+                }
+            },
+        },
+        {
+            name: 'search_files',
+            description: 'Search for files matching a pattern (supports glob patterns)',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: {
+                        type: 'string',
+                        description: 'The search pattern (e.g., "*.ts", "src/**/*.js")',
+                    },
+                    path: {
+                        type: 'string',
+                        description: 'The directory to search in (defaults to current working directory)',
+                    },
+                },
+                required: ['pattern'],
+            },
+            handler: async (args) => {
+                const searchPath = args.path ? resolveFilePath(workingDir, args.path) : workingDir;
+                const pattern = args.pattern;
+                try {
+                    const results = searchFilesGlob(searchPath, pattern);
+                    if (results.length === 0) {
+                        return `No files found matching pattern: ${pattern}`;
+                    }
+                    return `Found ${results.length} files:\n\n${results.map((f) => relative(workingDir, f)).join('\n')}`;
+                }
+                catch (error) {
+                    return `Error searching files: ${error instanceof Error ? error.message : String(error)}`;
+                }
+            },
+        },
+    ];
+}
+function resolveFilePath(workingDir, path) {
+    return path.startsWith('/') ? path : join(workingDir, path);
+}
+function listFilesRecursive(dir, maxDepth, baseDir, currentDepth = 0) {
+    if (currentDepth >= maxDepth) {
+        return [];
+    }
+    const ignoredDirs = new Set(['.git', 'node_modules', 'dist', '.next', 'build', 'coverage']);
+    const results = [];
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (ignoredDirs.has(entry.name)) {
+                continue;
+            }
+            const fullPath = join(dir, entry.name);
+            const relativePath = relative(baseDir, fullPath);
+            const indent = '  '.repeat(currentDepth);
+            if (entry.isDirectory()) {
+                results.push(`${indent}${entry.name}/`);
+                results.push(...listFilesRecursive(fullPath, maxDepth, baseDir, currentDepth + 1));
+            }
+            else {
+                const stats = statSync(fullPath);
+                const size = formatFileSize(stats.size);
+                results.push(`${indent}${entry.name} ${size}`);
+            }
+        }
+    }
+    catch (error) {
+        // Skip directories we can't read
+    }
+    return results;
+}
+function searchFilesGlob(dir, pattern) {
+    const results = [];
+    const regex = globToRegex(pattern);
+    function search(currentDir) {
+        const ignoredDirs = new Set(['.git', 'node_modules', 'dist', '.next', 'build', 'coverage']);
+        try {
+            const entries = readdirSync(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (ignoredDirs.has(entry.name)) {
+                    continue;
+                }
+                const fullPath = join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    search(fullPath);
+                }
+                else if (regex.test(fullPath)) {
+                    results.push(fullPath);
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories we can't read
+        }
+    }
+    search(dir);
+    return results;
+}
+function buildWriteSummary(filePath, diffSegments, workingDir, filePreviouslyExisted) {
+    const readablePath = formatRelativeFilePath(filePath, workingDir);
+    const addedLines = diffSegments.filter((segment) => segment.type === 'added').length;
+    const removedLines = diffSegments.filter((segment) => segment.type === 'removed').length;
+    const hasChanges = diffSegments.length > 0;
+    const actionLabel = !filePreviouslyExisted ? 'Added' : hasChanges ? 'Edited' : 'Updated';
+    const header = `#### ${actionLabel} ${readablePath}`;
+    if (!hasChanges) {
+        return `${header}\nNo textual changes.`;
+    }
+    const statsLine = `Lines changed: +${addedLines} / -${removedLines}`;
+    const diffLines = formatDiffLines(diffSegments);
+    const diffBlock = ['```diff', ...diffLines, '```'].join('\n');
+    const sections = [header, statsLine, '', 'Diff preview:', diffBlock];
+    return sections.join('\n').trimEnd();
+}
+function formatRelativeFilePath(filePath, workingDir) {
+    const relPath = relative(workingDir, filePath);
+    if (!relPath || relPath.startsWith('..')) {
+        return filePath;
+    }
+    return relPath;
+}
+function globToRegex(pattern) {
+    const escaped = pattern
+        .replace(/\./g, '\\.')
+        .replace(/\*\*/g, '.*')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '.');
+    return new RegExp(escaped);
+}
+function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}

package/dist/tools/searchTools.js

@@ -0,0 +1,175 @@
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+export function createSearchTools(workingDir) {
+    return [
+        {
+            name: 'grep_search',
+            description: 'Search for text patterns in files (similar to grep)',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: {
+                        type: 'string',
+                        description: 'The text pattern to search for (regex supported)',
+                    },
+                    path: {
+                        type: 'string',
+                        description: 'The directory or file to search in',
+                    },
+                    filePattern: {
+                        type: 'string',
+                        description: 'File pattern to filter (e.g., "*.ts", "*.js")',
+                    },
+                    caseSensitive: {
+                        type: 'boolean',
+                        description: 'Whether to perform case-sensitive search',
+                    },
+                },
+                required: ['pattern'],
+            },
+            handler: async (args) => {
+                const pattern = args.pattern;
+                const searchPath = args.path ? join(workingDir, args.path) : workingDir;
+                const filePattern = args.filePattern;
+                const caseSensitive = args.caseSensitive === true;
+                try {
+                    const regex = new RegExp(pattern, caseSensitive ? 'g' : 'gi');
+                    const results = searchInFiles(searchPath, regex, filePattern);
+                    if (results.length === 0) {
+                        return `No matches found for pattern: ${pattern}`;
+                    }
+                    return formatSearchResults(results);
+                }
+                catch (error) {
+                    return `Error searching: ${error instanceof Error ? error.message : String(error)}`;
+                }
+            },
+        },
+        {
+            name: 'find_definition',
+            description: 'Find function/class/interface definitions in code',
+            parameters: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'The name of the function, class, or interface to find',
+                    },
+                    type: {
+                        type: 'string',
+                        enum: ['function', 'class', 'interface', 'type', 'const', 'any'],
+                        description: 'The type of definition to search for',
+                    },
+                },
+                required: ['name'],
+            },
+            handler: async (args) => {
+                const name = args.name;
+                const type = args.type || 'any';
+                const patterns = {
+                    function: `(function\\s+${name}|const\\s+${name}\\s*=.*=>|${name}\\s*\\([^)]*\\)\\s*{)`,
+                    class: `class\\s+${name}`,
+                    interface: `interface\\s+${name}`,
+                    type: `type\\s+${name}`,
+                    const: `const\\s+${name}`,
+                    any: `(function\\s+${name}|class\\s+${name}|interface\\s+${name}|type\\s+${name}|const\\s+${name})`,
+                };
+                const pattern = patterns[type] || patterns.any;
+                const regex = new RegExp(pattern, 'gi');
+                try {
+                    const results = searchInFiles(workingDir, regex, '*.{ts,js,tsx,jsx}');
+                    if (results.length === 0) {
+                        return `No definitions found for: ${name}`;
+                    }
+                    return formatSearchResults(results);
+                }
+                catch (error) {
+                    return `Error finding definition: ${error instanceof Error ? error.message : String(error)}`;
+                }
+            },
+        },
+    ];
+}
+function searchInFiles(path, regex, filePattern) {
+    const results = [];
+    const ignoredDirs = new Set(['.git', 'node_modules', 'dist', '.next', 'build', 'coverage']);
+    function search(currentPath) {
+        try {
+            const stat = statSync(currentPath);
+            if (stat.isDirectory()) {
+                const entries = readdirSync(currentPath);
+                for (const entry of entries) {
+                    if (ignoredDirs.has(entry))
+                        continue;
+                    search(join(currentPath, entry));
+                }
+            }
+            else if (stat.isFile()) {
+                // Check file pattern
+                if (filePattern && !matchFilePattern(currentPath, filePattern)) {
+                    return;
+                }
+                // Skip binary files
+                if (isBinaryFile(currentPath)) {
+                    return;
+                }
+                try {
+                    const content = readFileSync(currentPath, 'utf-8');
+                    const lines = content.split('\n');
+                    lines.forEach((line, index) => {
+                        const matches = line.match(regex);
+                        if (matches) {
+                            results.push({
+                                file: currentPath,
+                                line: index + 1,
+                                content: line.trim(),
+                                match: matches[0],
+                            });
+                        }
+                    });
+                }
+                catch (error) {
+                    // Skip files we can't read
+                }
+            }
+        }
+        catch (error) {
+            // Skip paths we can't access
+        }
+    }
+    search(path);
+    return results;
+}
+function formatSearchResults(results) {
+    const grouped = new Map();
+    for (const result of results) {
+        if (!grouped.has(result.file)) {
+            grouped.set(result.file, []);
+        }
+        grouped.get(result.file).push(result);
+    }
+    const output = [`Found ${results.length} matches in ${grouped.size} files:\n`];
+    for (const [file, matches] of grouped) {
+        output.push(`\n${file}:`);
+        for (const match of matches) {
+            output.push(`  Line ${match.line}: ${match.content}`);
+        }
+    }
+    return output.join('\n');
+}
+function matchFilePattern(filePath, pattern) {
+    const regex = new RegExp(pattern
+        .replace(/\./g, '\\.')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.'), 'i');
+    return regex.test(filePath);
+}
+function isBinaryFile(filePath) {
+    const textExtensions = new Set([
+        '.ts', '.js', '.tsx', '.jsx', '.json', '.md', '.txt',
+        '.html', '.css', '.scss', '.sass', '.less',
+        '.yml', '.yaml', '.xml', '.svg', '.sh', '.bash',
+        '.py', '.rb', '.go', '.rs', '.c', '.cpp', '.h',
+    ]);
+    return !textExtensions.has(filePath.slice(filePath.lastIndexOf('.')));
+}

package/dist/tools/tavilyTools.js

@@ -0,0 +1,176 @@
+const DEFAULT_BASE_URL = 'https://api.tavily.com';
+const DEFAULT_MAX_RESULTS = 5;
+const MAX_ALLOWED_RESULTS = 10;
+export function createTavilyTools(config) {
+    const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+    return [buildSearchTool(config.apiKey, baseUrl), buildExtractTool(config.apiKey, baseUrl)];
+}
+function buildSearchTool(apiKey, baseUrl) {
+    return {
+        name: 'tavily_search',
+        description: 'Search the live web using Tavily and return summarized results.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Search query to run against Tavily.',
+                },
+                searchDepth: {
+                    type: 'string',
+                    description: 'Depth of the search (basic or advanced).',
+                    enum: ['basic', 'advanced'],
+                },
+                includeImages: {
+                    type: 'boolean',
+                    description: 'Include links to images when true.',
+                },
+                includeRawContent: {
+                    type: 'boolean',
+                    description: 'Include raw page content in the response.',
+                },
+                maxResults: {
+                    type: 'number',
+                    description: 'Maximum number of results to return (1-10).',
+                },
+            },
+            required: ['query'],
+            additionalProperties: false,
+        },
+        handler: async (args) => {
+            const query = typeof args.query === 'string' ? args.query.trim() : '';
+            if (!query) {
+                return 'A non-empty query is required to run Tavily search.';
+            }
+            const payload = {
+                query,
+                search_depth: args.searchDepth === 'advanced' ? 'advanced' : 'basic',
+                include_images: args.includeImages === true,
+                include_raw_content: args.includeRawContent === true,
+                max_results: normalizeMaxResults(args.maxResults),
+            };
+            try {
+                const response = await callTavily(baseUrl, '/search', apiKey, payload);
+                return formatSearchResponse(response);
+            }
+            catch (error) {
+                return formatTavilyError(error);
+            }
+        },
+    };
+}
+function buildExtractTool(apiKey, baseUrl) {
+    return {
+        name: 'tavily_extract',
+        description: 'Extract structured content from a URL using Tavily.',
+        parameters: {
+            type: 'object',
+            properties: {
+                url: {
+                    type: 'string',
+                    description: 'Canonical URL to extract text from.',
+                },
+                question: {
+                    type: 'string',
+                    description: 'Optional focus question to guide the extraction.',
+                },
+            },
+            required: ['url'],
+            additionalProperties: false,
+        },
+        handler: async (args) => {
+            const targetUrl = typeof args.url === 'string' ? args.url.trim() : '';
+            if (!targetUrl) {
+                return 'A valid URL is required for Tavily extraction.';
+            }
+            const payload = {
+                url: targetUrl,
+            };
+            if (typeof args.question === 'string' && args.question.trim()) {
+                payload.question = args.question.trim();
+            }
+            try {
+                const response = await callTavily(baseUrl, '/extract', apiKey, payload);
+                return formatExtractResponse(response);
+            }
+            catch (error) {
+                return formatTavilyError(error);
+            }
+        },
+    };
+}
+async function callTavily(baseUrl, path, apiKey, body) {
+    const response = await fetch(`${baseUrl}${path}`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ api_key: apiKey, ...body }),
+    });
+    const text = await response.text();
+    if (!response.ok) {
+        throw new Error(text || `Tavily request failed with status ${response.status}`);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error('Unable to parse Tavily response.');
+    }
+}
+function formatSearchResponse(payload) {
+    if (!payload?.results?.length) {
+        return 'No Tavily search results were returned.';
+    }
+    const lines = [];
+    if (payload.answer) {
+        lines.push(`Answer: ${payload.answer.trim()}`);
+        lines.push('');
+    }
+    payload.results.slice(0, MAX_ALLOWED_RESULTS).forEach((result, index) => {
+        const title = result.title?.trim() || `Result ${index + 1}`;
+        lines.push(`${index + 1}. ${title}`);
+        lines.push(`   URL: ${result.url}`);
+        if (result.score) {
+            lines.push(`   Score: ${result.score.toFixed(2)}`);
+        }
+        if (result.content) {
+            lines.push(`   ${truncate(result.content.trim(), 280)}`);
+        }
+        lines.push('');
+    });
+    return lines.join('\n').trimEnd();
+}
+function formatExtractResponse(payload) {
+    const lines = [payload.title ? `Title: ${payload.title.trim()}` : 'Title: (unknown)', `URL: ${payload.url}`];
+    if (payload.language) {
+        lines.push(`Language: ${payload.language}`);
+    }
+    lines.push('');
+    if (payload.content) {
+        lines.push(payload.content.trim());
+    }
+    else {
+        lines.push('No content returned by Tavily extract.');
+    }
+    return lines.join('\n');
+}
+function formatTavilyError(error) {
+    if (error instanceof Error) {
+        return `Tavily request failed: ${error.message}`;
+    }
+    return `Tavily request failed: ${String(error)}`;
+}
+function normalizeMaxResults(rawValue) {
+    if (typeof rawValue !== 'number' || Number.isNaN(rawValue)) {
+        return DEFAULT_MAX_RESULTS;
+    }
+    const clamped = Math.max(1, Math.min(MAX_ALLOWED_RESULTS, Math.round(rawValue)));
+    return clamped;
+}
+function truncate(value, max) {
+    if (value.length <= max) {
+        return value;
+    }
+    return `${value.slice(0, max - 1)}…`;
+}

package/dist/ui/__tests__/richText.test.js

@@ -0,0 +1,36 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { renderMessageBody } from '../richText.js';
+import { theme } from '../theme.js';
+test('renderMessageBody outputs compact, link-aware content', () => {
+    const sample = [
+        '• Japan stop: Trump met with business leaders and reaffirmed defense ties in Tokyo.',
+        '• South Korea finale: follow-on talks at the Busan economic summit reinforced chip cooperation.',
+        '',
+        'Sources:',
+        '- CNN recap: https://www.cnn.com/politics/trump-asia',
+        '- Reuters briefing: [Full itinerary](https://www.reuters.com/world/example-trip)',
+    ].join('\n');
+    const body = renderMessageBody(sample, 64);
+    assert.ok(!body.includes('┌'));
+    assert.ok(!body.includes('│'));
+    assert.ok(!body.includes('└'));
+    const lines = body.split('\n');
+    let blankRun = 0;
+    for (const line of lines) {
+        assert.equal(line, line.trimEnd());
+        if (!line.trim()) {
+            blankRun += 1;
+            assert.ok(blankRun <= 1, 'should not render multiple consecutive blank separators');
+        }
+        else {
+            blankRun = 0;
+        }
+    }
+    const bareLink = (theme.link?.url ?? theme.info)('https://www.cnn.com/politics/trump-asia');
+    assert.ok(body.includes(bareLink), 'bare links should be colorized');
+    const markdownLinkLabel = (theme.link?.label ?? theme.secondary)('Full itinerary');
+    const markdownLinkUrl = (theme.link?.url ?? theme.info)('(https://www.reuters.com/world/example-trip)');
+    assert.ok(body.includes(markdownLinkLabel), 'markdown link labels should be highlighted');
+    assert.ok(body.includes(markdownLinkUrl), 'markdown link URLs should reuse link color');
+});