@nclamvn/vibecode-cli 1.1.0 → 1.3.0

package/src/commands/config.js

@@ -0,0 +1,149 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Config Command
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import chalk from 'chalk';
+import path from 'path';
+import { workspaceExists, getWorkspacePath } from '../core/workspace.js';
+import { pathExists, readJson, writeJson } from '../utils/files.js';
+import { PROVIDERS, getDefaultProvider } from '../providers/index.js';
+import { printBox, printError, printSuccess, printInfo } from '../ui/output.js';
+
+const CONFIG_FILE = 'config.json';
+
+/**
+ * Get config file path
+ */
+function getConfigPath() {
+  return path.join(getWorkspacePath(), CONFIG_FILE);
+}
+
+/**
+ * Load config
+ */
+async function loadConfig() {
+  const configPath = getConfigPath();
+  if (await pathExists(configPath)) {
+    return await readJson(configPath);
+  }
+  return getDefaultConfig();
+}
+
+/**
+ * Save config
+ */
+async function saveConfig(config) {
+  const configPath = getConfigPath();
+  await writeJson(configPath, config);
+}
+
+/**
+ * Get default config
+ */
+function getDefaultConfig() {
+  return {
+    provider: 'claude-code',
+    claudeCode: {
+      flags: ['--dangerously-skip-permissions'],
+      timeout: 30 // minutes
+    },
+    autoEvidence: true,
+    verbose: false
+  };
+}
+
+export async function configCommand(options = {}) {
+  try {
+    // Check workspace for set operations
+    if (options.provider || options.set) {
+      if (!await workspaceExists()) {
+        printError('No Vibecode workspace found. Run `vibecode init` first.');
+        process.exit(1);
+      }
+    }
+
+    // Show current config
+    if (options.show || (!options.provider && !options.set)) {
+      await showConfig();
+      return;
+    }
+
+    // Set provider
+    if (options.provider) {
+      await setProvider(options.provider);
+      return;
+    }
+
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+}
+
+async function showConfig() {
+  console.log();
+
+  // Check if workspace exists
+  if (!await workspaceExists()) {
+    // Show default config
+    console.log(chalk.cyan('Default Configuration (no workspace):'));
+    console.log();
+    const defaultConfig = getDefaultConfig();
+    console.log(chalk.gray('Provider: ') + chalk.white(defaultConfig.provider));
+    console.log(chalk.gray('Flags: ') + chalk.white(defaultConfig.claudeCode.flags.join(', ')));
+    console.log(chalk.gray('Timeout: ') + chalk.white(`${defaultConfig.claudeCode.timeout} minutes`));
+    console.log();
+    console.log(chalk.gray('Run `vibecode init` to create a workspace.'));
+    return;
+  }
+
+  const config = await loadConfig();
+
+  const content = `Current Configuration
+
+Provider: ${config.provider}
+Flags: ${config.claudeCode?.flags?.join(', ') || 'none'}
+Timeout: ${config.claudeCode?.timeout || 30} minutes
+Auto Evidence: ${config.autoEvidence ? 'enabled' : 'disabled'}
+Verbose: ${config.verbose ? 'enabled' : 'disabled'}`;
+
+  printBox(content, { borderColor: 'cyan' });
+
+  // Show available providers
+  console.log();
+  console.log(chalk.cyan('Available Providers:'));
+  Object.entries(PROVIDERS).forEach(([key, provider]) => {
+    const status = provider.available ? chalk.green('available') : chalk.gray('coming soon');
+    const current = key === config.provider ? chalk.yellow(' (current)') : '';
+    console.log(chalk.gray(`  • ${key}: ${provider.description} [${status}]${current}`));
+  });
+
+  console.log();
+  console.log(chalk.gray('To change: vibecode config --provider <name>'));
+}
+
+async function setProvider(providerName) {
+  // Validate provider
+  if (!PROVIDERS[providerName]) {
+    printError(`Unknown provider: ${providerName}`);
+    console.log();
+    console.log(chalk.cyan('Available providers:'));
+    Object.keys(PROVIDERS).forEach(key => {
+      console.log(chalk.gray(`  • ${key}`));
+    });
+    process.exit(1);
+  }
+
+  if (!PROVIDERS[providerName].available) {
+    printError(`Provider "${providerName}" is not yet available.`);
+    process.exit(1);
+  }
+
+  // Load and update config
+  const config = await loadConfig();
+  config.provider = providerName;
+  await saveConfig(config);
+
+  printSuccess(`Provider set to: ${providerName}`);
+  console.log(chalk.gray(`Config saved to: ${getConfigPath()}`));
+}

package/src/commands/plan.js

@@ -45,7 +45,7 @@ export async function planCommand(options = {}) {
     const sessionPath = await getCurrentSessionPath();
     const specHash = await getSpecHash();
 
-    // Read contract and blueprint
+    // Read contract, blueprint, and intake
     spinner.text = 'Reading contract...';
     const contractContent = await readSessionFile('contract.md');
 
@@ -54,6 +54,11 @@ export async function planCommand(options = {}) {
       blueprintContent = await readSessionFile('blueprint.md');
     }
 
+    let intakeContent = '';
+    if (await sessionFileExists('intake.md')) {
+      intakeContent = await readSessionFile('intake.md');
+    }
+
     // Generate plan
     spinner.text = 'Generating plan...';
     const planContent = getPlanTemplate(projectName, sessionId, specHash, contractContent);
@@ -66,7 +71,8 @@ export async function planCommand(options = {}) {
       sessionId,
       specHash,
       contractContent,
-      blueprintContent
+      blueprintContent,
+      intakeContent
     );
     await writeSessionFile('coder_pack.md', coderPackContent);
 

package/src/config/constants.js

@@ -3,7 +3,7 @@
 // Spec Hash: 0fe43335f5a325e3279a079ce616c052
 // ═══════════════════════════════════════════════════════════════════════════════
 
-export const VERSION = '1.1.0';
+export const VERSION = '1.0.1';
 export const SPEC_HASH = '0fe43335f5a325e3279a079ce616c052';
 
 // ─────────────────────────────────────────────────────────────────────────────

package/src/config/templates.js

@@ -124,11 +124,39 @@ src/
 }
 
 /**
- * Get contract template
+ * Get contract template with content extracted from intake and blueprint
  */
-export function getContractTemplate(projectName, sessionId) {
+export function getContractTemplate(projectName, sessionId, intakeContent = '', blueprintContent = '') {
   const timestamp = new Date().toISOString();
 
+  // Extract goal from intake (look for "Mô tả dự án" section)
+  let goal = extractSection(intakeContent, '## 🎯 Mô tả dự án', '---') ||
+             extractSection(intakeContent, '## Mô tả dự án', '---') ||
+             '[Define your clear, specific goal here]';
+
+  // Extract tech stack from blueprint
+  let techStack = extractSection(blueprintContent, '## 💻 Tech Stack', '---') || '';
+
+  // Extract architecture from blueprint
+  let architecture = extractSection(blueprintContent, '## 📐 Architecture', '---') || '';
+
+  // Extract file structure from blueprint
+  let fileStructure = extractSection(blueprintContent, '## 📁 File Structure', '---') || '';
+
+  // Generate deliverables from goal and architecture
+  const deliverables = generateDeliverablesFromContent(goal, techStack, architecture);
+
+  // Generate acceptance criteria from deliverables
+  const acceptanceCriteria = generateAcceptanceCriteria(deliverables);
+
+  // Generate in-scope items
+  const inScopeItems = deliverables.map(d => `- [ ] ${d.item}`).join('\n');
+
+  // Generate deliverables table
+  const deliverablesTable = deliverables.map((d, i) =>
+    `| ${i + 1} | ${d.item} | ${d.description} | ⬜ |`
+  ).join('\n');
+
   return `# 📜 CONTRACT: ${projectName}
 
 ## Session: ${sessionId}
@@ -140,22 +168,21 @@ export function getContractTemplate(projectName, sessionId) {
 
 ## 🎯 Goal
 
-[Define your clear, specific goal here]
+${goal.trim()}
 
 ---
 
 ## ✅ In-Scope
 
-- [ ] [Deliverable 1]
-- [ ] [Deliverable 2]
-- [ ] [Deliverable 3]
+${inScopeItems || '- [ ] [Deliverable 1]\n- [ ] [Deliverable 2]\n- [ ] [Deliverable 3]'}
 
 ---
 
 ## ❌ Out-of-Scope
 
-- [What is NOT included]
-- [Explicitly excluded items]
+- Features not mentioned in goal
+- Additional integrations not specified
+- Performance optimization beyond MVP
 
 ---
 
@@ -163,14 +190,13 @@ export function getContractTemplate(projectName, sessionId) {
 
 | # | Item | Description | Status |
 |---|------|-------------|--------|
-| 1 | [Item] | [Description] | ⬜ |
+${deliverablesTable || '| 1 | [Item] | [Description] | ⬜ |'}
 
 ---
 
 ## ✔️ Acceptance Criteria
 
-- [ ] [Criterion 1]
-- [ ] [Criterion 2]
+${acceptanceCriteria || '- [ ] [Criterion 1]\n- [ ] [Criterion 2]'}
 
 ---
 
@@ -178,13 +204,17 @@ export function getContractTemplate(projectName, sessionId) {
 
 | Risk | Mitigation |
 |------|------------|
-| [Risk] | [Mitigation] |
+| Dependencies unavailable | Use alternative packages |
+| Scope creep | Strict contract adherence |
 
 ---
 
 ## 🔙 Rollback Plan
 
-[Define rollback strategy]
+If build fails:
+1. Revert to last stable commit
+2. Review contract requirements
+3. Rebuild with corrections
 
 ---
 
@@ -193,6 +223,91 @@ export function getContractTemplate(projectName, sessionId) {
 `;
 }
 
+/**
+ * Extract a section from markdown content
+ */
+function extractSection(content, startMarker, endMarker) {
+  if (!content) return null;
+
+  const startIndex = content.indexOf(startMarker);
+  if (startIndex === -1) return null;
+
+  const contentStart = startIndex + startMarker.length;
+  const endIndex = content.indexOf(endMarker, contentStart);
+
+  if (endIndex === -1) {
+    return content.substring(contentStart).trim();
+  }
+
+  return content.substring(contentStart, endIndex).trim();
+}
+
+/**
+ * Generate deliverables from content analysis
+ */
+function generateDeliverablesFromContent(goal, techStack, architecture) {
+  const deliverables = [];
+
+  // Parse goal for keywords to generate deliverables
+  const goalLower = goal.toLowerCase();
+
+  // Common patterns
+  if (goalLower.includes('landing page') || goalLower.includes('website')) {
+    deliverables.push({ item: 'Landing Page', description: 'Main landing page with hero section' });
+    deliverables.push({ item: 'Responsive Design', description: 'Mobile-friendly layout' });
+  }
+
+  if (goalLower.includes('cli') || goalLower.includes('command')) {
+    deliverables.push({ item: 'CLI Commands', description: 'Core command implementations' });
+    deliverables.push({ item: 'Help System', description: 'Command help and documentation' });
+  }
+
+  if (goalLower.includes('api') || goalLower.includes('backend')) {
+    deliverables.push({ item: 'API Endpoints', description: 'REST/GraphQL endpoints' });
+    deliverables.push({ item: 'Data Models', description: 'Database models and schemas' });
+  }
+
+  if (goalLower.includes('auth') || goalLower.includes('login')) {
+    deliverables.push({ item: 'Authentication', description: 'User login/logout flow' });
+  }
+
+  if (goalLower.includes('dashboard') || goalLower.includes('admin')) {
+    deliverables.push({ item: 'Dashboard UI', description: 'Admin dashboard interface' });
+  }
+
+  // Always include core deliverables if none detected
+  if (deliverables.length === 0) {
+    deliverables.push({ item: 'Core Implementation', description: 'Main functionality as described' });
+    deliverables.push({ item: 'UI/UX', description: 'User interface implementation' });
+    deliverables.push({ item: 'Documentation', description: 'Usage documentation' });
+  }
+
+  // Add testing if not already included
+  if (!deliverables.some(d => d.item.toLowerCase().includes('test'))) {
+    deliverables.push({ item: 'Testing', description: 'Basic functionality tests' });
+  }
+
+  return deliverables;
+}
+
+/**
+ * Generate acceptance criteria from deliverables
+ */
+function generateAcceptanceCriteria(deliverables) {
+  if (!deliverables || deliverables.length === 0) {
+    return '- [ ] All features work as expected\n- [ ] No console errors\n- [ ] Documentation complete';
+  }
+
+  const criteria = deliverables.map(d =>
+    `- [ ] ${d.item} is complete and functional`
+  );
+
+  criteria.push('- [ ] No console errors or warnings');
+  criteria.push('- [ ] Code is clean and documented');
+
+  return criteria.join('\n');
+}
+
 /**
  * Get plan template
  */
@@ -260,9 +375,13 @@ ${deliverables}
 /**
  * Get coder pack template - instructions for AI coder
  */
-export function getCoderPackTemplate(projectName, sessionId, specHash, contractContent, blueprintContent) {
+export function getCoderPackTemplate(projectName, sessionId, specHash, contractContent, blueprintContent, intakeContent = '') {
   const timestamp = new Date().toISOString();
 
+  // Extract the goal from intake for quick reference
+  const goalMatch = intakeContent.match(/## 🎯 Mô tả dự án\s*([\s\S]*?)(?=---|##|$)/);
+  const projectGoal = goalMatch ? goalMatch[1].trim() : 'See contract for details';
+
   return `# 🏗️ CODER PACK: ${projectName}
 
 ## Session: ${sessionId}
@@ -283,6 +402,12 @@ You are the **Thợ (Builder)**. Your job is to execute the locked contract exac
 
 ---
 
+## 🎯 PROJECT GOAL (Quick Reference)
+
+${projectGoal}
+
+---
+
 ## 📜 CONTRACT (LOCKED)
 
 ${contractContent}
@@ -291,7 +416,13 @@ ${contractContent}
 
 ## 📘 BLUEPRINT REFERENCE
 
-${blueprintContent}
+${blueprintContent || '[No blueprint provided - follow contract specifications]'}
+
+---
+
+## 📥 ORIGINAL INTAKE
+
+${intakeContent || '[No intake provided]'}
 
 ---
 

package/src/core/error-analyzer.js

@@ -0,0 +1,237 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Error Analyzer
+// Intelligent error analysis for iterative builds
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Analyze test results and extract actionable errors
+ * @param {TestResults} testResult - Results from test runner
+ * @returns {AnalyzedError[]}
+ */
+export function analyzeErrors(testResult) {
+  const errors = [];
+
+  for (const test of testResult.tests) {
+    if (!test.passed) {
+      const testErrors = test.errors || [];
+
+      for (const error of testErrors) {
+        errors.push({
+          source: test.name,
+          type: categorizeError(error),
+          file: error.file || null,
+          line: error.line || null,
+          column: error.column || null,
+          message: error.message,
+          suggestion: generateSuggestion(error),
+          priority: calculatePriority(error),
+          raw: error.raw
+        });
+      }
+
+      // If no specific errors but test failed, add generic error
+      if (testErrors.length === 0) {
+        errors.push({
+          source: test.name,
+          type: 'unknown',
+          message: test.error || `${test.name} failed`,
+          suggestion: `Check ${test.name} output for details`,
+          priority: 'medium',
+          raw: test.output
+        });
+      }
+    }
+  }
+
+  // Sort by priority
+  return errors.sort((a, b) => {
+    const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    return (priorityOrder[a.priority] || 2) - (priorityOrder[b.priority] || 2);
+  });
+}
+
+/**
+ * Categorize error type
+ */
+function categorizeError(error) {
+  const message = (error.message || '').toLowerCase();
+  const raw = (error.raw || '').toLowerCase();
+  const combined = message + ' ' + raw;
+
+  if (combined.includes('syntaxerror') || combined.includes('unexpected token')) {
+    return 'syntax';
+  }
+  if (combined.includes('typeerror') || combined.includes('type error') || combined.includes('is not a function')) {
+    return 'type';
+  }
+  if (combined.includes('referenceerror') || combined.includes('is not defined')) {
+    return 'reference';
+  }
+  if (combined.includes('import') || combined.includes('require') || combined.includes('module not found')) {
+    return 'import';
+  }
+  if (combined.includes('eslint') || combined.includes('lint')) {
+    return 'lint';
+  }
+  if (combined.includes('test') || combined.includes('expect') || combined.includes('assert')) {
+    return 'test';
+  }
+  if (combined.includes('typescript') || combined.includes('ts(')) {
+    return 'typescript';
+  }
+  if (combined.includes('build') || combined.includes('compile')) {
+    return 'build';
+  }
+
+  return 'unknown';
+}
+
+/**
+ * Generate fix suggestion based on error type
+ */
+function generateSuggestion(error) {
+  const type = categorizeError(error);
+  const message = error.message || '';
+
+  switch (type) {
+    case 'syntax':
+      return 'Check for missing brackets, semicolons, or typos near the error location';
+
+    case 'type':
+      if (message.includes('undefined')) {
+        return 'Check if the variable/property is properly initialized';
+      }
+      if (message.includes('is not a function')) {
+        return 'Verify the function exists and is properly imported';
+      }
+      return 'Check type compatibility and ensure proper type handling';
+
+    case 'reference':
+      return 'Ensure the variable/function is defined or imported before use';
+
+    case 'import':
+      if (message.includes('module not found')) {
+        return 'Install missing package with npm install or fix import path';
+      }
+      return 'Check import path and ensure the module exports correctly';
+
+    case 'lint':
+      return 'Fix the linting issue as specified in the error message';
+
+    case 'test':
+      return 'Update the implementation to match expected behavior, or fix the test assertion';
+
+    case 'typescript':
+      return 'Fix type errors by adding proper types or type guards';
+
+    case 'build':
+      return 'Check build configuration and dependencies';
+
+    default:
+      return 'Review the error message and fix accordingly';
+  }
+}
+
+/**
+ * Calculate error priority
+ */
+function calculatePriority(error) {
+  const type = categorizeError(error);
+
+  // Critical - blocks everything
+  if (type === 'syntax' || type === 'import') {
+    return 'critical';
+  }
+
+  // High - likely causes cascading failures
+  if (type === 'reference' || type === 'type') {
+    return 'high';
+  }
+
+  // Medium - should be fixed
+  if (type === 'typescript' || type === 'build' || type === 'test') {
+    return 'medium';
+  }
+
+  // Low - nice to fix
+  if (type === 'lint') {
+    return 'low';
+  }
+
+  return 'medium';
+}
+
+/**
+ * Group errors by file for better organization
+ */
+export function groupErrorsByFile(errors) {
+  const grouped = {};
+
+  for (const error of errors) {
+    const file = error.file || 'unknown';
+    if (!grouped[file]) {
+      grouped[file] = [];
+    }
+    grouped[file].push(error);
+  }
+
+  return grouped;
+}
+
+/**
+ * Get unique files with errors
+ */
+export function getAffectedFiles(errors) {
+  const files = new Set();
+  for (const error of errors) {
+    if (error.file) {
+      files.add(error.file);
+    }
+  }
+  return Array.from(files);
+}
+
+/**
+ * Format errors for display
+ */
+export function formatErrors(errors) {
+  const lines = [];
+
+  lines.push(`Found ${errors.length} error(s):`);
+  lines.push('');
+
+  const grouped = groupErrorsByFile(errors);
+
+  for (const [file, fileErrors] of Object.entries(grouped)) {
+    lines.push(`📄 ${file}`);
+    for (const error of fileErrors) {
+      const loc = error.line ? `:${error.line}` : '';
+      const priority = error.priority === 'critical' ? '🔴' :
+                       error.priority === 'high' ? '🟠' :
+                       error.priority === 'medium' ? '🟡' : '🟢';
+      lines.push(`   ${priority} ${error.type}: ${error.message?.substring(0, 60) || 'Unknown error'}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Create a summary of errors for logging
+ */
+export function createErrorSummary(errors) {
+  const byType = {};
+  const byPriority = { critical: 0, high: 0, medium: 0, low: 0 };
+
+  for (const error of errors) {
+    byType[error.type] = (byType[error.type] || 0) + 1;
+    byPriority[error.priority] = (byPriority[error.priority] || 0) + 1;
+  }
+
+  return {
+    total: errors.length,
+    byType,
+    byPriority,
+    files: getAffectedFiles(errors)
+  };
+}