@nclamvn/vibecode-cli 1.1.0 → 2.0.0

package/bin/vibecode.js

@@ -16,6 +16,7 @@ import {
   buildCommand,
   reviewCommand,
   snapshotCommand,
+  configCommand,
   VERSION
 } from '../src/index.js';
 
@@ -77,6 +78,8 @@ program
   .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
@@ -93,6 +96,17 @@ program
   .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.1.0",
+  "version": "2.0.0",
   "description": "Build software with discipline - AI coding with guardrails",
   "main": "src/index.js",
   "type": "module",

package/src/commands/build.js

@@ -1,5 +1,6 @@
 // ═══════════════════════════════════════════════════════════════════════════════
 // VIBECODE CLI - Build Command
+// "Claude/LLM là PIPELINE, là KIẾN TRÚC SƯ"
 // ═══════════════════════════════════════════════════════════════════════════════
 
 import chalk from 'chalk';
@@ -12,14 +13,21 @@ import {
   getCurrentSessionId,
   getCurrentSessionPath,
   writeSessionFile,
-  sessionFileExists
+  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 } from '../utils/files.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);
 
@@ -38,7 +46,9 @@ export async function buildCommand(options = {}) {
     const specHash = await getSpecHash();
 
     // Handle different build modes
-    if (options.start) {
+    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);
@@ -54,6 +64,158 @@ export async function buildCommand(options = {}) {
   }
 }
 
+/**
+ * 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();
 

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/config/constants.js

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

package/src/index.js

@@ -16,4 +16,11 @@ export { buildCommand } from './commands/build.js';
 export { reviewCommand } from './commands/review.js';
 export { snapshotCommand } from './commands/snapshot.js';
 
+// Phase C Commands
+export { configCommand } from './commands/config.js';
+
+// Constants
 export { VERSION, SPEC_HASH, STATES } from './config/constants.js';
+
+// Providers
+export { PROVIDERS, getProvider, getDefaultProvider } from './providers/index.js';

package/src/providers/claude-code.js

@@ -0,0 +1,159 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Claude Code Provider
+// "Claude/LLM là PIPELINE, là KIẾN TRÚC SƯ"
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import { spawn } from 'child_process';
+import path from 'path';
+import { pathExists, appendToFile } from '../utils/files.js';
+
+/**
+ * Claude Code optimal configuration
+ * Contract LOCKED = License to build (không cần hỏi thêm)
+ */
+export const CLAUDE_CODE_CONFIG = {
+  command: 'claude',
+  flags: [
+    '--dangerously-skip-permissions',  // Trust the AI - Contract đã locked
+  ],
+  timeout: 30 * 60 * 1000, // 30 minutes max
+};
+
+/**
+ * Check if Claude Code CLI is available
+ */
+export async function isClaudeCodeAvailable() {
+  return new Promise((resolve) => {
+    const proc = spawn('which', ['claude'], { shell: true });
+    proc.on('close', (code) => {
+      resolve(code === 0);
+    });
+    proc.on('error', () => {
+      resolve(false);
+    });
+  });
+}
+
+/**
+ * Spawn Claude Code with optimal settings
+ *
+ * @param {string} prompt - The coder pack / prompt to send
+ * @param {object} options - Configuration options
+ * @param {string} options.cwd - Working directory
+ * @param {string} options.logPath - Path to write build logs
+ * @param {function} options.onOutput - Callback for output
+ * @returns {Promise<{success: boolean, code: number}>}
+ */
+export async function spawnClaudeCode(prompt, options = {}) {
+  const { cwd, logPath, onOutput } = options;
+  const fs = await import('fs-extra');
+  const os = await import('os');
+
+  // Check if Claude Code is available
+  const available = await isClaudeCodeAvailable();
+  if (!available) {
+    throw new Error('Claude Code CLI not found. Install with: npm install -g @anthropic/claude-code');
+  }
+
+  // Write prompt to temp file to avoid shell escaping issues
+  const tempDir = os.default.tmpdir();
+  const promptFile = path.join(tempDir, `vibecode-prompt-${Date.now()}.md`);
+  await fs.default.writeFile(promptFile, prompt, 'utf-8');
+
+  return new Promise((resolve, reject) => {
+    // Use cat to pipe the prompt file content to claude
+    const command = `cat "${promptFile}" | claude ${CLAUDE_CODE_CONFIG.flags.join(' ')}`;
+
+    // Log the command being run
+    if (logPath) {
+      appendToFile(logPath, `\n[${new Date().toISOString()}] Running: claude with prompt from ${promptFile}\n`);
+    }
+
+    const proc = spawn(command, [], {
+      cwd: cwd || process.cwd(),
+      stdio: 'inherit', // Stream directly to terminal
+      shell: true,
+    });
+
+    let timeoutId = setTimeout(() => {
+      proc.kill();
+      // Cleanup temp file
+      fs.default.remove(promptFile).catch(() => {});
+      reject(new Error('Claude Code process timed out'));
+    }, CLAUDE_CODE_CONFIG.timeout);
+
+    proc.on('close', async (code) => {
+      clearTimeout(timeoutId);
+
+      // Cleanup temp file
+      await fs.default.remove(promptFile).catch(() => {});
+
+      const result = {
+        success: code === 0,
+        code: code || 0,
+        timestamp: new Date().toISOString()
+      };
+
+      if (logPath) {
+        const status = result.success ? 'SUCCESS' : 'FAILED';
+        appendToFile(logPath, `\n[${result.timestamp}] Claude Code ${status} (exit code: ${code})\n`);
+      }
+
+      resolve(result);
+    });
+
+    proc.on('error', async (error) => {
+      clearTimeout(timeoutId);
+      // Cleanup temp file
+      await fs.default.remove(promptFile).catch(() => {});
+
+      if (logPath) {
+        appendToFile(logPath, `\n[${new Date().toISOString()}] ERROR: ${error.message}\n`);
+      }
+      reject(error);
+    });
+  });
+}
+
+/**
+ * Build prompt with optional CLAUDE.md injection
+ *
+ * @param {string} coderPackContent - Content of coder_pack.md
+ * @param {string} projectRoot - Project root directory
+ * @returns {Promise<string>} - Final prompt
+ */
+export async function buildPromptWithContext(coderPackContent, projectRoot) {
+  let fullPrompt = coderPackContent;
+
+  // Check for CLAUDE.md in project root
+  const claudeMdPath = path.join(projectRoot, 'CLAUDE.md');
+  if (await pathExists(claudeMdPath)) {
+    const fs = await import('fs-extra');
+    const claudeMd = await fs.default.readFile(claudeMdPath, 'utf-8');
+
+    // Inject CLAUDE.md rules before coder pack
+    fullPrompt = `# PROJECT RULES (from CLAUDE.md)
+
+${claudeMd}
+
+---
+
+# BUILD INSTRUCTIONS
+
+${coderPackContent}`;
+  }
+
+  return fullPrompt;
+}
+
+/**
+ * Get provider info for status display
+ */
+export function getProviderInfo() {
+  return {
+    name: 'Claude Code',
+    command: CLAUDE_CODE_CONFIG.command,
+    mode: '--dangerously-skip-permissions',
+    description: 'AI coding with guardrails disabled (contract-approved)'
+  };
+}

package/src/providers/index.js

@@ -0,0 +1,45 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - AI Provider Manager
+// ═══════════════════════════════════════════════════════════════════════════════
+
+export {
+  spawnClaudeCode,
+  isClaudeCodeAvailable,
+  buildPromptWithContext,
+  getProviderInfo,
+  CLAUDE_CODE_CONFIG
+} from './claude-code.js';
+
+// Future providers:
+// export { callAnthropicAPI } from './anthropic-api.js';
+// export { spawnCursor } from './cursor.js';
+
+/**
+ * Available providers
+ */
+export const PROVIDERS = {
+  'claude-code': {
+    name: 'Claude Code',
+    description: 'Official Claude CLI for coding',
+    available: true
+  },
+  'anthropic-api': {
+    name: 'Anthropic API',
+    description: 'Direct API calls (coming soon)',
+    available: false
+  }
+};
+
+/**
+ * Get provider by name
+ */
+export function getProvider(name) {
+  return PROVIDERS[name] || null;
+}
+
+/**
+ * Get default provider
+ */
+export function getDefaultProvider() {
+  return 'claude-code';
+}