@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/commands/explain.js

@@ -0,0 +1,235 @@
+/**
+ * Explain Command
+ *
+ * Get AI explanations for code, infrastructure, or errors
+ *
+ * Usage: nimbus explain <target> [options]
+ */
+import { logger } from '../utils';
+import { ui } from '../wizard';
+import { llmClient } from '../clients';
+/**
+ * Detect content type from target
+ */
+function detectExplainType(target, content) {
+    // Check for error patterns
+    const errorPatterns = [
+        /^error:/i,
+        /^exception:/i,
+        /failed/i,
+        /traceback/i,
+        /stack trace/i,
+        /undefined variable/i,
+        /cannot find/i,
+        /not found/i,
+        /invalid/i,
+        /permission denied/i,
+    ];
+    const targetLower = target.toLowerCase();
+    if (errorPatterns.some(p => p.test(target) || (content && p.test(content)))) {
+        return 'error';
+    }
+    // Check for infrastructure file extensions
+    const infraExtensions = ['.tf', '.yaml', '.yml', '.json', '.hcl', '.toml'];
+    if (infraExtensions.some(ext => targetLower.endsWith(ext))) {
+        return 'infra';
+    }
+    // Check content for infrastructure patterns
+    if (content) {
+        if (content.includes('apiVersion:') && content.includes('kind:')) {
+            return 'infra'; // Kubernetes
+        }
+        if (content.includes('resource ') && content.includes('provider ')) {
+            return 'infra'; // Terraform
+        }
+        if (content.includes('AWSTemplateFormatVersion')) {
+            return 'infra'; // CloudFormation
+        }
+    }
+    // Check for code file extensions
+    const codeExtensions = [
+        '.ts',
+        '.js',
+        '.py',
+        '.go',
+        '.java',
+        '.rs',
+        '.rb',
+        '.php',
+        '.c',
+        '.cpp',
+        '.cs',
+    ];
+    if (codeExtensions.some(ext => targetLower.endsWith(ext))) {
+        return 'code';
+    }
+    // Default to code for unknown content
+    return 'code';
+}
+/**
+ * Build the explanation prompt based on type
+ */
+function buildPrompt(type, content, verbose) {
+    const detailLevel = verbose ? 'detailed' : 'concise';
+    switch (type) {
+        case 'error':
+            return `Please explain this error and suggest how to fix it. Provide a ${detailLevel} explanation.
+
+Error:
+\`\`\`
+${content}
+\`\`\`
+
+Include:
+1. What the error means
+2. Why it might have occurred
+3. How to fix it
+4. How to prevent it in the future`;
+        case 'infra':
+            return `Please explain this infrastructure configuration. Provide a ${detailLevel} explanation.
+
+Configuration:
+\`\`\`
+${content}
+\`\`\`
+
+Include:
+1. What this configuration does
+2. Key components and their purpose
+3. Any potential issues or improvements
+${verbose ? '4. Security considerations\n5. Best practices recommendations' : ''}`;
+        case 'code':
+        default:
+            return `Please explain this code. Provide a ${detailLevel} explanation.
+
+Code:
+\`\`\`
+${content}
+\`\`\`
+
+Include:
+1. What the code does
+2. How it works
+3. Any potential issues
+${verbose ? '4. Suggestions for improvement\n5. Related best practices' : ''}`;
+    }
+}
+/**
+ * Run the explain command
+ */
+export async function explainCommand(target, options = {}) {
+    logger.info('Running explain command', { target, options });
+    let content;
+    let filePath;
+    // Get content to explain
+    if (options.file) {
+        // Read from specified file
+        filePath = options.file;
+        try {
+            const fs = await import('fs/promises');
+            content = await fs.readFile(filePath, 'utf-8');
+        }
+        catch (error) {
+            ui.error(`Could not read file: ${error.message}`);
+            process.exit(1);
+        }
+    }
+    else if (target) {
+        // Check if target is a file path
+        try {
+            const fs = await import('fs/promises');
+            const stat = await fs.stat(target);
+            if (stat.isFile()) {
+                filePath = target;
+                content = await fs.readFile(target, 'utf-8');
+            }
+            else if (stat.isDirectory()) {
+                ui.error('Please specify a file, not a directory');
+                ui.info('Usage: nimbus explain <file> or nimbus explain "error message"');
+                process.exit(1);
+            }
+            else {
+                content = target;
+            }
+        }
+        catch {
+            // Not a file, use as content directly
+            content = target;
+        }
+    }
+    else {
+        ui.error('Please provide something to explain');
+        ui.newLine();
+        ui.print('Usage: nimbus explain <target> [options]');
+        ui.newLine();
+        ui.print('Examples:');
+        ui.print('  nimbus explain ./main.tf');
+        ui.print('  nimbus explain "Error: resource not found" --type error');
+        ui.print('  nimbus explain --file ./deployment.yaml');
+        process.exit(1);
+    }
+    // Limit content size
+    const maxLength = 10000;
+    if (content.length > maxLength) {
+        ui.warning(`Content truncated to ${maxLength} characters`);
+        content = `${content.slice(0, maxLength)}\n... (content truncated)`;
+    }
+    // Detect or use specified type
+    const type = options.type === 'auto' || !options.type ? detectExplainType(target, content) : options.type;
+    // Display header
+    ui.header('Nimbus Explain');
+    if (filePath) {
+        ui.info(`File: ${filePath}`);
+    }
+    ui.info(`Type: ${type}`);
+    ui.newLine();
+    // Check if LLM is available
+    const llmAvailable = await llmClient.isAvailable();
+    if (!llmAvailable) {
+        ui.error('LLM service is not available');
+        ui.info('Make sure you have configured an LLM provider with "nimbus login"');
+        process.exit(1);
+    }
+    // Build prompt
+    const prompt = buildPrompt(type, content, options.verbose ?? false);
+    ui.startSpinner({ message: 'Analyzing...' });
+    try {
+        let response = '';
+        let firstChunk = true;
+        for await (const chunk of llmClient.chat(prompt, [])) {
+            if (chunk.type === 'content' && chunk.content) {
+                if (firstChunk) {
+                    ui.stopSpinnerSuccess('');
+                    ui.newLine();
+                    firstChunk = false;
+                }
+                response += chunk.content;
+                process.stdout.write(chunk.content);
+            }
+            else if (chunk.type === 'error') {
+                ui.stopSpinnerFail('Error');
+                ui.error(chunk.message || chunk.error || 'Unknown error');
+                process.exit(1);
+            }
+        }
+        // Ensure newline at end
+        if (!response.endsWith('\n')) {
+            ui.newLine();
+        }
+        // JSON output mode
+        if (options.json) {
+            console.log(JSON.stringify({
+                type,
+                file: filePath,
+                explanation: response,
+            }, null, 2));
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed');
+        ui.error(error.message);
+        process.exit(1);
+    }
+}
+// Export as default
+export default explainCommand;

package/dist/src/commands/export.js

@@ -0,0 +1,120 @@
+/**
+ * Export Command (G19)
+ *
+ * Export session conversations to markdown, HTML, or JSON.
+ *
+ * Usage:
+ *   nimbus export                        # most recent session → stdout (md)
+ *   nimbus export <session-id>           # specific session
+ *   nimbus export --format html          # HTML output
+ *   nimbus export --format json          # JSON output
+ *   nimbus export --output report.md     # save to file
+ */
+import { writeFileSync } from 'node:fs';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function messageToMarkdown(role, content) {
+    const label = role === 'user' ? '**User**' : role === 'assistant' ? '**Agent**' : `*[${role}]*`;
+    return `${label}:\n${content}\n`;
+}
+// ---------------------------------------------------------------------------
+// Main export
+// ---------------------------------------------------------------------------
+export async function exportCommand(options = {}) {
+    const format = options.format ?? 'md';
+    // Load session manager + conversation
+    let conversation = [];
+    let sessionMeta = { id: 'unknown' };
+    try {
+        const { SessionManager } = await import('../sessions/manager');
+        const sm = SessionManager.getInstance();
+        const sessions = sm.list();
+        // Find the target session
+        let targetSession = sessions.find(s => options.sessionId && (s.id === options.sessionId || s.id.startsWith(options.sessionId))) ?? sessions[0];
+        if (!targetSession) {
+            console.error('No sessions found. Run "nimbus chat" first to create a session.');
+            process.exit(1);
+        }
+        sessionMeta = {
+            id: targetSession.id,
+            name: targetSession.name,
+            model: targetSession.model,
+            mode: targetSession.mode,
+            createdAt: targetSession.createdAt,
+        };
+        const messages = sm.loadConversation(targetSession.id);
+        conversation = messages
+            .filter(m => m.role === 'user' || m.role === 'assistant')
+            .map(m => ({
+            role: m.role,
+            content: Array.isArray(m.content)
+                ? m.content.map((b) => {
+                    if (typeof b === 'string')
+                        return b;
+                    if (b && typeof b === 'object' && 'text' in b)
+                        return b.text;
+                    return '';
+                }).join('')
+                : String(m.content ?? ''),
+        }));
+    }
+    catch (err) {
+        console.error(`Failed to load session: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    // Generate output
+    let output = '';
+    if (format === 'json') {
+        output = JSON.stringify({ session: sessionMeta, messages: conversation }, null, 2);
+    }
+    else if (format === 'html') {
+        output = buildHtml(sessionMeta, conversation);
+    }
+    else {
+        // Default: markdown
+        output = buildMarkdown(sessionMeta, conversation);
+    }
+    // Output to file or stdout
+    if (options.output) {
+        writeFileSync(options.output, output, 'utf-8');
+        console.log(`Exported to: ${options.output}`);
+    }
+    else {
+        process.stdout.write(output);
+    }
+}
+function buildMarkdown(meta, conversation) {
+    const lines = [
+        `# Nimbus Session Export`,
+        ``,
+        `| Field | Value |`,
+        `|-------|-------|`,
+        `| Session ID | ${meta.id} |`,
+        `| Name | ${meta.name ?? 'N/A'} |`,
+        `| Model | ${meta.model ?? 'N/A'} |`,
+        `| Mode | ${meta.mode ?? 'N/A'} |`,
+        `| Created | ${meta.createdAt ?? new Date().toISOString()} |`,
+        ``,
+        `---`,
+        ``,
+        `## Conversation`,
+        ``,
+    ];
+    for (const msg of conversation) {
+        lines.push(messageToMarkdown(msg.role, msg.content));
+        lines.push('---');
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function buildHtml(meta, conversation) {
+    const escape = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    const msgs = conversation.map(m => {
+        const isUser = m.role === 'user';
+        const bg = isUser ? '#3b82f6' : '#1e293b';
+        const align = isUser ? 'flex-end' : 'flex-start';
+        return `<div style="display:flex;justify-content:${align};margin:8px 0"><div style="max-width:75%;padding:12px 16px;border-radius:16px;background:${bg};color:#e2e8f0;font-size:14px;line-height:1.6;white-space:pre-wrap">${escape(m.content)}</div></div>`;
+    }).join('\n');
+    return `<!DOCTYPE html><html><head><meta charset="utf-8"><title>Nimbus Session Export — ${escape(meta.id)}</title></head><body style="background:#0f172a;color:#e2e8f0;font-family:monospace;padding:24px"><h2>Nimbus Session: ${escape(meta.name ?? meta.id)}</h2><p>Model: ${escape(meta.model ?? 'N/A')} | Mode: ${escape(meta.mode ?? 'N/A')} | Created: ${escape(meta.createdAt ?? '')}</p><div>${msgs}</div></body></html>`;
+}

package/dist/src/commands/feedback.js

@@ -0,0 +1,319 @@
+/**
+ * Feedback Command
+ *
+ * Collect and submit user feedback via GitHub issues or browser
+ *
+ * Usage: nimbus feedback [options]
+ */
+import { logger } from '../utils';
+import { ui } from '../wizard';
+import { input, select } from '../wizard/prompts';
+const FEEDBACK_TYPES = {
+    bug: {
+        label: 'Bug Report',
+        emoji: 'bug',
+        template: `## Bug Description
+<!-- A clear and concise description of what the bug is -->
+
+## Steps to Reproduce
+1.
+2.
+3.
+
+## Expected Behavior
+<!-- What you expected to happen -->
+
+## Actual Behavior
+<!-- What actually happened -->
+
+## Environment
+- Nimbus Version:
+- OS:
+- Node Version:
+
+## Additional Context
+<!-- Any other relevant information -->
+`,
+        labels: ['bug', 'triage'],
+    },
+    feature: {
+        label: 'Feature Request',
+        emoji: 'sparkles',
+        template: `## Feature Description
+<!-- A clear and concise description of the feature -->
+
+## Use Case
+<!-- Why do you need this feature? What problem does it solve? -->
+
+## Proposed Solution
+<!-- How do you think this should work? -->
+
+## Alternatives Considered
+<!-- Any alternative solutions or features you've considered -->
+
+## Additional Context
+<!-- Any other relevant information -->
+`,
+        labels: ['enhancement', 'feature-request'],
+    },
+    question: {
+        label: 'Question',
+        emoji: 'question',
+        template: `## Question
+<!-- What would you like to know? -->
+
+## Context
+<!-- What are you trying to accomplish? -->
+
+## What I've Tried
+<!-- What documentation or approaches have you already tried? -->
+`,
+        labels: ['question', 'help-wanted'],
+    },
+};
+const GITHUB_REPO = 'the-ai-project-co/nimbus';
+const GITHUB_ISSUES_URL = `https://github.com/${GITHUB_REPO}/issues`;
+/**
+ * Get system information for bug reports
+ */
+async function getSystemInfo() {
+    const os = await import('os');
+    const { execFileSync } = await import('child_process');
+    const info = {
+        OS: `${os.platform()} ${os.release()}`,
+        Architecture: os.arch(),
+        'Node Version': process.version,
+    };
+    // Try to get Nimbus version
+    try {
+        const fs = await import('fs/promises');
+        const path = await import('path');
+        const packagePath = path.join(__dirname, '../../package.json');
+        const packageJson = JSON.parse(await fs.readFile(packagePath, 'utf-8'));
+        info['Nimbus Version'] = packageJson.version;
+    }
+    catch {
+        info['Nimbus Version'] = 'unknown';
+    }
+    // Try to get Bun version
+    try {
+        const bunVersion = execFileSync('bun', ['--version'], { encoding: 'utf-8' }).trim();
+        info['Bun Version'] = bunVersion;
+    }
+    catch {
+        // Bun not installed
+    }
+    return info;
+}
+/**
+ * Open URL in browser
+ */
+async function openInBrowser(url) {
+    const { exec } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(exec);
+    try {
+        const platform = process.platform;
+        let command;
+        if (platform === 'darwin') {
+            command = `open "${url}"`;
+        }
+        else if (platform === 'win32') {
+            command = `start "" "${url}"`;
+        }
+        else {
+            command = `xdg-open "${url}"`;
+        }
+        await execAsync(command);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Build GitHub issue URL with pre-filled content
+ */
+function buildIssueUrl(type, title, body, labels) {
+    const params = new URLSearchParams({
+        title,
+        body,
+        labels: labels.join(','),
+    });
+    return `${GITHUB_ISSUES_URL}/new?${params.toString()}`;
+}
+/**
+ * Interactive feedback collection
+ */
+async function collectFeedbackInteractively(options) {
+    // Determine feedback type
+    let feedbackType;
+    if (options.bug) {
+        feedbackType = 'bug';
+    }
+    else if (options.feature) {
+        feedbackType = 'feature';
+    }
+    else if (options.question) {
+        feedbackType = 'question';
+    }
+    else {
+        // Ask user to select type
+        feedbackType = await select({
+            message: 'What type of feedback would you like to provide?',
+            options: [
+                { label: 'Bug Report', value: 'bug' },
+                { label: 'Feature Request', value: 'feature' },
+                { label: 'Question', value: 'question' },
+            ],
+        });
+        if (!feedbackType) {
+            return null;
+        }
+    }
+    const typeConfig = FEEDBACK_TYPES[feedbackType];
+    ui.newLine();
+    ui.print(ui.bold(`${typeConfig.label}`));
+    ui.newLine();
+    // Get title
+    let title = options.title;
+    if (!title) {
+        title = await input({
+            message: 'Brief summary (title):',
+            placeholder: `Enter a short description of your ${feedbackType === 'bug' ? 'issue' : feedbackType === 'feature' ? 'request' : 'question'}`,
+        });
+        if (!title || title.trim() === '') {
+            ui.warning('Feedback cancelled - no title provided');
+            return null;
+        }
+    }
+    // Get body/description
+    let body = options.body;
+    if (!body) {
+        ui.newLine();
+        ui.info('Please provide details (press Enter twice to finish):');
+        ui.dim('Tip: You can also edit the full template on GitHub');
+        ui.newLine();
+        body = await input({
+            message: 'Details (optional):',
+            placeholder: 'Describe the issue, feature, or question in detail...',
+        });
+    }
+    // Build full body with template
+    let fullBody = typeConfig.template;
+    if (body && body.trim()) {
+        // Replace first section placeholder with user's input
+        fullBody = fullBody.replace(/<!-- .+? -->/, body.trim());
+    }
+    // Add system info for bug reports
+    if (feedbackType === 'bug') {
+        const systemInfo = await getSystemInfo();
+        const envSection = Object.entries(systemInfo)
+            .map(([key, value]) => `- ${key}: ${value}`)
+            .join('\n');
+        fullBody = fullBody.replace('## Environment\n- Nimbus Version: \n- OS: \n- Node Version:', `## Environment\n${envSection}`);
+    }
+    return {
+        type: feedbackType,
+        title: title.trim(),
+        body: fullBody,
+    };
+}
+/**
+ * Run the feedback command
+ */
+export async function feedbackCommand(options = {}) {
+    logger.debug('Running feedback command', { options });
+    ui.header('Nimbus Feedback');
+    ui.info('Help us improve Nimbus by sharing your feedback!');
+    ui.newLine();
+    // Quick open mode - just open GitHub issues
+    if (options.open) {
+        ui.info('Opening GitHub issues page...');
+        const opened = await openInBrowser(GITHUB_ISSUES_URL);
+        if (opened) {
+            ui.success('Opened in browser');
+        }
+        else {
+            ui.print(`Visit: ${GITHUB_ISSUES_URL}`);
+        }
+        return;
+    }
+    // Collect feedback interactively
+    const feedback = await collectFeedbackInteractively(options);
+    if (!feedback) {
+        return;
+    }
+    const typeConfig = FEEDBACK_TYPES[feedback.type];
+    const issueUrl = buildIssueUrl(feedback.type, feedback.title, feedback.body, typeConfig.labels);
+    // JSON output
+    if (options.json) {
+        console.log(JSON.stringify({
+            type: feedback.type,
+            title: feedback.title,
+            url: issueUrl,
+            labels: typeConfig.labels,
+        }, null, 2));
+        return;
+    }
+    ui.newLine();
+    ui.print(ui.bold('Feedback Summary'));
+    ui.print(`  Type:  ${typeConfig.label}`);
+    ui.print(`  Title: ${feedback.title}`);
+    ui.newLine();
+    // Open in browser
+    ui.info('Opening GitHub to submit your feedback...');
+    const opened = await openInBrowser(issueUrl);
+    if (opened) {
+        ui.success('Opened in browser - please review and submit the issue');
+    }
+    else {
+        ui.warning('Could not open browser automatically');
+        ui.newLine();
+        ui.print('Please copy and paste this URL to submit your feedback:');
+        ui.print(issueUrl);
+    }
+    ui.newLine();
+    ui.info('Thank you for your feedback!');
+}
+/**
+ * Parse feedback command options from CLI args
+ */
+export function parseFeedbackOptions(args) {
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '--bug':
+            case '-b':
+                options.bug = true;
+                break;
+            case '--feature':
+            case '-f':
+                options.feature = true;
+                break;
+            case '--question':
+            case '-q':
+                options.question = true;
+                break;
+            case '--title':
+            case '-t':
+                options.title = args[++i];
+                break;
+            case '--body':
+            case '-m':
+                options.body = args[++i];
+                break;
+            case '--open':
+            case '-o':
+                options.open = true;
+                break;
+            case '--json':
+                options.json = true;
+                break;
+        }
+    }
+    return options;
+}
+// Export as default command
+export default feedbackCommand;