@nclamvn/vibecode-cli 1.0.0 → 1.1.0

package/bin/vibecode.js

@@ -12,6 +12,10 @@ import {
   statusCommand,
   lockCommand,
   doctorCommand,
+  planCommand,
+  buildCommand,
+  reviewCommand,
+  snapshotCommand,
   VERSION
 } from '../src/index.js';
 
@@ -23,7 +27,7 @@ program
   .version(VERSION);
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Commands
+// Phase A Commands - Planning
 // ─────────────────────────────────────────────────────────────────────────────
 
 program
@@ -58,6 +62,37 @@ program
   .description('Check configuration and diagnose issues')
   .action(doctorCommand);
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Phase B Commands - Execution
+// ─────────────────────────────────────────────────────────────────────────────
+
+program
+  .command('plan')
+  .description('Create execution plan from locked contract')
+  .action(planCommand);
+
+program
+  .command('build')
+  .description('Manage build process and capture evidence')
+  .option('-s, --start', 'Start the build process')
+  .option('-c, --complete', 'Mark build as complete')
+  .option('-e, --evidence', 'Capture evidence snapshot')
+  .action(buildCommand);
+
+program
+  .command('review')
+  .description('Review build against acceptance criteria')
+  .option('--skip-manual', 'Skip manual verification prompts')
+  .action(reviewCommand);
+
+program
+  .command('snapshot')
+  .description('Create release snapshot with version bump')
+  .option('--patch', 'Patch version bump (default)')
+  .option('--minor', 'Minor version bump')
+  .option('--major', 'Major version bump')
+  .action(snapshotCommand);
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Parse
 // ─────────────────────────────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nclamvn/vibecode-cli",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Build software with discipline - AI coding with guardrails",
   "main": "src/index.js",
   "type": "module",

package/src/commands/build.js

@@ -0,0 +1,308 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Build Command
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import chalk from 'chalk';
+import ora from 'ora';
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { workspaceExists, getProjectName, loadState, saveState } from '../core/workspace.js';
+import {
+  getCurrentSessionId,
+  getCurrentSessionPath,
+  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 { getBuildReportTemplate } from '../config/templates.js';
+import { ensureDir, pathExists, appendToFile } from '../utils/files.js';
+import { printBox, printError, printSuccess, printWarning, printNextStep } from '../ui/output.js';
+
+const execAsync = promisify(exec);
+
+export async function buildCommand(options = {}) {
+  try {
+    // Check workspace
+    if (!await workspaceExists()) {
+      printError('No Vibecode workspace found. Run `vibecode init` first.');
+      process.exit(1);
+    }
+
+    const currentState = await getCurrentState();
+    const projectName = await getProjectName();
+    const sessionId = await getCurrentSessionId();
+    const sessionPath = await getCurrentSessionPath();
+    const specHash = await getSpecHash();
+
+    // Handle different build modes
+    if (options.start) {
+      await handleBuildStart(currentState, projectName, sessionId, sessionPath, specHash);
+    } else if (options.complete) {
+      await handleBuildComplete(currentState, projectName, sessionId, sessionPath, specHash);
+    } else if (options.evidence) {
+      await handleCaptureEvidence(currentState, sessionPath);
+    } else {
+      await handleBuildStatus(currentState, projectName, sessionId, sessionPath, specHash);
+    }
+
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+}
+
+async function handleBuildStart(currentState, projectName, sessionId, sessionPath, specHash) {
+  const spinner = ora('Starting build...').start();
+
+  // Check state
+  if (currentState !== STATES.PLAN_CREATED && currentState !== STATES.REVIEW_FAILED) {
+    spinner.fail();
+    printError(`Cannot start build in state: ${currentState}`);
+    console.log('Run `vibecode plan` first to create execution plan.');
+    process.exit(1);
+  }
+
+  // Create evidence directory
+  const evidencePath = path.join(sessionPath, 'evidence');
+  await ensureDir(evidencePath);
+  await ensureDir(path.join(evidencePath, 'screenshots'));
+
+  // Save build start time
+  const stateData = await loadState();
+  stateData.build_started = new Date().toISOString();
+  await saveState(stateData);
+
+  // Initialize build log
+  const logPath = path.join(evidencePath, 'build.log');
+  await appendToFile(logPath, `=== BUILD STARTED: ${stateData.build_started} ===\n`);
+
+  // Transition state
+  await transitionTo(STATES.BUILD_IN_PROGRESS, 'build_started');
+
+  spinner.succeed('Build started!');
+
+  const content = `🏗️ BUILD IN PROGRESS
+
+Project: ${projectName}
+Session: ${sessionId}
+Spec Hash: ${specHash}
+Started: ${stateData.build_started}
+
+Evidence folder ready:
+  ${evidencePath}/
+  ├── build.log
+  └── screenshots/`;
+
+  console.log();
+  printBox(content, { borderColor: 'yellow' });
+
+  console.log();
+  console.log(chalk.cyan('📝 While building:'));
+  console.log(chalk.gray('   • Follow coder_pack.md instructions'));
+  console.log(chalk.gray('   • Capture evidence with `vibecode build --evidence`'));
+  console.log(chalk.gray('   • Complete with `vibecode build --complete`'));
+
+  printNextStep('Build your deliverables and run `vibecode build --complete` when done');
+}
+
+async function handleBuildComplete(currentState, projectName, sessionId, sessionPath, specHash) {
+  const spinner = ora('Completing build...').start();
+
+  // Check state
+  if (currentState !== STATES.BUILD_IN_PROGRESS) {
+    spinner.fail();
+    printError(`Cannot complete build in state: ${currentState}`);
+    console.log('Run `vibecode build --start` first.');
+    process.exit(1);
+  }
+
+  const stateData = await loadState();
+  const startTime = stateData.build_started;
+  const endTime = new Date().toISOString();
+
+  // Capture final evidence
+  spinner.text = 'Capturing evidence...';
+  const evidencePath = path.join(sessionPath, 'evidence');
+  await captureGitDiff(evidencePath);
+
+  // Append to build log
+  const logPath = path.join(evidencePath, 'build.log');
+  await appendToFile(logPath, `\n=== BUILD COMPLETED: ${endTime} ===`);
+
+  // Check evidence collected
+  const evidence = await checkEvidence(evidencePath);
+
+  // Generate build report
+  spinner.text = 'Generating build report...';
+  const reportContent = getBuildReportTemplate(
+    projectName,
+    sessionId,
+    specHash,
+    startTime,
+    endTime,
+    evidence
+  );
+  await writeSessionFile('build_report.md', reportContent);
+
+  // Save end time
+  stateData.build_completed = endTime;
+  await saveState(stateData);
+
+  // Transition state
+  await transitionTo(STATES.BUILD_DONE, 'build_completed');
+
+  spinner.succeed('Build completed!');
+
+  const duration = Math.round((new Date(endTime) - new Date(startTime)) / 1000 / 60);
+
+  const content = `✅ BUILD COMPLETED
+
+Project: ${projectName}
+Duration: ${duration} minutes
+Evidence collected:
+${evidence.hasDiff ? '  ✅ changes.diff' : '  ⬜ changes.diff'}
+${evidence.hasLog ? '  ✅ build.log' : '  ⬜ build.log'}
+${evidence.screenshots > 0 ? `  ✅ ${evidence.screenshots} screenshots` : '  ⬜ No screenshots'}`;
+
+  console.log();
+  printBox(content, { borderColor: 'green' });
+
+  printNextStep('Run `vibecode review` to validate your build');
+}
+
+async function handleCaptureEvidence(currentState, sessionPath) {
+  const spinner = ora('Capturing evidence...').start();
+
+  if (currentState !== STATES.BUILD_IN_PROGRESS) {
+    spinner.fail();
+    printError('Can only capture evidence during BUILD_IN_PROGRESS state');
+    process.exit(1);
+  }
+
+  const evidencePath = path.join(sessionPath, 'evidence');
+  await ensureDir(evidencePath);
+
+  // Capture git diff
+  await captureGitDiff(evidencePath);
+
+  // Append to build log
+  const timestamp = new Date().toISOString();
+  await appendToFile(
+    path.join(evidencePath, 'build.log'),
+    `\n[${timestamp}] Evidence snapshot captured\n`
+  );
+
+  spinner.succeed('Evidence captured!');
+
+  const evidence = await checkEvidence(evidencePath);
+  console.log();
+  console.log(chalk.cyan('📁 Evidence collected:'));
+  console.log(chalk.gray(`   ${evidence.hasDiff ? '✅' : '⬜'} changes.diff`));
+  console.log(chalk.gray(`   ${evidence.hasLog ? '✅' : '⬜'} build.log`));
+  console.log(chalk.gray(`   ${evidence.screenshots > 0 ? `✅ ${evidence.screenshots}` : '⬜ 0'} screenshots`));
+}
+
+async function handleBuildStatus(currentState, projectName, sessionId, sessionPath, specHash) {
+  if (currentState === STATES.BUILD_IN_PROGRESS) {
+    const stateData = await loadState();
+    const evidencePath = path.join(sessionPath, 'evidence');
+    const evidence = await checkEvidence(evidencePath);
+
+    const elapsed = Math.round((new Date() - new Date(stateData.build_started)) / 1000 / 60);
+
+    const content = `🏗️ BUILD IN PROGRESS
+
+Project: ${projectName}
+Session: ${sessionId}
+Started: ${stateData.build_started}
+Elapsed: ${elapsed} minutes
+
+Evidence:
+${evidence.hasDiff ? '  ✅ changes.diff' : '  ⬜ changes.diff'}
+${evidence.hasLog ? '  ✅ build.log' : '  ⬜ build.log'}
+${evidence.screenshots > 0 ? `  ✅ ${evidence.screenshots} screenshots` : '  ⬜ No screenshots'}`;
+
+    console.log();
+    printBox(content, { borderColor: 'yellow' });
+
+    console.log();
+    console.log(chalk.cyan('Commands:'));
+    console.log(chalk.gray('   --evidence  Capture current git diff'));
+    console.log(chalk.gray('   --complete  Mark build as done'));
+
+  } else if (currentState === STATES.BUILD_DONE) {
+    printSuccess('Build already completed!');
+    printNextStep('Run `vibecode review` to validate');
+
+  } else {
+    printWarning(`Current state: ${currentState}`);
+    console.log('Run `vibecode build --start` to begin building.');
+  }
+}
+
+async function captureGitDiff(evidencePath) {
+  try {
+    const { stdout } = await execAsync('git diff HEAD', { maxBuffer: 10 * 1024 * 1024 });
+    const diffPath = path.join(evidencePath, 'changes.diff');
+
+    if (stdout.trim()) {
+      const fs = await import('fs-extra');
+      await fs.default.writeFile(diffPath, stdout, 'utf-8');
+    } else {
+      // Try staged changes
+      const { stdout: stagedDiff } = await execAsync('git diff --cached', { maxBuffer: 10 * 1024 * 1024 });
+      if (stagedDiff.trim()) {
+        const fs = await import('fs-extra');
+        await fs.default.writeFile(diffPath, stagedDiff, 'utf-8');
+      }
+    }
+  } catch (error) {
+    // Git might not be available, that's okay
+  }
+}
+
+async function checkEvidence(evidencePath) {
+  const result = {
+    hasDiff: false,
+    hasLog: false,
+    screenshots: 0,
+    filesChanged: 0,
+    linesAdded: 0,
+    linesRemoved: 0
+  };
+
+  try {
+    result.hasDiff = await pathExists(path.join(evidencePath, 'changes.diff'));
+    result.hasLog = await pathExists(path.join(evidencePath, 'build.log'));
+
+    const screenshotsPath = path.join(evidencePath, 'screenshots');
+    if (await pathExists(screenshotsPath)) {
+      const fs = await import('fs-extra');
+      const files = await fs.default.readdir(screenshotsPath);
+      result.screenshots = files.filter(f => /\.(png|jpg|jpeg|gif)$/i.test(f)).length;
+    }
+
+    // Parse git diff stats
+    if (result.hasDiff) {
+      try {
+        const { stdout } = await execAsync('git diff --stat HEAD');
+        const statsLine = stdout.split('\n').pop();
+        const match = statsLine?.match(/(\d+) files? changed(?:, (\d+) insertions?)?(?:, (\d+) deletions?)?/);
+        if (match) {
+          result.filesChanged = parseInt(match[1]) || 0;
+          result.linesAdded = parseInt(match[2]) || 0;
+          result.linesRemoved = parseInt(match[3]) || 0;
+        }
+      } catch (e) {
+        // Ignore git errors
+      }
+    }
+  } catch (error) {
+    // Ignore errors
+  }
+
+  return result;
+}

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);
+  }
+}