@nclamvn/vibecode-cli 1.0.0 → 1.0.1

package/src/commands/plan.js

@@ -0,0 +1,105 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Plan Command
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import chalk from 'chalk';
+import ora from 'ora';
+import path from 'path';
+import { workspaceExists, getProjectName } from '../core/workspace.js';
+import {
+  getCurrentSessionId,
+  getCurrentSessionPath,
+  readSessionFile,
+  writeSessionFile,
+  sessionFileExists
+} from '../core/session.js';
+import { getCurrentState, transitionTo } from '../core/state-machine.js';
+import { getSpecHash } from '../core/contract.js';
+import { STATES } from '../config/constants.js';
+import { getPlanTemplate, getCoderPackTemplate } from '../config/templates.js';
+import { printBox, printError, printSuccess, printNextStep } from '../ui/output.js';
+
+export async function planCommand(options = {}) {
+  const spinner = ora('Creating execution plan...').start();
+
+  try {
+    // Check workspace
+    if (!await workspaceExists()) {
+      spinner.fail();
+      printError('No Vibecode workspace found. Run `vibecode init` first.');
+      process.exit(1);
+    }
+
+    // Check state
+    const currentState = await getCurrentState();
+    if (currentState !== STATES.CONTRACT_LOCKED) {
+      spinner.fail();
+      printError(`Cannot create plan in state: ${currentState}`);
+      console.log('Contract must be locked first. Run `vibecode lock`.');
+      process.exit(1);
+    }
+
+    // Get session info
+    const projectName = await getProjectName();
+    const sessionId = await getCurrentSessionId();
+    const sessionPath = await getCurrentSessionPath();
+    const specHash = await getSpecHash();
+
+    // Read contract and blueprint
+    spinner.text = 'Reading contract...';
+    const contractContent = await readSessionFile('contract.md');
+
+    let blueprintContent = '';
+    if (await sessionFileExists('blueprint.md')) {
+      blueprintContent = await readSessionFile('blueprint.md');
+    }
+
+    // Generate plan
+    spinner.text = 'Generating plan...';
+    const planContent = getPlanTemplate(projectName, sessionId, specHash, contractContent);
+    await writeSessionFile('plan.md', planContent);
+
+    // Generate coder pack
+    spinner.text = 'Generating coder pack...';
+    const coderPackContent = getCoderPackTemplate(
+      projectName,
+      sessionId,
+      specHash,
+      contractContent,
+      blueprintContent
+    );
+    await writeSessionFile('coder_pack.md', coderPackContent);
+
+    // Transition state
+    await transitionTo(STATES.PLAN_CREATED, 'plan_created');
+
+    spinner.succeed('Execution plan created!');
+
+    // Success output
+    const content = `📋 PLAN CREATED
+
+Project: ${projectName}
+Session: ${sessionId}
+Spec Hash: ${specHash}
+
+Files generated:
+• plan.md - Execution steps
+• coder_pack.md - Instructions for AI builder`;
+
+    console.log();
+    printBox(content, { borderColor: 'cyan' });
+
+    console.log();
+    console.log(chalk.cyan('📁 Files:'));
+    console.log(chalk.gray(`   ${sessionPath}/`));
+    console.log(chalk.gray('   ├── plan.md'));
+    console.log(chalk.gray('   └── coder_pack.md'));
+
+    printNextStep('Transfer coder_pack.md to Claude Code and run `vibecode build --start`');
+
+  } catch (error) {
+    spinner.fail('Failed to create plan');
+    printError(error.message);
+    process.exit(1);
+  }
+}

package/src/commands/review.js

@@ -0,0 +1,290 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Review Command
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import chalk from 'chalk';
+import ora from 'ora';
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import inquirer from 'inquirer';
+import { workspaceExists, getProjectName } from '../core/workspace.js';
+import {
+  getCurrentSessionId,
+  getCurrentSessionPath,
+  writeSessionFile,
+  readSessionFile,
+  sessionFileExists
+} from '../core/session.js';
+import { getCurrentState, transitionTo } from '../core/state-machine.js';
+import { getSpecHash } from '../core/contract.js';
+import { STATES } from '../config/constants.js';
+import { getReviewReportTemplate } from '../config/templates.js';
+import { pathExists } from '../utils/files.js';
+import { printBox, printError, printSuccess, printWarning, printNextStep } from '../ui/output.js';
+
+const execAsync = promisify(exec);
+
+export async function reviewCommand(options = {}) {
+  const spinner = ora('Starting review...').start();
+
+  try {
+    // Check workspace
+    if (!await workspaceExists()) {
+      spinner.fail();
+      printError('No Vibecode workspace found. Run `vibecode init` first.');
+      process.exit(1);
+    }
+
+    // Check state
+    const currentState = await getCurrentState();
+    if (currentState !== STATES.BUILD_DONE) {
+      spinner.fail();
+      printError(`Cannot review in state: ${currentState}`);
+      console.log('Complete build first with `vibecode build --complete`.');
+      process.exit(1);
+    }
+
+    const projectName = await getProjectName();
+    const sessionId = await getCurrentSessionId();
+    const sessionPath = await getCurrentSessionPath();
+    const specHash = await getSpecHash();
+
+    spinner.text = 'Running automated checks...';
+
+    // Run automated checks
+    const checks = [];
+
+    // Check 1: Evidence exists
+    const evidencePath = path.join(sessionPath, 'evidence');
+    const hasEvidence = await pathExists(path.join(evidencePath, 'changes.diff')) ||
+                       await pathExists(path.join(evidencePath, 'build.log'));
+    checks.push({
+      name: 'Evidence captured',
+      passed: hasEvidence,
+      message: hasEvidence ? 'Evidence files found' : 'No evidence files found'
+    });
+
+    // Check 2: Build report exists
+    const hasBuildReport = await sessionFileExists('build_report.md');
+    checks.push({
+      name: 'Build report',
+      passed: hasBuildReport,
+      message: hasBuildReport ? 'build_report.md exists' : 'Missing build_report.md'
+    });
+
+    // Check 3: Try npm test if package.json exists
+    const npmTestResult = await runNpmTest();
+    if (npmTestResult.ran) {
+      checks.push({
+        name: 'npm test',
+        passed: npmTestResult.passed,
+        message: npmTestResult.message
+      });
+    }
+
+    // Check 4: Try npm run lint if available
+    const lintResult = await runNpmLint();
+    if (lintResult.ran) {
+      checks.push({
+        name: 'npm run lint',
+        passed: lintResult.passed,
+        message: lintResult.message
+      });
+    }
+
+    // Check 5: Git status clean (no uncommitted changes)
+    const gitStatus = await checkGitStatus();
+    checks.push({
+      name: 'Git status',
+      passed: gitStatus.clean,
+      message: gitStatus.message
+    });
+
+    spinner.stop();
+
+    // Display automated check results
+    console.log();
+    console.log(chalk.cyan('📋 Automated Checks:'));
+    console.log(chalk.gray('─'.repeat(50)));
+
+    for (const check of checks) {
+      const icon = check.passed ? chalk.green('✅') : chalk.red('❌');
+      console.log(`  ${icon} ${check.name}: ${chalk.gray(check.message)}`);
+    }
+
+    console.log(chalk.gray('─'.repeat(50)));
+
+    // If skip-manual flag, auto-determine result
+    if (options.skipManual) {
+      const allPassed = checks.every(c => c.passed);
+      await finalizeReview(allPassed, checks, projectName, sessionId, specHash);
+      return;
+    }
+
+    // Manual checklist
+    console.log();
+    console.log(chalk.cyan('📝 Manual Verification:'));
+
+    // Read contract for acceptance criteria
+    let acceptanceCriteria = [];
+    if (await sessionFileExists('contract.md')) {
+      const contract = await readSessionFile('contract.md');
+      const match = contract.match(/## ✔️ Acceptance Criteria[\s\S]*?(?=\n---|\n##|$)/);
+      if (match) {
+        const criteriaText = match[0];
+        const criteriaLines = criteriaText.match(/- \[[ x]\] .+/g) || [];
+        acceptanceCriteria = criteriaLines.map(line => line.replace(/- \[[ x]\] /, ''));
+      }
+    }
+
+    if (acceptanceCriteria.length > 0) {
+      console.log(chalk.gray('\nVerify each acceptance criterion from the contract:\n'));
+
+      const { verified } = await inquirer.prompt([
+        {
+          type: 'checkbox',
+          name: 'verified',
+          message: 'Check all criteria that are met:',
+          choices: acceptanceCriteria.map(c => ({ name: c, checked: false }))
+        }
+      ]);
+
+      const allCriteriaMet = verified.length === acceptanceCriteria.length;
+
+      checks.push({
+        name: 'Acceptance criteria',
+        passed: allCriteriaMet,
+        message: `${verified.length}/${acceptanceCriteria.length} criteria verified`
+      });
+    }
+
+    // Final confirmation
+    console.log();
+    const { approve } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'approve',
+        message: 'Do you approve this build for release?',
+        default: false
+      }
+    ]);
+
+    const allPassed = approve && checks.every(c => c.passed);
+    await finalizeReview(allPassed, checks, projectName, sessionId, specHash);
+
+  } catch (error) {
+    spinner.fail('Review failed');
+    printError(error.message);
+    process.exit(1);
+  }
+}
+
+async function finalizeReview(passed, checks, projectName, sessionId, specHash) {
+  const spinner = ora('Generating review report...').start();
+
+  // Generate report
+  const reportContent = getReviewReportTemplate(
+    projectName,
+    sessionId,
+    specHash,
+    checks,
+    passed
+  );
+
+  await writeSessionFile('review_report.md', reportContent);
+
+  // Transition state
+  if (passed) {
+    await transitionTo(STATES.REVIEW_PASSED, 'review_passed');
+    spinner.succeed('Review PASSED!');
+
+    const content = `✅ REVIEW PASSED
+
+Project: ${projectName}
+Spec Hash: ${specHash}
+
+All checks passed!
+Ready for release.`;
+
+    console.log();
+    printBox(content, { borderColor: 'green' });
+    printNextStep('Run `vibecode snapshot` to create release');
+
+  } else {
+    await transitionTo(STATES.REVIEW_FAILED, 'review_failed');
+    spinner.warn('Review FAILED');
+
+    const failedChecks = checks.filter(c => !c.passed);
+
+    const content = `❌ REVIEW FAILED
+
+Project: ${projectName}
+Spec Hash: ${specHash}
+
+Failed checks:
+${failedChecks.map(c => `  • ${c.name}: ${c.message}`).join('\n')}`;
+
+    console.log();
+    printBox(content, { borderColor: 'red' });
+    printNextStep('Fix issues and run `vibecode build --start` to rebuild');
+  }
+}
+
+async function runNpmTest() {
+  try {
+    // Check if package.json exists
+    const packageExists = await pathExists('package.json');
+    if (!packageExists) {
+      return { ran: false };
+    }
+
+    // Check if test script exists
+    const fs = await import('fs-extra');
+    const pkg = await fs.default.readJson('package.json');
+    if (!pkg.scripts?.test || pkg.scripts.test.includes('no test specified')) {
+      return { ran: false };
+    }
+
+    // Run tests
+    await execAsync('npm test', { timeout: 120000 });
+    return { ran: true, passed: true, message: 'All tests passed' };
+
+  } catch (error) {
+    return { ran: true, passed: false, message: error.message.split('\n')[0] };
+  }
+}
+
+async function runNpmLint() {
+  try {
+    const packageExists = await pathExists('package.json');
+    if (!packageExists) {
+      return { ran: false };
+    }
+
+    const fs = await import('fs-extra');
+    const pkg = await fs.default.readJson('package.json');
+    if (!pkg.scripts?.lint) {
+      return { ran: false };
+    }
+
+    await execAsync('npm run lint', { timeout: 60000 });
+    return { ran: true, passed: true, message: 'No linting errors' };
+
+  } catch (error) {
+    return { ran: true, passed: false, message: 'Linting errors found' };
+  }
+}
+
+async function checkGitStatus() {
+  try {
+    const { stdout } = await execAsync('git status --porcelain');
+    const clean = stdout.trim() === '';
+    return {
+      clean,
+      message: clean ? 'Working tree clean' : 'Uncommitted changes exist'
+    };
+  } catch (error) {
+    return { clean: true, message: 'Git not available' };
+  }
+}

package/src/commands/snapshot.js

@@ -0,0 +1,252 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Snapshot Command
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import chalk from 'chalk';
+import ora from 'ora';
+import path from 'path';
+import inquirer from 'inquirer';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { workspaceExists, getProjectName, loadState, saveState } from '../core/workspace.js';
+import {
+  getCurrentSessionId,
+  getCurrentSessionPath,
+  writeSessionFile,
+  getSessionFilesStatus
+} from '../core/session.js';
+import { getCurrentState, transitionTo } from '../core/state-machine.js';
+import { getSpecHash } from '../core/contract.js';
+import { STATES } from '../config/constants.js';
+import { getManifestTemplate } from '../config/templates.js';
+import { pathExists, readJson, writeJson, appendToFile } from '../utils/files.js';
+import { printBox, printError, printSuccess, printWarning, printNextStep } from '../ui/output.js';
+
+const execAsync = promisify(exec);
+
+export async function snapshotCommand(options = {}) {
+  try {
+    // Check workspace
+    if (!await workspaceExists()) {
+      printError('No Vibecode workspace found. Run `vibecode init` first.');
+      process.exit(1);
+    }
+
+    // Check state
+    const currentState = await getCurrentState();
+    if (currentState !== STATES.REVIEW_PASSED) {
+      printError(`Cannot create snapshot in state: ${currentState}`);
+      console.log('Review must pass first. Run `vibecode review`.');
+      process.exit(1);
+    }
+
+    const projectName = await getProjectName();
+    const sessionId = await getCurrentSessionId();
+    const sessionPath = await getCurrentSessionPath();
+    const specHash = await getSpecHash();
+
+    // Determine version bump
+    let versionBump = options.major ? 'major' : options.minor ? 'minor' : options.patch ? 'patch' : null;
+
+    if (!versionBump) {
+      const { bump } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'bump',
+          message: 'What type of release is this?',
+          choices: [
+            { name: 'patch (bug fixes)', value: 'patch' },
+            { name: 'minor (new features)', value: 'minor' },
+            { name: 'major (breaking changes)', value: 'major' }
+          ],
+          default: 'patch'
+        }
+      ]);
+      versionBump = bump;
+    }
+
+    const spinner = ora('Creating snapshot...').start();
+
+    // Get current version and calculate new version
+    let currentVersion = '0.0.0';
+    let newVersion = '0.0.1';
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+
+    if (await pathExists(packageJsonPath)) {
+      const pkg = await readJson(packageJsonPath);
+      currentVersion = pkg.version || '0.0.0';
+      newVersion = bumpVersion(currentVersion, versionBump);
+
+      // Update package.json
+      spinner.text = 'Updating package.json...';
+      pkg.version = newVersion;
+      await writeJson(packageJsonPath, pkg);
+    }
+
+    // Collect session files
+    spinner.text = 'Collecting files...';
+    const files = await collectSessionFiles(sessionPath);
+
+    // Generate manifest
+    spinner.text = 'Generating manifest...';
+    const manifest = getManifestTemplate(
+      projectName,
+      newVersion,
+      specHash,
+      sessionId,
+      files
+    );
+    await writeSessionFile('manifest.json', JSON.stringify(manifest, null, 2));
+
+    // Update CHANGELOG
+    spinner.text = 'Updating CHANGELOG...';
+    await updateChangelog(newVersion, specHash, projectName);
+
+    // Create git tag if git is available
+    spinner.text = 'Creating git tag...';
+    const gitTagged = await createGitTag(newVersion, specHash);
+
+    // Update state
+    const stateData = await loadState();
+    stateData.shipped_version = newVersion;
+    stateData.shipped_at = new Date().toISOString();
+    await saveState(stateData);
+
+    // Transition state
+    await transitionTo(STATES.SHIPPED, 'snapshot_created');
+
+    spinner.succeed('Snapshot created!');
+
+    // Success output
+    const content = `🚀 SHIPPED!
+
+Project: ${projectName}
+Version: ${currentVersion} → ${newVersion}
+Spec Hash: ${specHash}
+Session: ${sessionId}
+
+Files:
+• manifest.json - Release manifest
+• CHANGELOG.md - Updated
+${gitTagged ? `• Git tag: v${newVersion}` : ''}`;
+
+    console.log();
+    printBox(content, { borderColor: 'green' });
+
+    console.log();
+    console.log(chalk.cyan('📦 Release Summary:'));
+    console.log(chalk.gray(`   Version: ${newVersion}`));
+    console.log(chalk.gray(`   Spec Hash: ${specHash}`));
+    console.log(chalk.gray(`   Files: ${files.length} session files`));
+    if (gitTagged) {
+      console.log(chalk.gray(`   Git Tag: v${newVersion}`));
+    }
+
+    console.log();
+    printSuccess('Your project has been shipped!');
+
+    if (await pathExists(packageJsonPath)) {
+      console.log();
+      console.log(chalk.cyan('📤 To publish:'));
+      console.log(chalk.gray('   npm publish'));
+      console.log(chalk.gray('   # or'));
+      console.log(chalk.gray('   git push && git push --tags'));
+    }
+
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+}
+
+function bumpVersion(version, type) {
+  const parts = version.split('.').map(Number);
+
+  switch (type) {
+    case 'major':
+      return `${parts[0] + 1}.0.0`;
+    case 'minor':
+      return `${parts[0]}.${parts[1] + 1}.0`;
+    case 'patch':
+    default:
+      return `${parts[0]}.${parts[1]}.${parts[2] + 1}`;
+  }
+}
+
+async function collectSessionFiles(sessionPath) {
+  const files = [];
+  const fs = await import('fs-extra');
+
+  const sessionFiles = [
+    'intake.md',
+    'blueprint.md',
+    'contract.md',
+    'plan.md',
+    'coder_pack.md',
+    'build_report.md',
+    'review_report.md'
+  ];
+
+  for (const file of sessionFiles) {
+    const filePath = path.join(sessionPath, file);
+    if (await pathExists(filePath)) {
+      const stat = await fs.default.stat(filePath);
+      files.push({
+        name: file,
+        size: stat.size,
+        modified: stat.mtime.toISOString()
+      });
+    }
+  }
+
+  return files;
+}
+
+async function updateChangelog(version, specHash, projectName) {
+  const changelogPath = path.join(process.cwd(), 'CHANGELOG.md');
+  const timestamp = new Date().toISOString().split('T')[0];
+
+  const newEntry = `
+## [${version}] - ${timestamp}
+
+### Shipped via Vibecode CLI
+- Spec Hash: \`${specHash}\`
+- Project: ${projectName}
+- Generated by vibecode-cli
+
+---
+`;
+
+  if (await pathExists(changelogPath)) {
+    const fs = await import('fs-extra');
+    const content = await fs.default.readFile(changelogPath, 'utf-8');
+
+    // Insert after the header
+    const headerMatch = content.match(/^# .+\n/);
+    if (headerMatch) {
+      const newContent = headerMatch[0] + newEntry + content.slice(headerMatch[0].length);
+      await fs.default.writeFile(changelogPath, newContent, 'utf-8');
+    } else {
+      await fs.default.writeFile(changelogPath, `# Changelog\n${newEntry}${content}`, 'utf-8');
+    }
+  } else {
+    const fs = await import('fs-extra');
+    await fs.default.writeFile(changelogPath, `# Changelog\n${newEntry}`, 'utf-8');
+  }
+}
+
+async function createGitTag(version, specHash) {
+  try {
+    // Check if git is available
+    await execAsync('git status');
+
+    // Create annotated tag
+    const tagMessage = `Release v${version}\n\nSpec Hash: ${specHash}\nGenerated by vibecode-cli`;
+    await execAsync(`git tag -a v${version} -m "${tagMessage}"`);
+
+    return true;
+  } catch (error) {
+    // Git not available or tag failed
+    return false;
+  }
+}

package/src/commands/status.js

@@ -58,7 +58,12 @@ export async function statusCommand(options = {}) {
       console.log(chalk.cyan('📁 Session Files:'));
       console.log(chalk.gray(`   ├── intake.md ${filesStatus.intake ? '✅' : '⬜'}`));
       console.log(chalk.gray(`   ├── blueprint.md ${filesStatus.blueprint ? '✅' : '⬜'}`));
-      console.log(chalk.gray(`   └── contract.md ${filesStatus.contract ? (specHash ? '🔒' : '📝') : '⬜'}`));
+      console.log(chalk.gray(`   ├── contract.md ${filesStatus.contract ? (specHash ? '🔒' : '📝') : '⬜'}`));
+      console.log(chalk.gray(`   ├── plan.md ${filesStatus.plan ? '✅' : '⬜'}`));
+      console.log(chalk.gray(`   ├── coder_pack.md ${filesStatus.coderPack ? '✅' : '⬜'}`));
+      console.log(chalk.gray(`   ├── build_report.md ${filesStatus.buildReport ? '✅' : '⬜'}`));
+      console.log(chalk.gray(`   ├── review_report.md ${filesStatus.reviewReport ? '✅' : '⬜'}`));
+      console.log(chalk.gray(`   └── manifest.json ${filesStatus.manifest ? '✅' : '⬜'}`));
     }
 
     // Next step hint
@@ -67,7 +72,13 @@ export async function statusCommand(options = {}) {
       [STATES.INTAKE_CAPTURED]: 'Create blueprint for your project',
       [STATES.BLUEPRINT_DRAFTED]: 'Create contract with deliverables',
       [STATES.CONTRACT_DRAFTED]: 'Run `vibecode lock` to finalize contract',
-      [STATES.CONTRACT_LOCKED]: 'Contract locked! Ready for build (Phase B)',
+      [STATES.CONTRACT_LOCKED]: 'Run `vibecode plan` to create execution plan',
+      [STATES.PLAN_CREATED]: 'Run `vibecode build --start` to begin building',
+      [STATES.BUILD_IN_PROGRESS]: 'Build in progress. Run `vibecode build --complete` when done',
+      [STATES.BUILD_DONE]: 'Run `vibecode review` to validate your build',
+      [STATES.REVIEW_PASSED]: 'Run `vibecode snapshot` to create release',
+      [STATES.REVIEW_FAILED]: 'Fix issues and run `vibecode build --start` to rebuild',
+      [STATES.SHIPPED]: 'Project shipped! Start a new session with `vibecode start`',
     };
 
     printNextStep(hints[stateData.current_state] || 'Continue with your workflow');