@nclamvn/vibecode-cli 1.0.0

package/src/core/session.js

@@ -0,0 +1,115 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Session Management
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import path from 'path';
+import {
+  getSessionsPath,
+  getSessionPath,
+  loadState,
+  saveState
+} from './workspace.js';
+import { ensureDir, pathExists, writeMarkdown, readMarkdown } from '../utils/files.js';
+import { generateSessionId } from '../utils/hash.js';
+import { getIntakeTemplate, getBlueprintTemplate, getContractTemplate } from '../config/templates.js';
+
+/**
+ * Create new session
+ */
+export async function createSession(projectName) {
+  const sessionId = generateSessionId();
+  const sessionPath = getSessionPath(sessionId);
+
+  // Create session directory
+  await ensureDir(sessionPath);
+  await ensureDir(path.join(sessionPath, 'evidence'));
+
+  // Update state with current session
+  const stateData = await loadState();
+  stateData.current_session = sessionId;
+  await saveState(stateData);
+
+  return sessionId;
+}
+
+/**
+ * Get current session ID
+ */
+export async function getCurrentSessionId() {
+  const stateData = await loadState();
+  return stateData.current_session;
+}
+
+/**
+ * Get current session path
+ */
+export async function getCurrentSessionPath() {
+  const sessionId = await getCurrentSessionId();
+  if (!sessionId) return null;
+  return getSessionPath(sessionId);
+}
+
+/**
+ * Check if file exists in current session
+ */
+export async function sessionFileExists(filename) {
+  const sessionPath = await getCurrentSessionPath();
+  if (!sessionPath) return false;
+  return await pathExists(path.join(sessionPath, filename));
+}
+
+/**
+ * Write file to current session
+ */
+export async function writeSessionFile(filename, content) {
+  const sessionPath = await getCurrentSessionPath();
+  if (!sessionPath) throw new Error('No active session');
+  await writeMarkdown(path.join(sessionPath, filename), content);
+}
+
+/**
+ * Read file from current session
+ */
+export async function readSessionFile(filename) {
+  const sessionPath = await getCurrentSessionPath();
+  if (!sessionPath) throw new Error('No active session');
+  return await readMarkdown(path.join(sessionPath, filename));
+}
+
+/**
+ * Get session files status
+ */
+export async function getSessionFilesStatus() {
+  const sessionPath = await getCurrentSessionPath();
+  if (!sessionPath) return null;
+
+  return {
+    intake: await pathExists(path.join(sessionPath, 'intake.md')),
+    blueprint: await pathExists(path.join(sessionPath, 'blueprint.md')),
+    contract: await pathExists(path.join(sessionPath, 'contract.md'))
+  };
+}
+
+/**
+ * Create intake file from description
+ */
+export async function createIntake(projectName, description, sessionId) {
+  const template = getIntakeTemplate(projectName, description, sessionId);
+  await writeSessionFile('intake.md', template);
+}
+
+/**
+ * Create blueprint file
+ */
+export async function createBlueprint(projectName, sessionId) {
+  const template = getBlueprintTemplate(projectName, sessionId);
+  await writeSessionFile('blueprint.md', template);
+}
+
+/**
+ * Create contract file
+ */
+export async function createContract(projectName, sessionId) {
+  const template = getContractTemplate(projectName, sessionId);
+  await writeSessionFile('contract.md', template);
+}

package/src/core/state-machine.js

@@ -0,0 +1,95 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - State Machine
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import { STATES, TRANSITIONS } from '../config/constants.js';
+import { loadState, saveState, getLogsPath } from './workspace.js';
+import { appendToFile } from '../utils/files.js';
+import path from 'path';
+
+/**
+ * Get current state
+ */
+export async function getCurrentState() {
+  const stateData = await loadState();
+  return stateData.current_state;
+}
+
+/**
+ * Check if transition is valid
+ */
+export function isValidTransition(fromState, toState) {
+  const allowedTransitions = TRANSITIONS[fromState] || [];
+  return allowedTransitions.includes(toState);
+}
+
+/**
+ * Get allowed transitions from current state
+ */
+export function getAllowedTransitions(currentState) {
+  return TRANSITIONS[currentState] || [];
+}
+
+/**
+ * Transition to new state
+ */
+export async function transitionTo(newState, action = 'manual_transition') {
+  const stateData = await loadState();
+  const currentState = stateData.current_state;
+
+  if (!isValidTransition(currentState, newState)) {
+    throw new Error(
+      `Invalid transition: ${currentState} → ${newState}. ` +
+      `Allowed: ${getAllowedTransitions(currentState).join(', ') || 'none'}`
+    );
+  }
+
+  // Update state
+  stateData.current_state = newState;
+  stateData.history.push({
+    state: newState,
+    timestamp: new Date().toISOString(),
+    action: action,
+    from: currentState
+  });
+
+  await saveState(stateData);
+
+  // Log to audit trail
+  await logAudit(`State transition: ${currentState} → ${newState} (${action})`);
+
+  return stateData;
+}
+
+/**
+ * Log to audit file
+ */
+export async function logAudit(message) {
+  const timestamp = new Date().toISOString();
+  const logLine = `[${timestamp}] ${message}`;
+  const logPath = path.join(getLogsPath(), 'audit.log');
+
+  try {
+    await appendToFile(logPath, logLine);
+  } catch (error) {
+    // Silently fail if logs dir doesn't exist yet
+  }
+}
+
+/**
+ * Get state history
+ */
+export async function getStateHistory() {
+  const stateData = await loadState();
+  return stateData.history;
+}
+
+/**
+ * Check if state is at or past a certain point
+ */
+export function isStateAtLeast(currentState, targetState) {
+  const stateOrder = Object.values(STATES);
+  const currentIndex = stateOrder.indexOf(currentState);
+  const targetIndex = stateOrder.indexOf(targetState);
+  return currentIndex >= targetIndex;
+}

package/src/core/workspace.js

@@ -0,0 +1,152 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Workspace Management
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import path from 'path';
+import {
+  WORKSPACE_DIR,
+  CONFIG_FILE,
+  STATE_FILE,
+  SESSIONS_DIR,
+  LIBRARY_DIR,
+  LOGS_DIR,
+  STATES
+} from '../config/constants.js';
+import {
+  pathExists,
+  ensureDir,
+  readJson,
+  writeJson,
+  readYaml,
+  writeYaml,
+  getCurrentDirName
+} from '../utils/files.js';
+
+/**
+ * Get workspace root path
+ */
+export function getWorkspacePath() {
+  return path.join(process.cwd(), WORKSPACE_DIR);
+}
+
+/**
+ * Check if workspace exists
+ */
+export async function workspaceExists() {
+  return await pathExists(getWorkspacePath());
+}
+
+/**
+ * Get config file path
+ */
+export function getConfigPath() {
+  return path.join(getWorkspacePath(), CONFIG_FILE);
+}
+
+/**
+ * Get state file path
+ */
+export function getStatePath() {
+  return path.join(getWorkspacePath(), STATE_FILE);
+}
+
+/**
+ * Get sessions directory path
+ */
+export function getSessionsPath() {
+  return path.join(getWorkspacePath(), SESSIONS_DIR);
+}
+
+/**
+ * Get specific session path
+ */
+export function getSessionPath(sessionId) {
+  return path.join(getSessionsPath(), sessionId);
+}
+
+/**
+ * Get logs directory path
+ */
+export function getLogsPath() {
+  return path.join(getWorkspacePath(), LOGS_DIR);
+}
+
+/**
+ * Create workspace structure
+ */
+export async function createWorkspace() {
+  const workspacePath = getWorkspacePath();
+
+  // Create directories
+  await ensureDir(workspacePath);
+  await ensureDir(path.join(workspacePath, SESSIONS_DIR));
+  await ensureDir(path.join(workspacePath, LIBRARY_DIR));
+  await ensureDir(path.join(workspacePath, LIBRARY_DIR, 'prompts'));
+  await ensureDir(path.join(workspacePath, LOGS_DIR));
+
+  // Create config file
+  const config = {
+    version: '1.0',
+    created: new Date().toISOString(),
+    project: {
+      name: getCurrentDirName(),
+      type: 'auto'
+    },
+    settings: {
+      enforcement: 'strict',
+      auto_backup: true,
+      audit_log: true
+    },
+    provider: {
+      default: 'claude-code'
+    }
+  };
+  await writeYaml(getConfigPath(), config);
+
+  // Create state file
+  const state = {
+    version: '1.0',
+    current_state: STATES.INIT,
+    current_session: null,
+    spec_hash: null,
+    history: [
+      {
+        state: STATES.INIT,
+        timestamp: new Date().toISOString(),
+        action: 'workspace_initialized'
+      }
+    ]
+  };
+  await writeJson(getStatePath(), state);
+
+  return { config, state };
+}
+
+/**
+ * Load config
+ */
+export async function loadConfig() {
+  return await readYaml(getConfigPath());
+}
+
+/**
+ * Load state
+ */
+export async function loadState() {
+  return await readJson(getStatePath());
+}
+
+/**
+ * Save state
+ */
+export async function saveState(state) {
+  await writeJson(getStatePath(), state);
+}
+
+/**
+ * Get project name from config
+ */
+export async function getProjectName() {
+  const config = await loadConfig();
+  return config.project?.name || getCurrentDirName();
+}

package/src/index.js

@@ -0,0 +1,12 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Main Exports
+// Spec Hash: 0fe43335f5a325e3279a079ce616c052
+// ═══════════════════════════════════════════════════════════════════════════════
+
+export { initCommand } from './commands/init.js';
+export { startCommand } from './commands/start.js';
+export { statusCommand } from './commands/status.js';
+export { lockCommand } from './commands/lock.js';
+export { doctorCommand } from './commands/doctor.js';
+
+export { VERSION, SPEC_HASH, STATES } from './config/constants.js';

package/src/ui/branding.js

@@ -0,0 +1,36 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Branding & ASCII Art
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import chalk from 'chalk';
+import { VERSION } from '../config/constants.js';
+
+export const LOGO = `
+██╗   ██╗██╗██████╗ ███████╗ ██████╗ ██████╗ ██████╗ ███████╗
+██║   ██║██║██╔══██╗██╔════╝██╔════╝██╔═══██╗██╔══██╗██╔════╝
+██║   ██║██║██████╔╝█████╗  ██║     ██║   ██║██║  ██║█████╗
+╚██╗ ██╔╝██║██╔══██╗██╔══╝  ██║     ██║   ██║██║  ██║██╔══╝
+ ╚████╔╝ ██║██████╔╝███████╗╚██████╗╚██████╔╝██████╔╝███████╗
+  ╚═══╝  ╚═╝╚═════╝ ╚══════╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝
+`;
+
+export function printLogo() {
+  console.log(chalk.cyan(LOGO));
+  console.log(chalk.gray.italic('                    "Build with Discipline"'));
+  console.log(chalk.gray(`                        Version ${VERSION}`));
+  console.log();
+}
+
+export function printWelcome() {
+  printLogo();
+  console.log(chalk.cyan('🏗️  Chào mừng! Tôi là Kiến trúc sư của bạn.'));
+  console.log();
+  console.log(chalk.white('    Tôi đã thiết kế hàng triệu sản phẩm số.'));
+  console.log(chalk.white('    Tôi sẽ dẫn dắt bạn qua từng bước.'));
+  console.log(chalk.white('    Bạn chỉ cần cho tôi biết MỤC TIÊU.'));
+  console.log();
+}
+
+export function printDivider() {
+  console.log(chalk.gray('─'.repeat(70)));
+}

package/src/ui/output.js

@@ -0,0 +1,96 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Output Formatting
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import chalk from 'chalk';
+import boxen from 'boxen';
+import { PROGRESS_MAP, COLORS } from '../config/constants.js';
+
+/**
+ * Print boxed message
+ */
+export function printBox(content, options = {}) {
+  const defaultOptions = {
+    padding: 1,
+    borderStyle: 'round',
+    borderColor: 'cyan'
+  };
+  console.log(boxen(content, { ...defaultOptions, ...options }));
+}
+
+/**
+ * Print success message
+ */
+export function printSuccess(message) {
+  console.log(chalk.green('✅ ' + message));
+}
+
+/**
+ * Print error message
+ */
+export function printError(message) {
+  console.log(chalk.red('❌ ' + message));
+}
+
+/**
+ * Print warning message
+ */
+export function printWarning(message) {
+  console.log(chalk.yellow('⚠️  ' + message));
+}
+
+/**
+ * Print info message
+ */
+export function printInfo(message) {
+  console.log(chalk.blue('ℹ️  ' + message));
+}
+
+/**
+ * Print progress bar based on state
+ */
+export function printProgress(state) {
+  const progress = PROGRESS_MAP[state] || PROGRESS_MAP.INIT;
+
+  const bar = `  ${progress.intake} INTAKE  ${progress.blueprint} BLUEPRINT  ${progress.contract} CONTRACT  ${progress.build} BUILD  ${progress.ship} SHIP`;
+
+  console.log(chalk.gray('┌─ Progress ─────────────────────────────────────────────────────────┐'));
+  console.log(chalk.white(bar));
+  console.log(chalk.gray('└────────────────────────────────────────────────────────────────────┘'));
+}
+
+/**
+ * Print status info
+ */
+export function printStatus(projectName, state, sessionId, specHash = null) {
+  console.log();
+  console.log(chalk.cyan(`📍 Project: ${chalk.white(projectName)}`));
+  console.log(chalk.cyan(`📊 State: ${chalk.white(state)}`));
+  console.log(chalk.cyan(`📋 Session: ${chalk.gray(sessionId || 'none')}`));
+
+  if (specHash) {
+    console.log(chalk.cyan(`🔒 Spec Hash: ${chalk.green(specHash)}`));
+  } else {
+    console.log(chalk.cyan(`📄 Spec Hash: ${chalk.gray('(not locked)')}`));
+  }
+  console.log();
+}
+
+/**
+ * Print file tree
+ */
+export function printFileTree(files) {
+  console.log(chalk.cyan('📁 Files:'));
+  files.forEach((file, index) => {
+    const prefix = index === files.length - 1 ? '└── ' : '├── ';
+    console.log(chalk.gray(`   ${prefix}${file}`));
+  });
+}
+
+/**
+ * Print next step hint
+ */
+export function printNextStep(message) {
+  console.log();
+  console.log(chalk.yellow(`💡 Next: ${message}`));
+}

package/src/ui/prompts.js

@@ -0,0 +1,120 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// VIBECODE CLI - Interactive Prompts
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+
+/**
+ * Ask for project description
+ */
+export async function askProjectDescription() {
+  const { description } = await inquirer.prompt([
+    {
+      type: 'editor',
+      name: 'description',
+      message: 'Mô tả ý tưởng dự án của bạn (mở editor):',
+      waitForUseInput: false
+    }
+  ]);
+
+  // If editor fails, fall back to input
+  if (!description || description.trim() === '') {
+    const { fallback } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'fallback',
+        message: chalk.cyan('📝 Bạn muốn build gì hôm nay?\n') + chalk.gray('   (Mô tả bằng ngôn ngữ tự nhiên)\n\n   >'),
+      }
+    ]);
+    return fallback;
+  }
+
+  return description;
+}
+
+/**
+ * Simple text input for description
+ */
+export async function askSimpleDescription() {
+  console.log();
+  const { description } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'description',
+      message: chalk.cyan('📝 Bạn muốn build gì hôm nay?'),
+      validate: (input) => {
+        if (input.trim().length < 10) {
+          return 'Vui lòng mô tả chi tiết hơn (ít nhất 10 ký tự)';
+        }
+        return true;
+      }
+    }
+  ]);
+  return description;
+}
+
+/**
+ * Confirm action
+ */
+export async function confirmAction(message) {
+  const { confirm } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: message,
+      default: true
+    }
+  ]);
+  return confirm;
+}
+
+/**
+ * Select from options
+ */
+export async function selectOption(message, choices) {
+  const { selection } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selection',
+      message: message,
+      choices: choices
+    }
+  ]);
+  return selection;
+}
+
+/**
+ * Ask what to do next based on state
+ */
+export async function askNextAction(state) {
+  const actions = {
+    'INIT': [
+      { name: 'Capture intake (mô tả dự án)', value: 'intake' },
+      { name: 'Exit', value: 'exit' }
+    ],
+    'INTAKE_CAPTURED': [
+      { name: 'Create blueprint', value: 'blueprint' },
+      { name: 'View intake', value: 'view_intake' },
+      { name: 'Exit', value: 'exit' }
+    ],
+    'BLUEPRINT_DRAFTED': [
+      { name: 'Create contract', value: 'contract' },
+      { name: 'Edit blueprint', value: 'edit_blueprint' },
+      { name: 'Exit', value: 'exit' }
+    ],
+    'CONTRACT_DRAFTED': [
+      { name: 'Lock contract (vibecode lock)', value: 'lock' },
+      { name: 'Edit contract', value: 'edit_contract' },
+      { name: 'Exit', value: 'exit' }
+    ],
+    'CONTRACT_LOCKED': [
+      { name: 'Ready for build! (Phase B)', value: 'ready' },
+      { name: 'View contract', value: 'view_contract' },
+      { name: 'Exit', value: 'exit' }
+    ]
+  };
+
+  const choices = actions[state] || actions['INIT'];
+  return await selectOption('What would you like to do?', choices);
+}