vibecodingmachine-cli 2026.2.26-1739 → 2026.3.9-1621

package/src/utils/provider-checker/time-formatter.js

@@ -9,8 +9,9 @@ function formatCheckedAt(checkedAt) {
   const d = new Date(checkedAt);
   if (isNaN(d.getTime())) return checkedAt;
   const months = ['January','February','March','April','May','June','July','August','September','October','November','December'];
-  const timePart = d.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true }).toLowerCase();
-  return `${months[d.getMonth()]} ${d.getDate()}, ${d.getFullYear()} at ${timePart}`;
+  const timePart = d.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true });
+  const tzPart = d.toLocaleTimeString('en-US', { timeZoneName: 'short' }).split(' ').pop().toUpperCase();
+  return `on ${months[d.getMonth()]} ${d.getDate()}, ${d.getFullYear()} at ${timePart} ${tzPart}`;
 }
 
 module.exports = {

package/src/utils/provider-manager.js

@@ -104,7 +104,7 @@ async function showProviderManagerMenu() {
     console.log(chalk.bold.cyan('⚙ ' + t('provider.title') + '\n'));
 
     // Header
-    console.log(chalk.gray('Use ↑↓ to move, Space to toggle, </> to reorder (< down, > up), → to configure, !/1 to check agents, X/ESC to exit\n'));
+    console.log(chalk.gray('Use ↑↓ to move, Space to toggle, </> to reorder (< down, > up), → to configure, ← to go back, !/1 to check agents, X/ESC to exit\n'));
 
     // Display providers
     order.forEach((id, index) => {
@@ -193,11 +193,12 @@ async function showProviderManagerMenu() {
           await saveProviderPreferences({ order, enabled });
           await setProviderCache(Object.fromEntries(installationStatus));
         }
-        // Trigger agents check after returning
+        // Trigger agents check after returning - only check enabled agents
         setTimeout(() => {
           console.clear();
           console.log(chalk.bold.cyan('🔍 Checking agents...\n'));
-          require('../commands/agents-check')().then(() => {
+          const { checkAgents } = require('../commands/agents-check');
+          checkAgents({ enabledOnly: true, enabledAgents: enabled }).then(() => {
             process.exit(0);
           }).catch((err) => {
             console.log(chalk.red('Agents check error: ' + err.message));
@@ -224,6 +225,14 @@ async function showProviderManagerMenu() {
         break;
 
       case 'left':
+        // Go back to previous menu
+        isMenuActive = false;
+        if (dirty) {
+          await saveProviderPreferences({ order, enabled });
+          await setProviderCache(Object.fromEntries(installationStatus));
+        }
+        return;
+
       case '<':
         // Move selected provider down in order
         if (selectedIndex < order.length - 1) {
@@ -236,6 +245,22 @@ async function showProviderManagerMenu() {
         break;
 
       case 'right':
+        // Configure selected provider
+        const selectedId = order[selectedIndex];
+        const def = defMap.get(selectedId);
+        if (def && def.configOptions && def.configOptions.length > 0) {
+          console.log(chalk.cyan(`\nConfiguring ${getAgentDisplayName(selectedId)}...\n`));
+          // Here you would implement configuration logic
+          console.log(chalk.gray('Configuration not yet implemented in CLI'));
+          const inquirer = require('inquirer');
+          await inquirer.prompt([{
+            type: 'input',
+            name: 'continue',
+            message: 'Press Enter to continue...'
+          }]);
+        }
+        break;
+
       case '>':
         // Move selected provider up in order
         if (selectedIndex > 0) {
@@ -254,23 +279,6 @@ async function showProviderManagerMenu() {
         dirty = true;
         break;
 
-      case 'c':
-        // Configure selected provider
-        const selectedId = order[selectedIndex];
-        const def = defMap.get(selectedId);
-        if (def && def.configOptions && def.configOptions.length > 0) {
-          console.log(chalk.cyan(`\nConfiguring ${getAgentDisplayName(selectedId)}...\n`));
-          // Here you would implement configuration logic
-          console.log(chalk.gray('Configuration not yet implemented in CLI'));
-          const inquirer = require('inquirer');
-          await inquirer.prompt([{
-            type: 'input',
-            name: 'continue',
-            message: 'Press Enter to continue...'
-          }]);
-        }
-        break;
-
       default:
         return;
     }

package/src/utils/provider-registry.js

@@ -118,6 +118,14 @@ const PROVIDER_DEFINITIONS = [
     defaultModel: 'opencode-cli',
     estimatedSpeed: 40000
   },
+  {
+    id: 'vscode-copilot-cli',
+    name: 'VS Code Copilot CLI',
+    type: 'direct',
+    category: 'llm',
+    defaultModel: 'copilot-cli',
+    estimatedSpeed: 45000
+  },
   {
     id: 'replit',
     name: 'Replit Agent',
@@ -166,6 +174,7 @@ function getProviderDisplayName(id) {
     'cline': 'ide.agent.cline',
     'claude-code': 'ide.agent.claude.code',
     'opencode': 'ide.agent.opencode',
+    'vscode-copilot-cli': 'ide.agent.vscode.copilot.cli',
     'antigravity': 'ide.agent.antigravity',
     'github-copilot': 'ide.agent.github.copilot',
     'amazon-q': 'ide.agent.amazon.q',
@@ -199,8 +208,8 @@ function mergeProviderPreferences(autoConfig) {
       cleanedOrder.push(id);
     }
     if (enabled[id] === undefined) {
-      // Enable the first provider by default (antigravity)
-      enabled[id] = index === 0;
+      // Default to disabled, not enabled
+      enabled[id] = false;
     }
   });
 
@@ -209,7 +218,30 @@ function mergeProviderPreferences(autoConfig) {
 
 async function getProviderPreferences() {
   const autoConfig = await getAutoConfig();
-  return mergeProviderPreferences(autoConfig);
+  // Directly return providerPreferences from auto config if it exists
+  if (autoConfig.providerPreferences) {
+    const prefs = autoConfig.providerPreferences;
+    // Ensure we never return empty preferences
+    if (!prefs.order || prefs.order.length === 0) {
+      const defaultOrder = getDefaultProviderOrder();
+      const defaultEnabled = {};
+      defaultOrder.forEach((id, index) => {
+        defaultEnabled[id] = false; // Default to disabled, not enabled
+      });
+      // Auto-fix empty preferences
+      await saveProviderPreferences(defaultOrder, defaultEnabled);
+      return { order: defaultOrder, enabled: defaultEnabled };
+    }
+    return prefs;
+  }
+  // If no preferences exist, create default disabled state
+  const defaultOrder = getDefaultProviderOrder();
+  const defaultEnabled = {};
+  defaultOrder.forEach((id, index) => {
+    defaultEnabled[id] = false; // Default to disabled
+  });
+  await saveProviderPreferences(defaultOrder, defaultEnabled);
+  return { order: defaultOrder, enabled: defaultEnabled };
 }
 
 async function saveProviderPreferences(order, enabled) {

package/src/utils/requirements-navigator/index.js

@@ -0,0 +1,94 @@
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { t } = require('vibecodingmachine-core');
+const { buildTreeStructure } = require('./tree-builder');
+const { loadSection, loadVerified, loadClarification } = require('./section-loader');
+const { renderTree, calculateScrollWindow } = require('./tree-renderer');
+const { readKeypress, handleKeypress } = require('./input-handler');
+
+/**
+ * Tree-style requirements navigator
+ */
+async function showRequirementsTree() {
+  console.log(chalk.bold.cyan('\n📋 ' + t('requirements.navigator.title') + '\n'));
+  console.log(chalk.gray(t('requirements.navigator.basic.instructions') + '\n'));
+  console.log(chalk.gray('💡 Press F for feedback - Share your thoughts anytime\n'));
+
+  const tree = {
+    expanded: { root: true },
+    selected: 0,
+    items: []
+  };
+
+  // Build tree structure
+  const buildTree = async () => {
+    await buildTreeStructure(tree);
+  };
+
+  // Load all sections upfront to show counts immediately
+  tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
+  tree.verifyReqs = await loadSection('verify', '✅ Verified by AI screenshot');
+  tree.clarificationReqs = await loadClarification();
+  tree.verifiedReqs = await loadVerified();
+  tree.recycledReqs = await loadSection('recycled', '♻️ Recycled');
+
+  let inTree = true;
+  await buildTree();
+
+  const loaders = { loadSection, loadVerified, loadClarification };
+
+  while (inTree) {
+    console.clear();
+    console.log(chalk.bold.cyan('\n📋 ' + t('requirements.navigator.title') + '\n'));
+    console.log(chalk.gray(t('requirements.navigator.instructions') + '\n'));
+
+    // Safety check: ensure tree.selected is within bounds
+    if (tree.items.length === 0) {
+      console.log(chalk.yellow('No items to display.'));
+      await inquirer.prompt([{
+        type: 'input',
+        name: 'continue',
+        message: `${t('interactive.press.any.key.return')}`
+      }]);
+      inTree = false;
+      continue;
+    }
+
+    if (tree.selected >= tree.items.length) {
+      tree.selected = tree.items.length - 1;
+    }
+
+    if (tree.selected < 0) {
+      tree.selected = 0;
+    }
+
+    // Calculate window for scrolling (show max 20 items at a time)
+    const { startIdx, endIdx } = calculateScrollWindow(tree, 20);
+
+    // Show indicator if there are items above
+    if (startIdx > 0) {
+      console.log(chalk.gray(`  ↑ ${startIdx} more above...`));
+    }
+
+    // Display visible tree items
+    renderTree(tree, startIdx, endIdx);
+
+    // Show indicator if there are items below
+    if (endIdx < tree.items.length) {
+      console.log(chalk.gray(`  ↓ ${tree.items.length - endIdx} more below...`));
+    }
+
+    console.log();
+
+    // Handle input
+    const key = await readKeypress();
+    const result = await handleKeypress(key, tree, loaders, buildTree);
+    inTree = result.inTree;
+  }
+
+  process.stdin.pause();
+}
+
+module.exports = {
+  showRequirementsTree
+};

package/src/utils/requirements-navigator/input-handler.js

@@ -0,0 +1,217 @@
+const readline = require('readline');
+const chalk = require('chalk');
+const { t } = require('vibecodingmachine-core');
+const {
+  confirmAndExit,
+  showRequirementActions,
+  showClarificationActions,
+  handleAddRequirement,
+  deleteRequirement,
+  deleteClarification,
+  permanentlyDeleteRequirement,
+  moveRequirementDown,
+  moveRequirementUp,
+  promoteRequirement,
+  demoteRequirement,
+  moveClarificationToTodo,
+  handleFeedbackSubmission
+} = require('../requirement-actions');
+
+/**
+ * Reads a single keypress from user
+ */
+async function readKeypress() {
+  return new Promise((resolve) => {
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+
+    const handler = (str, key) => {
+      process.stdin.removeListener('keypress', handler);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      resolve(key);
+    };
+
+    process.stdin.on('keypress', handler);
+    process.stdin.resume();
+  });
+}
+
+/**
+ * Handles key input and performs actions
+ */
+async function handleKeypress(key, tree, loaders, buildTree) {
+  const { loadSection, loadVerified, loadClarification } = loaders;
+
+  if (!key) return { inTree: true };
+
+  // Handle key presses
+  if (key.ctrl && key.name === 'c') {
+    // Ctrl+C always exits immediately
+    process.exit(0);
+  } else if (key.name === 'x' || key.name === 'escape') {
+    // X or ESC key - exit CLI with confirmation
+    await confirmAndExit();
+  } else if (key.name === 'left') {
+    const current = tree.items[tree.selected];
+    if (!current) return { inTree: true }; // Safety check
+
+    if (tree.expanded[current.key]) {
+      // Collapse expanded section
+      tree.expanded[current.key] = false;
+      await buildTree();
+    } else if (current.level > 0) {
+      // Go to parent
+      for (let i = tree.selected - 1; i >= 0; i--) {
+        if (tree.items[i].level < current.level) {
+          tree.selected = i;
+          break;
+        }
+      }
+    } else {
+      // At root level, go back to main menu
+      return { inTree: false };
+    }
+  } else if (key.name === 'k' || key.name === 'up') {
+    tree.selected = Math.max(0, tree.selected - 1);
+    await buildTree();
+  } else if (key.name === 'j' || key.name === 'down') {
+    tree.selected = Math.min(tree.items.length - 1, tree.selected + 1);
+    await buildTree();
+  } else if (key.name === 'right' || key.name === 'return' || key.name === 'space') {
+    await handleSelectAction(tree, loaders, buildTree);
+  } else if (key.name === 'f') {
+    // Feedback button ( megaphone 📣 )
+    await handleFeedbackSubmission();
+    await buildTree();
+  } else if (key.name === 'r') {
+    await handleRecycleAction(tree, loaders, buildTree);
+  } else if (key.name === 'u') {
+    const current = tree.items[tree.selected];
+    if (!current) return { inTree: true }; // Safety check
+
+    if (current.type === 'requirement') {
+      await promoteRequirement(current.req, current.sectionKey, tree, loadSection, loadVerified);
+      await buildTree();
+    }
+  } else if (key.name === 'd') {
+    await handleDemoteAction(tree, loaders, buildTree);
+  }
+
+  return { inTree: true };
+}
+
+/**
+ * Handles select/enter action on tree items
+ */
+async function handleSelectAction(tree, loaders, buildTree) {
+  const { loadSection, loadVerified, loadClarification } = loaders;
+  const current = tree.items[tree.selected];
+  if (!current) return; // Safety check
+
+  if (current.type === 'section') {
+    if (!tree.expanded[current.key]) {
+      tree.expanded[current.key] = true;
+      // Load requirements for this section
+      if (current.key === 'todo') {
+        tree.todoReqs = await loadSection(current.key, current.section);
+      } else if (current.key === 'verify') {
+        tree.verifyReqs = await loadSection(current.key, current.section);
+      } else if (current.key === 'verified') {
+        tree.verifiedReqs = await loadVerified();
+      } else if (current.key === 'recycled') {
+        tree.recycledReqs = await loadSection(current.key, current.section);
+      }
+      await buildTree();
+    } else {
+      tree.expanded[current.key] = false;
+      await buildTree();
+    }
+  } else if (current.type === 'requirement') {
+    // Show requirement actions
+    await showRequirementActions(current.req, current.sectionKey, tree);
+    await buildTree();
+  } else if (current.type === 'clarification') {
+    // Show clarification requirement with questions
+    await showClarificationActions(current.req, tree, loadClarification);
+    await buildTree();
+  } else if (current.type === 'verified') {
+    // Show verified item details (read-only)
+    await showVerifiedDetails(current);
+  } else if (current.type === 'add') {
+    // Handle add requirement
+    await handleAddRequirement(current.key);
+    // Reload TODO section
+    tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
+    await buildTree();
+  }
+}
+
+/**
+ * Shows verified requirement details
+ */
+async function showVerifiedDetails(item) {
+  console.clear();
+  console.log(chalk.bold.green(`\n${item.label}\n`));
+  console.log(chalk.gray('(From CHANGELOG.md - read only)'));
+  console.log(chalk.gray(`\n${t('interactive.press.any.key.back')}`));
+  await readKeypress();
+}
+
+/**
+ * Handles recycle action
+ */
+async function handleRecycleAction(tree, loaders, buildTree) {
+  const { loadSection, loadClarification } = loaders;
+  const current = tree.items[tree.selected];
+  if (!current) return; // Safety check
+
+  if (current.type === 'requirement') {
+    await deleteRequirement(current.req, current.sectionKey, tree);
+    // Reload the section that the requirement was deleted from
+    if (current.sectionKey === 'todo') {
+      tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
+    } else if (current.sectionKey === 'verify') {
+      tree.verifyReqs = await loadSection('verify', '✅ Verified by AI screenshot');
+    }
+    await buildTree();
+  } else if (current.type === 'clarification') {
+    await deleteClarification(current.req, tree);
+    tree.clarificationReqs = await loadClarification();
+    await buildTree();
+  } else if (current.type === 'recycled') {
+    await permanentlyDeleteRequirement(current.req, current.sectionKey, tree);
+    tree.recycledReqs = await loadSection('recycled', '♻️ Recycled');
+    await buildTree();
+  }
+}
+
+/**
+ * Handles demote action
+ */
+async function handleDemoteAction(tree, loaders, buildTree) {
+  const { loadSection, loadVerified, loadClarification } = loaders;
+  const current = tree.items[tree.selected];
+  if (!current) return; // Safety check
+
+  if (current.type === 'clarification') {
+    // D on clarification item = Move to TODO
+    await moveClarificationToTodo(current.req, tree);
+    tree.clarificationReqs = await loadClarification();
+    tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
+    await buildTree();
+  } else if (current.type === 'requirement' || current.type === 'verified') {
+    const sectionKey = current.type === 'verified' ? 'verified' : current.sectionKey;
+    const reqTitle = current.type === 'verified' ? current.label : current.req.title;
+    await demoteRequirement(reqTitle, sectionKey, tree, loadSection, loadVerified);
+    await buildTree();
+  }
+}
+
+module.exports = {
+  readKeypress,
+  handleKeypress
+};

package/src/utils/requirements-navigator/section-loader.js

@@ -0,0 +1,188 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { getRequirementsPath, getVibeCodingMachineDir, checkVibeCodingMachineExists } = require('vibecodingmachine-core');
+const { parseRequirementsFromContent } = require('../requirements-parser');
+
+/**
+ * Load requirements for a section
+ */
+async function loadSection(sectionKey, sectionTitle) {
+  const reqPath = await getRequirementsPath();
+
+  if (!reqPath || !await fs.pathExists(reqPath)) {
+    return [];
+  }
+
+  const content = await fs.readFile(reqPath, 'utf8');
+
+  // Delegate to reusable parser
+  const allReqs = parseRequirementsFromContent(content, sectionKey, sectionTitle);
+
+  // For TODO section, only show primary heading requirements (those marked from '###' titles)
+  if (sectionKey === 'todo') return allReqs.filter(r => r.source === 'heading');
+
+  return allReqs;
+}
+
+/**
+ * Load VERIFIED requirements from CHANGELOG
+ */
+async function loadVerified() {
+  const allnightStatus = await checkVibeCodingMachineExists();
+  let changelogPath;
+
+  if (allnightStatus.insideExists) {
+    const allnightDir = await getVibeCodingMachineDir();
+    changelogPath = path.join(path.dirname(allnightDir), 'CHANGELOG.md');
+  } else if (allnightStatus.siblingExists) {
+    changelogPath = path.join(process.cwd(), 'CHANGELOG.md');
+  }
+
+  if (!changelogPath || !await fs.pathExists(changelogPath)) {
+    return [];
+  }
+
+  const content = await fs.readFile(changelogPath, 'utf8');
+  const lines = content.split('\n');
+  const requirements = [];
+  let inVerifiedSection = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Check for Verified Requirements section
+    if (trimmed.includes('## Verified Requirements')) {
+      inVerifiedSection = true;
+      continue;
+    }
+
+    // Exit section if we hit another ## header
+    if (inVerifiedSection && trimmed.startsWith('##') && !trimmed.includes('Verified Requirements')) {
+      break;
+    }
+
+    // Only collect items from within the Verified Requirements section
+    if (inVerifiedSection && trimmed.startsWith('- ') && trimmed.length > 10) {
+      requirements.push(trimmed.substring(2));
+    }
+  }
+
+  return requirements;
+}
+
+/**
+ * Load clarification requirements with questions
+ */
+async function loadClarification() {
+  const reqPath = await getRequirementsPath();
+
+  if (!reqPath || !await fs.pathExists(reqPath)) {
+    return [];
+  }
+
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  let inSection = false;
+  const requirements = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Check if we're entering the clarification section
+    if (trimmed.includes('❓ Requirements needing manual feedback')) {
+      inSection = true;
+      continue;
+    }
+
+    // Check if we're leaving the section (hit another ## section)
+    if (inSection && trimmed.startsWith('##') && !trimmed.startsWith('###')) {
+      break;
+    }
+
+    // Read requirements in new format (### header)
+    if (inSection && trimmed.startsWith('###')) {
+      const title = trimmed.replace(/^###\s*/, '').trim();
+
+      // Skip empty titles
+      if (!title || title.length === 0) {
+        continue;
+      }
+
+      const details = [];
+      const questions = [];
+      let pkg = null;
+      let findings = null;
+      let currentQuestion = null;
+
+      // Read package, description, and clarifying questions
+      for (let j = i + 1; j < lines.length; j++) {
+        const nextLine = lines[j].trim();
+
+        // Stop if we hit another requirement or section
+        if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+          break;
+        }
+
+        // Check for PACKAGE line
+        if (nextLine.startsWith('PACKAGE:')) {
+          pkg = nextLine.replace(/^PACKAGE:\s*/, '').trim();
+        }
+        // Check for AI findings
+        else if (nextLine.startsWith('**AI found in codebase:**')) {
+          // Next line will be the findings
+          continue;
+        }
+        else if (nextLine.startsWith('**What went wrong')) {
+          // Description line
+          details.push(nextLine);
+        }
+        else if (nextLine.startsWith('**Clarifying questions:**')) {
+          // Start of questions section
+          continue;
+        }
+        else if (nextLine.match(/^\d+\./)) {
+          // Save previous question if exists
+          if (currentQuestion) {
+            questions.push(currentQuestion);
+          }
+          // This is a new question
+          currentQuestion = { question: nextLine, response: null };
+        }
+        else if (currentQuestion && nextLine && !nextLine.startsWith('PACKAGE:') && !nextLine.startsWith('**')) {
+          // This might be a response to the current question or description/findings
+          if (!findings && !currentQuestion.response && questions.length === 0 && !nextLine.match(/^\d+\./)) {
+            // This is findings content
+            findings = nextLine;
+          } else if (currentQuestion && !currentQuestion.response) {
+            // This is a response to the current question
+            currentQuestion.response = nextLine;
+          } else {
+            // Description line
+            details.push(nextLine);
+          }
+        }
+        else if (nextLine && !nextLine.startsWith('PACKAGE:') && !nextLine.startsWith('**')) {
+          // Description line
+          details.push(nextLine);
+        }
+      }
+
+      // Save last question if exists
+      if (currentQuestion) {
+        questions.push(currentQuestion);
+      }
+
+      requirements.push({ title, details, pkg, questions, findings, lineIndex: i });
+    }
+  }
+
+  return requirements;
+}
+
+module.exports = {
+  loadSection,
+  loadVerified,
+  loadClarification
+};