@build-astron-co/nimbus 0.2.0

package/src/commands/feedback.ts

@@ -0,0 +1,389 @@
+/**
+ * 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';
+
+/**
+ * Command options
+ */
+export interface FeedbackOptions {
+  bug?: boolean;
+  feature?: boolean;
+  question?: boolean;
+  title?: string;
+  body?: string;
+  open?: boolean;
+  json?: boolean;
+}
+
+/**
+ * Feedback type configuration
+ */
+interface FeedbackType {
+  label: string;
+  emoji: string;
+  template: string;
+  labels: string[];
+}
+
+const FEEDBACK_TYPES: Record<string, FeedbackType> = {
+  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(): Promise<Record<string, string>> {
+  const os = await import('os');
+  const { execFileSync } = await import('child_process');
+
+  const info: Record<string, string> = {
+    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: string): Promise<boolean> {
+  const { exec } = await import('child_process');
+  const { promisify } = await import('util');
+  const execAsync = promisify(exec);
+
+  try {
+    const platform = process.platform;
+    let command: string;
+
+    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: string, title: string, body: string, labels: string[]): string {
+  const params = new URLSearchParams({
+    title,
+    body,
+    labels: labels.join(','),
+  });
+
+  return `${GITHUB_ISSUES_URL}/new?${params.toString()}`;
+}
+
+/**
+ * Interactive feedback collection
+ */
+async function collectFeedbackInteractively(
+  options: FeedbackOptions
+): Promise<{ type: string; title: string; body: string } | null> {
+  // Determine feedback type
+  let feedbackType: string | undefined;
+
+  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: FeedbackOptions = {}): Promise<void> {
+  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: string[]): FeedbackOptions {
+  const options: FeedbackOptions = {};
+
+  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;

package/src/commands/fix.ts

@@ -0,0 +1,324 @@
+/**
+ * Fix Command
+ *
+ * AI-assisted error fixing
+ *
+ * Usage: nimbus fix <error-or-file> [options]
+ */
+
+import { logger } from '../utils';
+import { ui, confirm } from '../wizard';
+import { llmClient } from '../clients';
+
+/**
+ * Command options
+ */
+export interface FixOptions {
+  file?: string;
+  autoApply?: boolean;
+  dryRun?: boolean;
+  json?: boolean;
+}
+
+/**
+ * Fix suggestion from AI
+ */
+interface FixSuggestion {
+  problem: string;
+  explanation: string;
+  fix: string;
+  originalCode?: string;
+  fixedCode?: string;
+  filePath?: string;
+  lineNumber?: number;
+}
+
+/**
+ * Parse fix response from AI
+ */
+function parseFixResponse(response: string): FixSuggestion {
+  // Try to extract structured sections from the response
+  const problemMatch = response.match(
+    /(?:problem|issue|error):\s*(.+?)(?=\n(?:explanation|fix|solution)|$)/is
+  );
+  const explanationMatch = response.match(
+    /(?:explanation|cause|reason):\s*(.+?)(?=\n(?:fix|solution)|$)/is
+  );
+  const fixMatch = response.match(
+    /(?:fix|solution|resolution):\s*(.+?)(?=\n(?:original|fixed)|$)/is
+  );
+  const originalMatch = response.match(/(?:original|before)[^:]*:\s*```[\w]*\n([\s\S]*?)```/i);
+  const fixedMatch = response.match(/(?:fixed|after|corrected)[^:]*:\s*```[\w]*\n([\s\S]*?)```/i);
+
+  return {
+    problem: problemMatch?.[1]?.trim() || 'Unable to parse problem description',
+    explanation: explanationMatch?.[1]?.trim() || response.split('\n').slice(0, 3).join('\n'),
+    fix: fixMatch?.[1]?.trim() || 'See suggested code below',
+    originalCode: originalMatch?.[1]?.trim(),
+    fixedCode: fixedMatch?.[1]?.trim(),
+  };
+}
+
+/**
+ * Build the fix prompt
+ */
+function buildFixPrompt(errorContent: string, fileContent?: string, filePath?: string): string {
+  let prompt = `Please help fix this error. Analyze the problem and provide a solution.
+
+Error:
+\`\`\`
+${errorContent}
+\`\`\`
+`;
+
+  if (fileContent && filePath) {
+    prompt += `
+Source file (${filePath}):
+\`\`\`
+${fileContent}
+\`\`\`
+`;
+  }
+
+  prompt += `
+Please provide:
+1. **Problem**: A brief description of what's wrong
+2. **Explanation**: Why this error occurs
+3. **Fix**: How to fix it
+
+If you can provide code changes, please show:
+- **Original**: The problematic code
+- **Fixed**: The corrected code
+
+Format your response with clear section headers.`;
+
+  return prompt;
+}
+
+/**
+ * Display fix suggestion
+ */
+function displayFixSuggestion(suggestion: FixSuggestion): void {
+  ui.newLine();
+
+  // Problem
+  ui.print(ui.color('Problem:', 'yellow'));
+  ui.print(`  ${suggestion.problem}`);
+  ui.newLine();
+
+  // Explanation
+  ui.print(ui.color('Explanation:', 'blue'));
+  for (const line of suggestion.explanation.split('\n')) {
+    ui.print(`  ${line}`);
+  }
+  ui.newLine();
+
+  // Fix
+  ui.print(ui.color('Suggested Fix:', 'green'));
+  for (const line of suggestion.fix.split('\n')) {
+    ui.print(`  ${line}`);
+  }
+
+  // Show diff if we have original and fixed code
+  if (suggestion.originalCode && suggestion.fixedCode) {
+    ui.newLine();
+    ui.print(ui.color('Code Changes:', 'cyan'));
+    ui.newLine();
+
+    // Show original
+    ui.print(ui.color('Before:', 'red'));
+    ui.print('```');
+    for (const line of suggestion.originalCode.split('\n')) {
+      ui.print(ui.color(`- ${line}`, 'red'));
+    }
+    ui.print('```');
+
+    ui.newLine();
+
+    // Show fixed
+    ui.print(ui.color('After:', 'green'));
+    ui.print('```');
+    for (const line of suggestion.fixedCode.split('\n')) {
+      ui.print(ui.color(`+ ${line}`, 'green'));
+    }
+    ui.print('```');
+  }
+}
+
+/**
+ * Apply the fix to a file
+ */
+async function applyFix(suggestion: FixSuggestion, filePath: string): Promise<boolean> {
+  if (!suggestion.originalCode || !suggestion.fixedCode) {
+    ui.warning('Cannot auto-apply: No code diff provided');
+    return false;
+  }
+
+  try {
+    const fs = await import('fs/promises');
+    const content = await fs.readFile(filePath, 'utf-8');
+
+    // Try to find and replace the original code
+    if (content.includes(suggestion.originalCode)) {
+      const newContent = content.replace(suggestion.originalCode, suggestion.fixedCode);
+      await fs.writeFile(filePath, newContent, 'utf-8');
+      return true;
+    } else {
+      ui.warning('Could not find the original code in the file');
+      ui.info('The file may have been modified since the analysis');
+      return false;
+    }
+  } catch (error: any) {
+    ui.error(`Failed to apply fix: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Run the fix command
+ */
+export async function fixCommand(errorOrFile: string, options: FixOptions = {}): Promise<void> {
+  logger.info('Running fix command', { errorOrFile, options });
+
+  let errorContent: string;
+  let fileContent: string | undefined;
+  let filePath: string | undefined;
+
+  // Determine what we're fixing
+  if (options.file) {
+    // Error content with explicit file
+    errorContent = errorOrFile;
+    filePath = options.file;
+
+    try {
+      const fs = await import('fs/promises');
+      fileContent = await fs.readFile(filePath, 'utf-8');
+    } catch (error: any) {
+      ui.warning(`Could not read file ${filePath}: ${error.message}`);
+    }
+  } else if (errorOrFile) {
+    // Check if it's a file path
+    try {
+      const fs = await import('fs/promises');
+      const stat = await fs.stat(errorOrFile);
+
+      if (stat.isFile()) {
+        filePath = errorOrFile;
+        fileContent = await fs.readFile(errorOrFile, 'utf-8');
+
+        // For a file without explicit error, we'll analyze the whole file
+        errorContent = `Please analyze this file for potential issues and errors:\n${errorOrFile}`;
+      } else {
+        errorContent = errorOrFile;
+      }
+    } catch {
+      // Not a file, treat as error message
+      errorContent = errorOrFile;
+    }
+  } else {
+    ui.error('Please provide an error message or file to fix');
+    ui.newLine();
+    ui.print('Usage: nimbus fix <error-or-file> [options]');
+    ui.newLine();
+    ui.print('Examples:');
+    ui.print('  nimbus fix "Error: undefined variable"');
+    ui.print('  nimbus fix ./broken.tf');
+    ui.print('  nimbus fix "Error: invalid syntax" --file ./app.py');
+    ui.print('  nimbus fix ./config.yaml --auto-apply');
+    process.exit(1);
+  }
+
+  // Display header
+  ui.header('Nimbus Fix');
+  if (filePath) {
+    ui.info(`File: ${filePath}`);
+  }
+  ui.info(`Error: ${errorContent.slice(0, 100)}${errorContent.length > 100 ? '...' : ''}`);
+  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 = buildFixPrompt(errorContent, fileContent, filePath);
+
+  ui.startSpinner({ message: 'Analyzing error...' });
+
+  try {
+    let response = '';
+
+    for await (const chunk of llmClient.chat(prompt, [])) {
+      if (chunk.type === 'content' && chunk.content) {
+        response += chunk.content;
+      } else if (chunk.type === 'error') {
+        ui.stopSpinnerFail('Error');
+        ui.error(chunk.message || chunk.error || 'Unknown error');
+        process.exit(1);
+      }
+    }
+
+    ui.stopSpinnerSuccess('Analysis complete');
+
+    // Parse and display the suggestion
+    const suggestion = parseFixResponse(response);
+    suggestion.filePath = filePath;
+
+    displayFixSuggestion(suggestion);
+
+    // JSON output mode
+    if (options.json) {
+      console.log(JSON.stringify(suggestion, null, 2));
+      return;
+    }
+
+    // Dry run - don't apply
+    if (options.dryRun) {
+      ui.newLine();
+      ui.info('Dry run mode - no changes applied');
+      return;
+    }
+
+    // Apply the fix if requested and possible
+    if (filePath && suggestion.originalCode && suggestion.fixedCode) {
+      ui.newLine();
+
+      const shouldApply =
+        options.autoApply ||
+        (await confirm({
+          message: 'Apply this fix?',
+          defaultValue: false,
+        }));
+
+      if (shouldApply) {
+        ui.startSpinner({ message: 'Applying fix...' });
+
+        const applied = await applyFix(suggestion, filePath);
+
+        if (applied) {
+          ui.stopSpinnerSuccess('Fix applied successfully!');
+          ui.newLine();
+          ui.info(`File updated: ${filePath}`);
+          ui.info('Please review the changes and test your code');
+        } else {
+          ui.stopSpinnerFail('Could not apply fix automatically');
+          ui.info('Please apply the suggested changes manually');
+        }
+      } else {
+        ui.info('Fix not applied');
+      }
+    }
+  } catch (error: any) {
+    ui.stopSpinnerFail('Failed');
+    ui.error(error.message);
+    process.exit(1);
+  }
+}
+
+// Export as default
+export default fixCommand;