vibecodingmachine-cli 2026.2.26-1739 → 2026.3.9-1621

package/src/utils/trui-clarifications.js

@@ -0,0 +1,188 @@
+/**
+ * TRUI Clarification Response Editing
+ *
+ * Handles editing clarification responses for requirements with multi-line support.
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { debugLogger } = require('./trui-debug');
+const { editMultiLineText } = require('./trui-req-editor');
+
+/**
+ * Edit clarification response for a requirement
+ * @param {Object} requirement - The requirement object with clarification
+ * @param {Function} saveCallback - Function to save the updated requirement
+ */
+async function editClarificationResponse(requirement, saveCallback) {
+  debugLogger.info('Opening clarification editor', { requirementId: requirement.id });
+
+  console.clear();
+  console.log(chalk.cyan('\n📝 Edit Clarification Response\n'));
+  console.log(chalk.gray(`Requirement: ${requirement.title}\n`));
+
+  try {
+    // Extract current clarification response
+    const currentResponse = extractClarificationResponse(requirement);
+    
+    if (!currentResponse) {
+      console.log(chalk.yellow('No clarification response found for this requirement.'));
+      await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...') }]);
+      return;
+    }
+
+    // Show current response
+    console.log(chalk.bold('Current response:'));
+    console.log(chalk.white(currentResponse));
+    console.log();
+
+    // Edit response
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+          { name: '✏️  Edit response', value: 'edit' },
+          { name: '👁️  Preview formatted', value: 'preview' },
+          { name: '❌ Cancel', value: 'cancel' }
+        ]
+      }
+    ]);
+
+    if (action === 'cancel') {
+      console.log(chalk.yellow('\n⚠ Edit cancelled.'));
+      return;
+    }
+
+    if (action === 'preview') {
+      await showFormattedPreview(currentResponse);
+      return;
+    }
+
+    if (action === 'edit') {
+      const editedResponse = await editMultiLineText(
+        currentResponse,
+        'Edit clarification response:',
+        'clarification-response'
+      );
+
+      if (!editedResponse || editedResponse.trim() === currentResponse.trim()) {
+        console.log(chalk.yellow('\n⚠ No changes made.'));
+        return;
+      }
+
+      // Show diff and confirm
+      const { confirmed } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirmed',
+          message: 'Save these changes?',
+          default: true
+        }
+      ]);
+
+      if (confirmed) {
+        // Update the requirement with the new response
+        const updatedRequirement = updateClarificationResponse(requirement, editedResponse);
+        await saveCallback(updatedRequirement);
+        
+        console.log(chalk.green('\n✓ Clarification response updated successfully.'));
+        debugLogger.info('Clarification response updated', { requirementId: requirement.id });
+      } else {
+        console.log(chalk.yellow('\n⚠ Changes discarded.'));
+      }
+    }
+
+  } catch (error) {
+    debugLogger.error('Error editing clarification response', { error: error.message });
+    console.log(chalk.red('\n❌ Error editing clarification response: ' + error.message));
+  }
+}
+
+/**
+ * Extract clarification response from requirement content
+ */
+function extractClarificationResponse(requirement) {
+  const content = requirement.content || requirement.description || '';
+  
+  // Look for clarification response section
+  const clarificationMatch = content.match(/##\s*Clarification\s*Response\s*\n([\s\S]*?)(?=\n##|\n---|$)/i);
+  if (clarificationMatch) {
+    return clarificationMatch[1].trim();
+  }
+  
+  // Look for response section
+  const responseMatch = content.match(/###\s*Response\s*\n([\s\S]*?)(?=\n###|\n##|\n---|$)/i);
+  if (responseMatch) {
+    return responseMatch[1].trim();
+  }
+  
+  return null;
+}
+
+/**
+ * Update clarification response in requirement content
+ */
+function updateClarificationResponse(requirement, newResponse) {
+  const content = requirement.content || requirement.description || '';
+  
+  // Update existing clarification response section
+  if (content.match(/##\s*Clarification\s*Response\s*\n/i)) {
+    const updatedContent = content.replace(
+      /##\s*Clarification\s*Response\s*\n[\s\S]*?(?=\n##|\n---|$)/i,
+      `## Clarification Response\n${newResponse}`
+    );
+    return { ...requirement, content: updatedContent };
+  }
+  
+  // Update existing response section
+  if (content.match(/###\s*Response\s*\n/i)) {
+    const updatedContent = content.replace(
+      /###\s*Response\s*\n[\s\S]*?(?=\n###|\n##|\n---|$)/i,
+      `### Response\n${newResponse}`
+    );
+    return { ...requirement, content: updatedContent };
+  }
+  
+  // Add new clarification response section at the end
+  const updatedContent = content + `\n\n## Clarification Response\n${newResponse}`;
+  return { ...requirement, content: updatedContent };
+}
+
+/**
+ * Show formatted preview of the response
+ */
+async function showFormattedPreview(response) {
+  console.clear();
+  console.log(chalk.bold.cyan('\n📋 Formatted Preview\n'));
+  console.log(chalk.gray('This is how the response will appear when rendered:\n'));
+  
+  // Simple markdown-like formatting for preview
+  const formatted = response
+    .replace(/\*\*(.*?)\*\*/g, chalk.bold('$1'))
+    .replace(/\*(.*?)\*/g, chalk.italic('$1'))
+    .replace(/`(.*?)`/g, chalk.cyan('$1'))
+    .replace(/^### (.*?)$/gm, chalk.bold.underline('$1'))
+    .replace(/^## (.*?)$/gm, chalk.bold.cyan.underline('$1'))
+    .replace(/^# (.*?)$/gm, chalk.bold.white.underline('$1'));
+  
+  console.log(formatted);
+  
+  await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...') }]);
+}
+
+/**
+ * Check if a requirement has a clarification response
+ */
+function hasClarificationResponse(requirement) {
+  return extractClarificationResponse(requirement) !== null;
+}
+
+module.exports = {
+  editClarificationResponse,
+  extractClarificationResponse,
+  updateClarificationResponse,
+  hasClarificationResponse,
+  showFormattedPreview
+};

package/src/utils/trui-feedback.js

@@ -65,6 +65,45 @@ async function showFeedbackSubmission() {
       }
     ]);
 
+    // Screenshot attachment (optional)
+    const { includeScreenshot } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'includeScreenshot',
+        message: 'Include screenshot attachment?',
+        default: false
+      }
+    ]);
+
+    let screenshotPath = null;
+    if (includeScreenshot) {
+      const { screenshot } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'screenshot',
+          message: 'Screenshot file path (or drag & drop):',
+          validate: (input) => {
+            if (!input) return 'Screenshot path is required when including screenshot';
+            const fs = require('fs');
+            const path = require('path');
+            
+            if (!fs.existsSync(input.trim())) {
+              return `File not found: ${input}`;
+            }
+            
+            const ext = path.extname(input.trim()).toLowerCase();
+            const validExts = ['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp'];
+            if (!validExts.includes(ext)) {
+              return `Invalid image format. Supported: ${validExts.join(', ')}`;
+            }
+            
+            return true;
+          }
+        }
+      ]);
+      screenshotPath = screenshot.trim();
+    }
+
     // Confirmation
     const { confirmed } = await inquirer.prompt([
       {
@@ -81,7 +120,7 @@ async function showFeedbackSubmission() {
     }
 
     // Submit feedback
-    await submitFeedback({ category, feedback, email });
+    await submitFeedback({ category, feedback, email, screenshotPath });
 
     console.log(chalk.green('\n✓ Thank you! Your feedback has been submitted.\n'));
 
@@ -114,6 +153,20 @@ async function submitFeedback(feedbackData) {
       version: require('../../../package.json').version || 'unknown'
     };
 
+    // Handle screenshot attachment
+    if (feedbackData.screenshotPath) {
+      const screenshotFileName = `screenshot-${Date.now()}${path.extname(feedbackData.screenshotPath)}`;
+      const screenshotDestPath = path.join(feedbackDir, screenshotFileName);
+      
+      // Copy screenshot to feedback directory
+      fs.copyFileSync(feedbackData.screenshotPath, screenshotDestPath);
+      feedbackWithMeta.screenshotFile = screenshotFileName;
+      debugLogger.info('Screenshot attached', { 
+        source: feedbackData.screenshotPath, 
+        dest: screenshotDestPath 
+      });
+    }
+
     fs.writeFileSync(feedbackFile, JSON.stringify(feedbackWithMeta, null, 2));
     debugLogger.info('Feedback saved locally', { file: feedbackFile });
 

package/src/utils/trui-kiro-integration.js

@@ -0,0 +1,398 @@
+/**
+ * TRUI Kiro Integration Module
+ *
+ * Handles Kiro integration and installation prompts.
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { debugLogger } = require('./trui-debug');
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Check if Kiro is installed
+ */
+async function isKiroInstalled() {
+  try {
+    execSync('kiro --version', { stdio: 'ignore' });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Get Kiro version if installed
+ */
+async function getKiroVersion() {
+  try {
+    const version = execSync('kiro --version', { encoding: 'utf8' }).trim();
+    return version;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Check if Kiro is properly configured
+ */
+async function isKiroConfigured() {
+  try {
+    const configPath = path.join(process.cwd(), '.kiro', 'config.json');
+    return fs.existsSync(configPath);
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Get Kiro configuration
+ */
+async function getKiroConfig() {
+  try {
+    const configPath = path.join(process.cwd(), '.kiro', 'config.json');
+    if (fs.existsSync(configPath)) {
+      const config = fs.readFileSync(configPath, 'utf8');
+      return JSON.parse(config);
+    }
+    return null;
+  } catch (error) {
+    debugLogger.error('Error reading Kiro config', { error: error.message });
+    return null;
+  }
+}
+
+/**
+ * Install Kiro
+ */
+async function installKiro() {
+  console.log(chalk.bold.cyan('\n🚀 Installing Kiro...\n'));
+  
+  try {
+    // Check if npm is available
+    execSync('npm --version', { stdio: 'ignore' });
+    
+    console.log(chalk.gray('Installing Kiro via npm...'));
+    execSync('npm install -g kiro', { stdio: 'inherit' });
+    
+    console.log(chalk.green('\n✅ Kiro installed successfully!'));
+    return true;
+  } catch (error) {
+    console.log(chalk.red('\n❌ Failed to install Kiro: ' + error.message));
+    
+    // Try alternative installation methods
+    const { tryAlternative } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'tryAlternative',
+        message: 'Try alternative installation methods?',
+        default: true
+      }
+    ]);
+    
+    if (tryAlternative) {
+      return await tryAlternativeInstallation();
+    }
+    
+    return false;
+  }
+}
+
+/**
+ * Try alternative installation methods
+ */
+async function tryAlternativeInstallation() {
+  console.log(chalk.yellow('\n📦 Alternative installation options:\n'));
+  
+  const { method } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'method',
+      message: 'Choose installation method:',
+      choices: [
+        { name: 'Download from GitHub releases', value: 'github' },
+        { name: 'Build from source', value: 'source' },
+        { name: 'Use package manager (yarn/pnpm)', value: 'package-manager' },
+        { name: 'Cancel', value: 'cancel' }
+      ]
+    }
+  ]);
+  
+  switch (method) {
+    case 'github':
+      return await installFromGitHub();
+    case 'source':
+      return await installFromSource();
+    case 'package-manager':
+      return await installWithPackageManager();
+    case 'cancel':
+      return false;
+    default:
+      return false;
+  }
+}
+
+/**
+ * Install Kiro from GitHub releases
+ */
+async function installFromGitHub() {
+  console.log(chalk.gray('\nOpening GitHub releases page...'));
+  console.log(chalk.white('Please download the appropriate binary for your system.'));
+  console.log(chalk.cyan('https://github.com/kiro-dev/kiro/releases\n'));
+  
+  const { downloaded } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'downloaded',
+      message: 'Have you downloaded and installed Kiro?',
+      default: false
+    }
+  ]);
+  
+  if (downloaded) {
+    const verified = await verifyKiroInstallation();
+    return verified;
+  }
+  
+  return false;
+}
+
+/**
+ * Install Kiro from source
+ */
+async function installFromSource() {
+  console.log(chalk.gray('\nCloning and building from source...'));
+  
+  try {
+    execSync('git clone https://github.com/kiro-dev/kiro.git /tmp/kiro-build', { stdio: 'inherit' });
+    process.chdir('/tmp/kiro-build');
+    execSync('npm install', { stdio: 'inherit' });
+    execSync('npm run build', { stdio: 'inherit' });
+    execSync('npm install -g .', { stdio: 'inherit' });
+    
+    console.log(chalk.green('\n✅ Kiro built and installed successfully!'));
+    return true;
+  } catch (error) {
+    console.log(chalk.red('\n❌ Failed to build from source: ' + error.message));
+    return false;
+  }
+}
+
+/**
+ * Install Kiro with alternative package manager
+ */
+async function installWithPackageManager() {
+  const { packageManager } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'packageManager',
+      message: 'Choose package manager:',
+      choices: [
+        { name: 'Yarn', value: 'yarn' },
+        { name: 'PNPM', value: 'pnpm' },
+        { name: 'Cancel', value: 'cancel' }
+      ]
+    }
+  ]);
+  
+  if (packageManager === 'cancel') return false;
+  
+  try {
+    console.log(chalk.gray(`Installing Kiro with ${packageManager}...`));
+    execSync(`${packageManager} global add kiro`, { stdio: 'inherit' });
+    console.log(chalk.green('\n✅ Kiro installed successfully!'));
+    return true;
+  } catch (error) {
+    console.log(chalk.red(`\n❌ Failed to install with ${packageManager}: ` + error.message));
+    return false;
+  }
+}
+
+/**
+ * Verify Kiro installation
+ */
+async function verifyKiroInstallation() {
+  const isInstalled = await isKiroInstalled();
+  if (isInstalled) {
+    const version = await getKiroVersion();
+    console.log(chalk.green(`✅ Kiro ${version} is installed!`));
+    return true;
+  } else {
+    console.log(chalk.red('❌ Kiro installation not found.'));
+    return false;
+  }
+}
+
+/**
+ * Configure Kiro for current project
+ */
+async function configureKiro() {
+  console.log(chalk.bold.cyan('\n⚙️  Configuring Kiro...\n'));
+  
+  const { projectName } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'projectName',
+      message: 'Project name:',
+      default: path.basename(process.cwd())
+    }
+  ]);
+  
+  const { provider } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'provider',
+      message: 'Primary AI provider:',
+      choices: [
+        { name: 'Claude (Anthropic)', value: 'claude' },
+        { name: 'GPT (OpenAI)', value: 'gpt' },
+        { name: 'Custom', value: 'custom' }
+      ]
+    }
+  ]);
+  
+  const { autoMode } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'autoMode',
+      message: 'Enable auto-mode?',
+      default: true
+    }
+  ]);
+  
+  // Create .kiro directory and config
+  const kiroDir = path.join(process.cwd(), '.kiro');
+  if (!fs.existsSync(kiroDir)) {
+    fs.mkdirSync(kiroDir, { recursive: true });
+  }
+  
+  const config = {
+    project: projectName,
+    provider,
+    autoMode,
+    version: '1.0.0',
+    createdAt: new Date().toISOString()
+  };
+  
+  fs.writeFileSync(
+    path.join(kiroDir, 'config.json'),
+    JSON.stringify(config, null, 2)
+  );
+  
+  console.log(chalk.green('\n✅ Kiro configured successfully!'));
+  return true;
+}
+
+/**
+ * Show Kiro status
+ */
+async function showKiroStatus() {
+  const isInstalled = await isKiroInstalled();
+  const version = await getKiroVersion();
+  const isConfigured = await isKiroConfigured();
+  const config = await getKiroConfig();
+  
+  console.log(chalk.bold.cyan('\n🔍 Kiro Status\n'));
+  
+  console.log(`Status: ${isInstalled ? chalk.green('Installed') : chalk.red('Not Installed')}`);
+  if (version) {
+    console.log(`Version: ${chalk.white(version)}`);
+  }
+  console.log(`Configured: ${isConfigured ? chalk.green('Yes') : chalk.yellow('No')}`);
+  
+  if (config) {
+    console.log(`Project: ${chalk.white(config.project)}`);
+    console.log(`Provider: ${chalk.white(config.provider)}`);
+    console.log(`Auto-mode: ${config.autoMode ? chalk.green('Enabled') : chalk.red('Disabled')}`);
+  }
+  
+  console.log();
+}
+
+/**
+ * Prompt for Kiro installation if not installed
+ */
+async function promptKiroInstallation() {
+  const isInstalled = await isKiroInstalled();
+  
+  if (isInstalled) {
+    console.log(chalk.green('✅ Kiro is already installed.'));
+    const isConfigured = await isKiroConfigured();
+    if (!isConfigured) {
+      const { shouldConfigure } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'shouldConfigure',
+          message: 'Kiro is installed but not configured. Configure it now?',
+          default: true
+        }
+      ]);
+      
+      if (shouldConfigure) {
+        return await configureKiro();
+      }
+    }
+    return true;
+  }
+  
+  console.log(chalk.yellow('⚠️  Kiro is not installed.'));
+  
+  const { shouldInstall } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'shouldInstall',
+      message: 'Would you like to install Kiro now?',
+      default: true
+    }
+  ]);
+  
+  if (shouldInstall) {
+    const installed = await installKiro();
+    if (installed) {
+      const { shouldConfigure } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'shouldConfigure',
+          message: 'Kiro installed! Configure it for this project?',
+          default: true
+        }
+      ]);
+      
+      if (shouldConfigure) {
+        return await configureKiro();
+      }
+    }
+  }
+  
+  return false;
+}
+
+/**
+ * Get Kiro integration status for display
+ */
+async function getKiroIntegrationStatus() {
+  const isInstalled = await isKiroInstalled();
+  const isConfigured = await isKiroConfigured();
+  
+  return {
+    installed: isInstalled,
+    configured: isConfigured,
+    version: await getKiroVersion(),
+    config: await getKiroConfig()
+  };
+}
+
+module.exports = {
+  isKiroInstalled,
+  getKiroVersion,
+  isKiroConfigured,
+  getKiroConfig,
+  installKiro,
+  configureKiro,
+  showKiroStatus,
+  promptKiroInstallation,
+  getKiroIntegrationStatus,
+  verifyKiroInstallation
+};