@nclamvn/vibecode-cli 1.0.0 → 1.0.1

package/bin/vibecode.js

@@ -12,6 +12,11 @@ import {
   statusCommand,
   lockCommand,
   doctorCommand,
+  planCommand,
+  buildCommand,
+  reviewCommand,
+  snapshotCommand,
+  configCommand,
   VERSION
 } from '../src/index.js';
 
@@ -23,7 +28,7 @@ program
   .version(VERSION);
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Commands
+// Phase A Commands - Planning
 // ─────────────────────────────────────────────────────────────────────────────
 
 program
@@ -58,6 +63,50 @@ 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')
+  .option('-a, --auto', 'Auto-build with Claude Code (--dangerously-skip-permissions)')
+  .option('--provider <name>', 'Provider to use: claude-code', 'claude-code')
+  .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);
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Phase C Commands - AI Integration
+// ─────────────────────────────────────────────────────────────────────────────
+
+program
+  .command('config')
+  .description('Manage Vibecode configuration')
+  .option('--show', 'Show current configuration')
+  .option('--provider <name>', 'Set default AI provider')
+  .action(configCommand);
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Parse
 // ─────────────────────────────────────────────────────────────────────────────

package/package.json

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

package/src/commands/build.js

@@ -0,0 +1,470 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Build Command
+// "Claude/LLM là PIPELINE, là KIẾN TRÚC SƯ"
+// ═══════════════════════════════════════════════════════════════════════════════
+
+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,
+  readSessionFile
+} 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, readMarkdown } from '../utils/files.js';
+import { printBox, printError, printSuccess, printWarning, printNextStep } from '../ui/output.js';
+import {
+  spawnClaudeCode,
+  isClaudeCodeAvailable,
+  buildPromptWithContext,
+  getProviderInfo
+} from '../providers/index.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.auto) {
+      await handleAutoBuild(currentState, projectName, sessionId, sessionPath, specHash, options);
+    } else 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);
+  }
+}
+
+/**
+ * Handle --auto mode: Spawn Claude Code with optimal config
+ * "Contract LOCKED = License to build"
+ */
+async function handleAutoBuild(currentState, projectName, sessionId, sessionPath, specHash, options) {
+  // Check state - must be PLAN_CREATED or BUILD_IN_PROGRESS or REVIEW_FAILED
+  const validStates = [STATES.PLAN_CREATED, STATES.BUILD_IN_PROGRESS, STATES.REVIEW_FAILED];
+  if (!validStates.includes(currentState)) {
+    printError(`Cannot auto-build in state: ${currentState}`);
+    console.log('Run `vibecode plan` first to create execution plan.');
+    process.exit(1);
+  }
+
+  // Check if Claude Code is available
+  const available = await isClaudeCodeAvailable();
+  if (!available) {
+    printError('Claude Code CLI not found.');
+    console.log(chalk.gray('Install with: npm install -g @anthropic-ai/claude-code'));
+    console.log(chalk.gray('Or use manual build: vibecode build --start'));
+    process.exit(1);
+  }
+
+  // Check coder_pack.md exists
+  if (!await sessionFileExists('coder_pack.md')) {
+    printError('coder_pack.md not found. Run `vibecode plan` first.');
+    process.exit(1);
+  }
+
+  // Setup evidence directory
+  const evidencePath = path.join(sessionPath, 'evidence');
+  await ensureDir(evidencePath);
+  await ensureDir(path.join(evidencePath, 'screenshots'));
+  const logPath = path.join(evidencePath, 'build.log');
+
+  // Save build start time
+  const stateData = await loadState();
+  const startTime = new Date().toISOString();
+  stateData.build_started = startTime;
+  stateData.build_provider = 'claude-code';
+  stateData.build_mode = 'auto';
+  await saveState(stateData);
+
+  // Transition to BUILD_IN_PROGRESS if not already
+  if (currentState !== STATES.BUILD_IN_PROGRESS) {
+    await transitionTo(STATES.BUILD_IN_PROGRESS, 'auto_build_started');
+  }
+
+  // Load coder pack
+  const coderPackContent = await readSessionFile('coder_pack.md');
+
+  // Build full prompt with CLAUDE.md injection if exists
+  const fullPrompt = await buildPromptWithContext(coderPackContent, process.cwd());
+
+  // Log start
+  await appendToFile(logPath, `\n${'='.repeat(60)}\n`);
+  await appendToFile(logPath, `AUTO BUILD STARTED: ${startTime}\n`);
+  await appendToFile(logPath, `Provider: Claude Code (--dangerously-skip-permissions)\n`);
+  await appendToFile(logPath, `${'='.repeat(60)}\n\n`);
+
+  // Show starting message
+  const providerInfo = getProviderInfo();
+
+  const content = `🤖 AUTO BUILD
+
+Project: ${projectName}
+Session: ${sessionId}
+Spec Hash: ${specHash}
+
+Provider: ${providerInfo.name}
+Mode: ${providerInfo.mode}
+
+Starting AI build session...
+Contract LOCKED = License to build`;
+
+  console.log();
+  printBox(content, { borderColor: 'magenta' });
+  console.log();
+  console.log(chalk.magenta('─'.repeat(60)));
+  console.log(chalk.magenta('│ CLAUDE CODE OUTPUT'));
+  console.log(chalk.magenta('─'.repeat(60)));
+  console.log();
+
+  // Spawn Claude Code
+  try {
+    const result = await spawnClaudeCode(fullPrompt, {
+      cwd: process.cwd(),
+      logPath: logPath
+    });
+
+    console.log();
+    console.log(chalk.magenta('─'.repeat(60)));
+    console.log();
+
+    // Capture evidence
+    await captureGitDiff(evidencePath);
+
+    const endTime = new Date().toISOString();
+    await appendToFile(logPath, `\n${'='.repeat(60)}\n`);
+    await appendToFile(logPath, `AUTO BUILD COMPLETED: ${endTime}\n`);
+    await appendToFile(logPath, `Exit code: ${result.code}\n`);
+    await appendToFile(logPath, `${'='.repeat(60)}\n`);
+
+    // Check evidence
+    const evidence = await checkEvidence(evidencePath);
+
+    // Generate build report
+    const reportContent = getBuildReportTemplate(
+      projectName,
+      sessionId,
+      specHash,
+      startTime,
+      endTime,
+      evidence
+    );
+    await writeSessionFile('build_report.md', reportContent);
+
+    // Update state
+    stateData.build_completed = endTime;
+    await saveState(stateData);
+
+    if (result.success) {
+      await transitionTo(STATES.BUILD_DONE, 'auto_build_completed');
+
+      const duration = Math.round((new Date(endTime) - new Date(startTime)) / 1000 / 60);
+
+      const successContent = `✅ AUTO BUILD COMPLETED
+
+Project: ${projectName}
+Duration: ${duration} minutes
+Provider: Claude Code
+
+Evidence:
+${evidence.hasDiff ? '  ✅ changes.diff' : '  ⬜ changes.diff'}
+${evidence.hasLog ? '  ✅ build.log' : '  ⬜ build.log'}
+${evidence.screenshots > 0 ? `  ✅ ${evidence.screenshots} screenshots` : '  ⬜ No screenshots'}`;
+
+      printBox(successContent, { borderColor: 'green' });
+      printNextStep('Run `vibecode review` to validate your build');
+
+    } else {
+      printWarning(`Claude Code exited with code: ${result.code}`);
+      console.log(chalk.gray('Check build.log for details.'));
+      console.log(chalk.gray('Run `vibecode build --auto` to retry.'));
+    }
+
+  } catch (error) {
+    await appendToFile(logPath, `\nERROR: ${error.message}\n`);
+    printError(`Auto build failed: ${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/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()}`));
+}