vibecodingmachine-cli 1.0.0

package/src/commands/ide.js

@@ -0,0 +1,70 @@
+const chalk = require('chalk');
+const path = require('path');
+const ora = require('ora');
+const { AppleScriptManager } = require('@vibecodingmachine/core');
+const { getRepoPath } = require('../utils/config');
+
+const IDES = ['cursor', 'vscode', 'windsurf', 'antigravity', 'cline'];
+
+async function list() {
+  console.log(chalk.bold('\nAvailable IDEs'));
+  for (const ide of IDES) console.log('-', chalk.cyan(ide));
+  console.log();
+}
+
+async function open(ide) {
+  const repoPath = await getRepoPath();
+  if (!repoPath) {
+    console.log(chalk.yellow('No repository path configured'));
+    console.log(chalk.gray('Use'), chalk.cyan('allnightai repo:init'), chalk.gray('or'), chalk.cyan('allnightai repo:set <path>'));
+    process.exit(1);
+  }
+  const ideKey = String(ide || '').toLowerCase();
+  if (!IDES.includes(ideKey)) {
+    console.log(chalk.red('Unknown IDE:'), ide);
+    await list();
+    process.exit(1);
+  }
+
+  const spinner = ora(`Opening ${ideKey}...`).start();
+
+  try {
+    const appleScriptManager = new AppleScriptManager();
+
+    // Use AppleScriptManager to open IDE with repo path
+    await appleScriptManager.openIDE(ideKey, repoPath);
+
+    spinner.succeed(chalk.green(`Opened ${ideKey} at ${path.basename(repoPath)}`));
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to open IDE'));
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function send(message, options) {
+  const ide = (options && options.ide) || 'cline';
+  const spinner = ora(`Sending message to ${ide}...`).start();
+
+  try {
+    const appleScriptManager = new AppleScriptManager();
+
+    // Use AppleScriptManager to send text to IDE AI chat
+    await appleScriptManager.sendTextToIDE(ide, message);
+
+    spinner.succeed(chalk.green(`Sent message to ${ide} AI chat`));
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to send message'));
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  list,
+  open,
+  send
+};
+
+
+

package/src/commands/repo.js

@@ -0,0 +1,159 @@
+const path = require('path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { getRepoPath, setRepoPath } = require('../utils/config');
+const {
+  checkVibeCodingMachineExists,
+  getHostname,
+  getRequirementsFilename,
+  isComputerNameEnabled
+} = require('@vibecodingmachine/core');
+
+async function setRepo(repoPath) {
+  try {
+    const absolutePath = path.resolve(repoPath);
+
+    if (!await fs.pathExists(absolutePath)) {
+      console.error(chalk.red(`Error: Directory does not exist: ${absolutePath}`));
+      process.exit(1);
+    }
+
+    await setRepoPath(absolutePath);
+    console.log(chalk.green('✓'), `Repository path set to: ${chalk.cyan(absolutePath)}`);
+  } catch (error) {
+    console.error(chalk.red('Error setting repository path:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function getRepo() {
+  try {
+    const repoPath = await getRepoPath();
+
+    if (!repoPath) {
+      console.log(chalk.yellow('No repository path configured'));
+      console.log(chalk.gray('Use'), chalk.cyan('allnightai repo:set <path>'), chalk.gray('to set repository path'));
+      return;
+    }
+
+    console.log(chalk.cyan(repoPath));
+  } catch (error) {
+    console.error(chalk.red('Error getting repository path:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function initRepo() {
+  try {
+    const cwd = process.cwd();
+    const repoName = path.basename(cwd);
+    const insideDir = path.join(cwd, '.vibecodingmachine');
+    const siblingDir = path.join(path.dirname(cwd), `.vibecodingmachine-${repoName}`);
+
+    // Ask user where to create the directory
+    const { location } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'location',
+        message: 'Where would you like to create the VibeCodingMachine directory?',
+        choices: [
+          {
+            name: `Inside this repository (${chalk.cyan('.vibecodingmachine')}) - suggested`,
+            value: 'inside',
+            short: 'Inside repository'
+          },
+          {
+            name: `As a sibling directory (${chalk.cyan(`../.vibecodingmachine-${repoName}`)}) - keeps configs separate from code`,
+            value: 'sibling',
+            short: 'Sibling directory'
+          }
+        ],
+        default: 'inside'
+      }
+    ]);
+
+    const allnightDir = location === 'inside' ? insideDir : siblingDir;
+
+    console.log(chalk.blue('\nInitializing VibeCodingMachine in:'), chalk.cyan(allnightDir));
+
+    await fs.ensureDir(allnightDir);
+    await fs.ensureDir(path.join(allnightDir, 'temp'));
+    await fs.ensureDir(path.join(allnightDir, 'temp', 'screenshots'));
+
+    // Check if computer name is enabled and use appropriate filename
+    const useHostname = await isComputerNameEnabled();
+    const hostname = getHostname();
+    const requirementsFilename = await getRequirementsFilename();
+    const requirementsPath = path.join(allnightDir, requirementsFilename);
+
+    if (!await fs.pathExists(requirementsPath)) {
+      const titleSuffix = useHostname ? ` (${hostname})` : '';
+      const requirementsTemplate = `# VibeCodingMachine Requirements${titleSuffix}
+
+## 🚦 Current Status
+PREPARE
+
+## ⏳ Requirements not yet completed
+
+### Example Requirement
+Add your requirements here...
+
+## ✅ Verified by AI
+
+## ⚠️ Issues Found
+`;
+      await fs.writeFile(requirementsPath, requirementsTemplate);
+      console.log(chalk.green('✓'), `Created ${requirementsFilename}`);
+    }
+
+    const instructionsPath = path.join(allnightDir, 'INSTRUCTIONS.md');
+    if (!await fs.pathExists(instructionsPath)) {
+      const fileNote = useHostname
+        ? `**ALWAYS** use the hostname-specific requirements file:
+- File: \`${requirementsFilename}\`
+- This ensures each computer has its own requirements and progress tracking`
+        : `**Requirements file:** \`REQUIREMENTS.md\``;
+
+      const instructionsTemplate = `# Development Instructions
+
+## Important: Requirements File
+
+${fileNote}
+
+## Guidelines
+- Follow the status progression: PREPARE → ACT → CLEAN UP → VERIFY → DONE
+- Update status in ${requirementsFilename} at each stage
+- Take screenshots during VERIFY phase
+- Mark requirement as DONE when complete
+
+## Code Standards
+- Keep files under 250 lines
+- Follow DRY principles
+- Keep it simple (KISS)
+- No placeholder code
+- Prefix temporary files with TEMP_
+`;
+      await fs.writeFile(instructionsPath, instructionsTemplate);
+      console.log(chalk.green('✓'), 'Created INSTRUCTIONS.md');
+    }
+
+    await setRepoPath(cwd);
+    console.log(chalk.green('✓'), 'Set repository path to current directory');
+
+    console.log(chalk.green('\n✓ VibeCodingMachine initialized successfully!'));
+    console.log(chalk.gray('\nNext steps:'));
+    const configPath = location === 'inside' ? `.vibecodingmachine/${requirementsFilename}` : `../.vibecodingmachine-${repoName}/${requirementsFilename}`;
+    console.log(chalk.gray('  1. Edit'), chalk.cyan(configPath), chalk.gray('with your requirements'));
+    console.log(chalk.gray('  2. Run'), chalk.cyan('allnightai auto:start'), chalk.gray('to begin autonomous development'));
+  } catch (error) {
+    console.error(chalk.red('Error initializing repository:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  setRepo,
+  getRepo,
+  initRepo
+};

package/src/commands/requirements.js

@@ -0,0 +1,161 @@
+const path = require('path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const chokidar = require('chokidar');
+const { getRepoPath } = require('../utils/config');
+const { getRequirementsPath } = require('@vibecodingmachine/core');
+
+async function getReqPathOrExit() {
+  const repoPath = await getRepoPath();
+  if (!repoPath) {
+    console.log(chalk.yellow('No repository path configured'));
+    console.log(chalk.gray('Use'), chalk.cyan('vcm repo:init'), chalk.gray('or'), chalk.cyan('vcm repo:set <path>'));
+    process.exit(1);
+  }
+  // Use getRequirementsPath which handles hostname-specific files
+  const reqPath = await getRequirementsPath(repoPath);
+  return { repoPath, reqPath };
+}
+
+async function list(options) {
+  try {
+    const { reqPath } = await getReqPathOrExit();
+    if (!await fs.pathExists(reqPath)) {
+      console.log(chalk.yellow('No REQUIREMENTS.md found.'));
+      return;
+    }
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+    const filter = options && options.status ? String(options.status).toLowerCase() : null;
+    for (const line of lines) {
+      if (line.startsWith('### ') || line.startsWith('## ')) {
+        if (!filter || line.toLowerCase().includes(filter)) {
+          console.log(line);
+        }
+      }
+    }
+  } catch (error) {
+    console.error(chalk.red('Error listing requirements:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function add(name) {
+  try {
+    const { reqPath } = await getReqPathOrExit();
+    await fs.ensureFile(reqPath);
+    let content = await fs.readFile(reqPath, 'utf8').catch(() => '');
+
+    // Find the TODO section
+    const todoSectionHeader = '## ⏳ Requirements not yet completed';
+    if (!content.includes(todoSectionHeader)) {
+      content += '\n\n' + todoSectionHeader + '\n';
+    }
+
+    // Insert at the top of the TODO section (right after the header)
+    const lines = content.split('\n');
+    const newLines = [];
+    let inserted = false;
+
+    for (let i = 0; i < lines.length; i++) {
+      newLines.push(lines[i]);
+
+      // Insert right after the TODO section header (new header format)
+      if (!inserted && lines[i].includes(todoSectionHeader)) {
+        // Add requirement header
+        newLines.push(`### ${name}`);
+        // Add blank line after requirement
+        newLines.push('');
+        inserted = true;
+      }
+    }
+
+    content = newLines.join('\n');
+    await fs.writeFile(reqPath, content);
+    console.log(chalk.green('✓ Requirement added'));
+  } catch (error) {
+    console.error(chalk.red('Error adding requirement:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function current() {
+  try {
+    const { reqPath } = await getReqPathOrExit();
+    if (!await fs.pathExists(reqPath)) {
+      console.log(chalk.yellow('No REQUIREMENTS.md found.'));
+      return;
+    }
+    const content = await fs.readFile(reqPath, 'utf8');
+    const match = content.match(/## \uD83D\uDEA6 Current Status\n([A-Z_]+)/);
+    console.log(chalk.cyan(match ? match[1] : 'UNKNOWN'));
+  } catch (error) {
+    console.error(chalk.red('Error reading current status:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function next() {
+  try {
+    const { reqPath } = await getReqPathOrExit();
+    if (!await fs.pathExists(reqPath)) {
+      console.log(chalk.yellow('No REQUIREMENTS.md found.'));
+      return;
+    }
+    const content = await fs.readFile(reqPath, 'utf8');
+    const order = ['PREPARE', 'ACT', 'CLEAN UP', 'VERIFY', 'DONE'];
+    const currentMatch = content.match(/## \uD83D\uDEA6 Current Status\n([A-Z_ ]+)/);
+    const current = currentMatch ? currentMatch[1] : 'PREPARE';
+    const idx = Math.min(order.indexOf(current) + 1, order.length - 1);
+    const nextStatus = order[idx];
+    const updated = content.replace(/(## \uD83D\uDEA6 Current Status\n)([A-Z_ ]+)/, `$1${nextStatus}`);
+    await fs.writeFile(reqPath, updated);
+    console.log(chalk.green('✓ Moved to next status:'), chalk.cyan(nextStatus));
+  } catch (error) {
+    console.error(chalk.red('Error updating status:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function edit() {
+  try {
+    const { reqPath } = await getReqPathOrExit();
+    const opener = process.env.EDITOR ? null : 'open';
+    if (process.env.EDITOR) {
+      const { spawn } = require('child_process');
+      const child = spawn(process.env.EDITOR, [reqPath], { stdio: 'inherit' });
+      child.on('exit', (code) => process.exit(code || 0));
+    } else {
+      const { execSync } = require('child_process');
+      execSync(`${opener} ${JSON.stringify(reqPath)}`);
+    }
+  } catch (error) {
+    console.error(chalk.red('Error opening file:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function watch() {
+  try {
+    const { reqPath } = await getReqPathOrExit();
+    console.log(chalk.gray('Watching:'), chalk.cyan(reqPath));
+    chokidar.watch(reqPath, { ignoreInitial: true })
+      .on('change', () => console.log(chalk.green('✓ REQUIREMENTS.md changed')))
+      .on('error', (err) => console.error(chalk.red('Watcher error:'), err.message));
+  } catch (error) {
+    console.error(chalk.red('Error watching requirements:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  list,
+  add,
+  current,
+  next,
+  edit,
+  watch
+};
+
+
+

package/src/commands/setup.js

@@ -0,0 +1,91 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+
+async function setupAlias() {
+    console.log(chalk.bold.cyan('\n🛠️  Setup Vibe Coding Machine Alias\n'));
+
+    // Detect shell
+    const shell = process.env.SHELL;
+    let configFile = '';
+    let shellName = '';
+
+    if (shell.includes('zsh')) {
+        shellName = 'zsh';
+        configFile = path.join(os.homedir(), '.zshrc');
+    } else if (shell.includes('bash')) {
+        shellName = 'bash';
+        configFile = path.join(os.homedir(), '.bashrc');
+        // On Mac, .bash_profile is often used instead of .bashrc for login shells
+        if (process.platform === 'darwin' && !fs.existsSync(configFile)) {
+            const profile = path.join(os.homedir(), '.bash_profile');
+            if (fs.existsSync(profile)) {
+                configFile = profile;
+            }
+        }
+    } else if (shell.includes('fish')) {
+        shellName = 'fish';
+        configFile = path.join(os.homedir(), '.config', 'fish', 'config.fish');
+    } else {
+        console.log(chalk.yellow(`⚠️  Could not detect supported shell (zsh, bash, fish). Current shell: ${shell}`));
+        console.log(chalk.gray('You can manually add the alias:\n'));
+        console.log(chalk.cyan('  alias vcm="vibecodingmachine"'));
+        return;
+    }
+
+    console.log(chalk.gray(`Detected shell: ${chalk.cyan(shellName)}`));
+    console.log(chalk.gray(`Config file:    ${chalk.cyan(configFile)}`));
+
+    // Check if config file exists
+    if (!fs.existsSync(configFile)) {
+        // For fish, ensure directory exists
+        if (shellName === 'fish') {
+            const configDir = path.dirname(configFile);
+            if (!fs.existsSync(configDir)) {
+                fs.mkdirSync(configDir, { recursive: true });
+            }
+        }
+        // Create empty file if it doesn't exist
+        fs.writeFileSync(configFile, '', 'utf8');
+    }
+
+    // Read config file
+    let content = fs.readFileSync(configFile, 'utf8');
+
+    // Check if alias already exists
+    if (content.includes('alias vcm="vibecodingmachine"') || content.includes("alias vcm='vibecodingmachine'")) {
+        console.log(chalk.green('\n✓ "vcm" alias is already configured!'));
+        return;
+    }
+
+    // Confirm with user
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Add 'vcm' alias to ${path.basename(configFile)}?`,
+            default: true
+        }
+    ]);
+
+    if (!confirm) {
+        console.log(chalk.yellow('\nCancelled.'));
+        return;
+    }
+
+    // Add alias
+    const aliasCommand = '\n# Vibe Coding Machine Alias\nalias vcm="vibecodingmachine"\n';
+
+    try {
+        fs.appendFileSync(configFile, aliasCommand, 'utf8');
+        console.log(chalk.green(`\n✓ Added alias to ${path.basename(configFile)}`));
+        console.log(chalk.gray('\nYou may need to restart your terminal or run:'));
+        console.log(chalk.cyan(`  source ${configFile}`));
+    } catch (error) {
+        console.log(chalk.red(`\n✗ Error writing to config file: ${error.message}`));
+    }
+}
+
+module.exports = { setupAlias };

package/src/commands/status.js

@@ -0,0 +1,88 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const chalk = require('chalk');
+const { getRepoPath } = require('../utils/config');
+const { checkAutoModeStatus } = require('../utils/auto-mode');
+const { getRequirementsPath } = require('@vibecodingmachine/core');
+
+/**
+ * Format IDE name for display
+ * @param {string} ide - Internal IDE identifier
+ * @returns {string} Display name for IDE
+ */
+function formatIDEName(ide) {
+  const ideNames = {
+    'cline': 'Cline IDE',
+    'cursor': 'Cursor',
+    'vscode': 'VS Code',
+    'windsurf': 'Windsurf'
+  };
+  return ideNames[ide] || ide;
+}
+
+function formatPath(fullPath) {
+  if (!fullPath) return 'not set';
+  const homeDir = os.homedir();
+  if (fullPath.startsWith(homeDir)) {
+    return fullPath.replace(homeDir, '~');
+  }
+  return fullPath;
+}
+
+async function show() {
+  const repoPath = await getRepoPath();
+  console.log(chalk.bold('\nVibe Coding Machine Status'));
+  console.log(chalk.gray('Repository:'), chalk.cyan(formatPath(repoPath)));
+  const status = await checkAutoModeStatus();
+  console.log(chalk.gray('Auto mode:'), status.running ? chalk.green('running') : chalk.yellow('stopped'));
+  if (status.running) {
+    console.log(chalk.gray('IDE:'), chalk.cyan(formatIDEName(status.ide || 'cline')));
+    console.log(chalk.gray('Chats:'), chalk.cyan(status.chatCount || 0));
+  }
+  console.log();
+}
+
+async function progress() {
+  const repoPath = await getRepoPath();
+  if (!repoPath) {
+    console.log(chalk.yellow('No repository path configured'));
+    return;
+  }
+  // Use getRequirementsPath to get the hostname-specific file
+  const reqPath = await getRequirementsPath(repoPath);
+  if (!reqPath || !await fs.pathExists(reqPath)) {
+    console.log(chalk.yellow('No REQUIREMENTS file found.'));
+    return;
+  }
+  const content = await fs.readFile(reqPath, 'utf8');
+  const current = content.match(/## \uD83D\uDEA6 Current Status\n([A-Z_ ]+)/);
+  console.log(chalk.bold('\nProgress'));
+  console.log(chalk.gray('Current Status:'), chalk.cyan(current ? current[1] : 'UNKNOWN'));
+  console.log();
+}
+
+async function logs(cmd) {
+  const lines = parseInt((cmd && cmd.lines) || '50', 10);
+  const repoPath = await getRepoPath();
+  const defaultLog = path.join(process.cwd(), 'logs', 'security', 'security-2025-10-29.log');
+  const logPath = await fs.pathExists(defaultLog) ? defaultLog : null;
+  console.log(chalk.bold('\nRecent Logs'));
+  if (!logPath) {
+    console.log(chalk.gray('No logs available.'));
+    return;
+  }
+  const content = await fs.readFile(logPath, 'utf8');
+  const out = content.trim().split('\n').slice(-lines).join('\n');
+  console.log(out);
+  console.log();
+}
+
+module.exports = {
+  show,
+  progress,
+  logs
+};
+
+
+

package/src/index.js

@@ -0,0 +1,5 @@
+// Entry point placeholder to satisfy package.json main
+module.exports = {};
+
+
+