vibecodingmachine-cli 2026.1.23-1010 → 2026.1.29-1432

package/src/utils/auto-mode-ui.js.bak.blessed

@@ -1,207 +0,0 @@
-const blessed = require('blessed');
-const chalk = require('chalk');
-
-/**
- * Create and display a blessed-based UI for Auto Mode
- * Shows: persistent menu header, status card, and scrolling output
- * @param {object} options - UI configuration
- * @param {string} options.menuContent - Menu content to display in header
- * @param {function} options.onExit - Callback when user presses Ctrl+C or q
- * @returns {object} UI interface with methods to update status and append output
- */
-function createAutoModeUI(options = {}) {
-  const { menuContent = '', onExit } = options;
-
-  // Create screen
-  const screen = blessed.screen({
-    smartCSR: true,
-    title: 'AllNightAI Auto Mode',
-    fullUnicode: true,
-    forceUnicode: true
-  });
-
-  // Clear screen and render immediately
-  screen.clearRegion(0, screen.width, 0, screen.height);
-
-  // Header box (menu) - use fixed height instead of shrink
-  const headerHeight = 11; // Fixed height for header
-  const header = blessed.box({
-    top: 0,
-    left: 0,
-    width: '100%',
-    height: headerHeight,
-    content: menuContent,
-    tags: true,
-    border: {
-      type: 'line'
-    },
-    style: {
-      border: {
-        fg: 'cyan'
-      }
-    }
-  });
-
-  // Status card (purple/magenta border like GUI)
-  const statusCardHeight = 12;
-  const statusCard = blessed.box({
-    top: headerHeight,
-    left: 0,
-    width: '100%',
-    height: statusCardHeight,
-    tags: true,
-    border: {
-      type: 'round'
-    },
-    style: {
-      border: {
-        fg: 'magenta'
-      }
-    },
-    label: ' Auto Mode Status '
-  });
-
-  // Output log (scrollable)
-  const totalHeaderHeight = headerHeight + statusCardHeight;
-  const outputLog = blessed.log({
-    top: totalHeaderHeight,
-    left: 0,
-    width: '100%',
-    height: `100%-${totalHeaderHeight}`,
-    tags: true,
-    border: {
-      type: 'line'
-    },
-    style: {
-      border: {
-        fg: 'green'
-      }
-    },
-    label: ' Aider Output ',
-    scrollable: true,
-    alwaysScroll: true,
-    mouse: true,
-    keys: true,
-    vi: true,
-    scrollbar: {
-      ch: ' ',
-      track: {
-        bg: 'cyan'
-      },
-      style: {
-        inverse: true
-      }
-    }
-  });
-
-  // Append all elements to screen
-  screen.append(header);
-  screen.append(statusCard);
-  screen.append(outputLog);
-
-  // Focus the output log for scrolling
-  outputLog.focus();
-
-  // Key bindings
-  screen.key(['escape', 'q', 'C-c'], () => {
-    if (onExit) {
-      onExit();
-    }
-    screen.destroy();
-    process.exit(0);
-  });
-
-  // Initial render
-  screen.render();
-
-  /**
-   * Update the status card with new status information
-   * @param {object} status - Status object
-   * @param {string} status.requirement - Current requirement
-   * @param {string} status.step - Current step (PREPARE, ACT, CLEAN UP, VERIFY, DONE)
-   * @param {number} status.chatCount - Current chat count
-   * @param {number|null} status.maxChats - Max chats or null for unlimited
-   * @param {number} status.progress - Progress percentage (0-100)
-   */
-  function updateStatus(status) {
-    const {
-      requirement = 'No requirement loaded',
-      step = 'UNKNOWN',
-      chatCount = 0,
-      maxChats = null,
-      progress = 0
-    } = status;
-
-    // Step color mapping
-    const stepColors = {
-      'PREPARE': '{cyan-fg}',
-      'ACT': '{yellow-fg}',
-      'CLEAN UP': '{magenta-fg}',
-      'VERIFY': '{blue-fg}',
-      'DONE': '{green-fg}',
-      'UNKNOWN': '{gray-fg}'
-    };
-
-    const stepColor = stepColors[step] || '{gray-fg}';
-
-    // Progress bar
-    const barWidth = 40;
-    const filledWidth = Math.round((progress / 100) * barWidth);
-    const emptyWidth = barWidth - filledWidth;
-    const progressBar = '{green-fg}' + '█'.repeat(filledWidth) + '{/green-fg}' +
-                        '{gray-fg}' + '░'.repeat(emptyWidth) + '{/gray-fg}';
-
-    // Chat counter
-    const chatDisplay = maxChats
-      ? `Chat ${chatCount}/${maxChats}`
-      : `Chat ${chatCount} (unlimited)`;
-
-    // Build card content
-    const content = `
-  {bold}📋 Current Requirement{/bold}
-
-  ${requirement.length > 70 ? requirement.substring(0, 67) + '...' : requirement}
-
-  {bold}🚦 Status:{/bold} ${stepColor}{bold}${step}{/bold}{/}
-
-  ${progressBar} ${progress}%
-
-  {gray-fg}${chatDisplay}{/gray-fg}
-`;
-
-    statusCard.setContent(content);
-    screen.render();
-  }
-
-  /**
-   * Append a line to the output log
-   * @param {string} line - Line to append
-   */
-  function appendOutput(line) {
-    outputLog.log(line);
-    screen.render();
-  }
-
-  /**
-   * Clear the output log
-   */
-  function clearOutput() {
-    outputLog.setContent('');
-    screen.render();
-  }
-
-  return {
-    screen,
-    header,
-    statusCard,
-    outputLog,
-    updateStatus,
-    appendOutput,
-    clearOutput,
-    destroy: () => screen.destroy()
-  };
-}
-
-module.exports = {
-  createAutoModeUI
-};

package/tests/antigravity-js-handler.test.js

@@ -1,23 +0,0 @@
-const { handleAntigravityRateLimit } = require('../src/utils/antigravity-js-handler');
-const providerRegistry = require('../src/utils/provider-registry');
-
-jest.mock('../src/utils/provider-registry');
-
-describe('handleAntigravityRateLimit', () => {
-  beforeEach(() => {
-    jest.resetAllMocks();
-  });
-
-  test('suggests next provider and does not persistently disable antigravity', async () => {
-    providerRegistry.getProviderPreferences.mockResolvedValue({
-      order: ['antigravity', 'vscode'],
-      enabled: { antigravity: true, vscode: true }
-    });
-
-    const result = await handleAntigravityRateLimit();
-
-    expect(result.success).toBe(true);
-    expect(result.nextProvider).toBe('vscode');
-    expect(providerRegistry.saveProviderPreferences).not.toHaveBeenCalled();
-  });
-});

package/tests/auto-mode.test.js

@@ -1,37 +0,0 @@
-const os = require('os');
-const path = require('path');
-const fs = require('fs-extra');
-
-describe('auto-mode utils', () => {
-  const tmpConfig = path.join(os.tmpdir(), `vibecodingmachine_test_config_${Date.now()}.json`);
-  const tmpRepo = path.join(os.tmpdir(), `vibecodingmachine_test_repo_${Date.now()}`);
-
-  beforeAll(async () => {
-    process.env.VIBECODINGMACHINE_CONFIG_PATH = tmpConfig;
-    await fs.ensureDir(path.join(tmpRepo, '.vibecodingmachine', 'temp'));
-    const { setRepoPath } = require('../src/utils/config');
-    await setRepoPath(tmpRepo);
-  });
-
-  afterAll(async () => {
-    delete process.env.VIBECODINGMACHINE_CONFIG_PATH;
-    await fs.remove(tmpConfig).catch(() => {});
-    await fs.remove(tmpRepo).catch(() => {});
-  });
-
-  test('start/stop and status', async () => {
-    const { startAutoMode, stopAutoMode, checkAutoModeStatus } = require('../src/utils/auto-mode');
-    const { getAutoConfig } = require('../src/utils/config');
-    await startAutoMode(tmpRepo, { ide: 'cursor' });
-    let status = await checkAutoModeStatus();
-    expect(status.running).toBe(true);
-    expect(status.ide).toBe('cursor');
-
-    await stopAutoMode();
-    status = await checkAutoModeStatus();
-    expect(status.running).toBe(false);
-  });
-});
-
-
-

package/tests/config.test.js

@@ -1,34 +0,0 @@
-const os = require('os');
-const path = require('path');
-const fs = require('fs-extra');
-
-describe('config utils', () => {
-  const tmpConfig = path.join(os.tmpdir(), `vibecodingmachine_test_config_${Date.now()}.json`);
-
-  beforeAll(() => {
-    process.env.VIBECODINGMACHINE_CONFIG_PATH = tmpConfig;
-  });
-
-  afterAll(async () => {
-    delete process.env.VIBECODINGMACHINE_CONFIG_PATH;
-    await fs.remove(tmpConfig).catch(() => {});
-  });
-
-  test('set/get repo path roundtrip', async () => {
-    const { getRepoPath, setRepoPath } = require('../src/utils/config');
-    expect(await getRepoPath()).toBeNull();
-    await setRepoPath('/tmp/repo');
-    expect(await getRepoPath()).toBe('/tmp/repo');
-  });
-
-  test('set/get auto config roundtrip', async () => {
-    const { getAutoConfig, setAutoConfig } = require('../src/utils/config');
-    await setAutoConfig({ ide: 'cursor', maxChats: 10 });
-    const cfg = await getAutoConfig();
-    expect(cfg.ide).toBe('cursor');
-    expect(cfg.maxChats).toBe(10);
-  });
-});
-
-
-

package/tests/home-bootstrap.test.js

@@ -1,76 +0,0 @@
-const os = require('os');
-const path = require('path');
-const fs = require('fs-extra');
-
-describe('interactive home directory bootstrap', () => {
-  const tmpHome = path.join(os.tmpdir(), `vibecodingmachine_test_home_${Date.now()}`);
-  const tmpConfig = path.join(os.tmpdir(), `vibecodingmachine_test_config_${Date.now()}.json`);
-
-  beforeAll(async () => {
-    process.env.VIBECODINGMACHINE_CONFIG_PATH = tmpConfig;
-    await fs.ensureDir(tmpHome);
-
-    jest.resetModules();
-
-    jest.spyOn(os, 'homedir').mockReturnValue(tmpHome);
-
-    process.chdir(tmpHome);
-
-    const prompts = [];
-    jest.doMock('inquirer', () => ({
-      prompt: async (questions) => {
-        prompts.push(questions);
-        const q0 = Array.isArray(questions) ? questions[0] : questions;
-
-        if (q0 && q0.name === 'shouldCreateCodeDir') {
-          return { shouldCreateCodeDir: true };
-        }
-
-        if (q0 && q0.name === 'projectName') {
-          return { projectName: 'My Project Name' };
-        }
-
-        return {};
-      }
-    }));
-
-    jest.doMock('vibecodingmachine-core', () => ({
-      checkVibeCodingMachineExists: async () => ({ insideExists: false, siblingExists: false }),
-      getHostname: () => 'test-host',
-      getRequirementsFilename: async () => 'REQUIREMENTS.md',
-      requirementsExists: async () => false,
-      isComputerNameEnabled: async () => false,
-      t: (k) => k,
-      detectLocale: () => 'en',
-      setLocale: () => {}
-    }));
-
-
-  });
-
-  afterAll(async () => {
-    jest.restoreAllMocks();
-    delete process.env.VIBECODINGMACHINE_CONFIG_PATH;
-    await fs.remove(tmpConfig).catch(() => {});
-    await fs.remove(tmpHome).catch(() => {});
-  });
-
-  test('bootstraps ~/code/<project> from home and can init .vibecodingmachine inside it', async () => {
-    const { bootstrapProjectIfInHomeDir } = require('../src/utils/interactive');
-    await bootstrapProjectIfInHomeDir();
-
-    const projectDir = path.join(tmpHome, 'code', 'my-project-name');
-    const projectDirReal = await fs.realpath(projectDir);
-    expect(await fs.realpath(process.cwd())).toBe(projectDirReal);
-    expect(await fs.pathExists(projectDirReal)).toBe(true);
-
-    const { initRepo } = require('../src/commands/repo');
-    await initRepo({ location: 'inside' });
-
-    const vcmDir = path.join(projectDirReal, '.vibecodingmachine');
-    expect(await fs.pathExists(vcmDir)).toBe(true);
-
-    const requirementsPath = path.join(vcmDir, 'REQUIREMENTS.md');
-    expect(await fs.pathExists(requirementsPath)).toBe(true);
-  });
-});

package/tests/integration/health-tracking.integration.test.js

@@ -1,284 +0,0 @@
-/**
- * Integration tests for Health Tracking
- * Tests cross-component behavior and data persistence
- * @jest-environment node
- */
-
-const fs = require('fs-extra');
-const path = require('path');
-const os = require('os');
-const { IDEHealthTracker } = require('vibecodingmachine-core');
-
-describe('Health Tracking Integration', () => {
-  let testStorageFile;
-
-  beforeEach(() => {
-    testStorageFile = path.join(os.tmpdir(), `integration-test-health-${Date.now()}.json`);
-  });
-
-  afterEach(async () => {
-    if (await fs.pathExists(testStorageFile)) {
-      await fs.remove(testStorageFile);
-    }
-    const backupFile = `${testStorageFile}.bak`;
-    if (await fs.pathExists(backupFile)) {
-      await fs.remove(backupFile);
-    }
-  });
-
-  describe('Data Persistence', () => {
-    it('should persist health data across tracker instances', async () => {
-      // Create first tracker and record interactions
-      const tracker1 = new IDEHealthTracker({ storageFile: testStorageFile });
-
-      await tracker1.recordSuccess('cursor', 120000, {
-        requirementId: 'req-001',
-        continuationPromptsDetected: 1,
-      });
-      await tracker1.recordSuccess('cursor', 115000);
-      await tracker1.recordFailure('windsurf', 'Timeout exceeded', {
-        timeoutUsed: 1800000,
-      });
-      await tracker1.recordQuota('vscode', 'Monthly quota exceeded');
-
-      // Save explicitly
-      await tracker1.save();
-
-      // Create second tracker and verify data loaded
-      const tracker2 = new IDEHealthTracker({ storageFile: testStorageFile });
-      await tracker2.load();
-
-      const cursorMetrics = await tracker2.getHealthMetrics('cursor');
-      const windsurfMetrics = await tracker2.getHealthMetrics('windsurf');
-      const vscodeMetrics = await tracker2.getHealthMetrics('vscode');
-
-      // Verify Cursor data
-      expect(cursorMetrics.successCount).toBe(2);
-      expect(cursorMetrics.failureCount).toBe(0);
-      expect(cursorMetrics.averageResponseTime).toBeGreaterThan(0);
-
-      // Verify Windsurf data
-      expect(windsurfMetrics.successCount).toBe(0);
-      expect(windsurfMetrics.failureCount).toBe(1);
-
-      // Verify VS Code quota didn't increment counters
-      expect(vscodeMetrics.successCount).toBe(0);
-      expect(vscodeMetrics.failureCount).toBe(0);
-    });
-
-    // KNOWN LIMITATION: Concurrent writes with autoSave:false not currently supported
-    // The current implementation writes to disk on every operation, which causes race
-    // conditions when multiple operations run concurrently. This would require in-memory
-    // caching to fix properly. In production, autoSave defaults to true with 500ms
-    // debouncing, which prevents this issue.
-    it.skip('should handle concurrent writes from same tracker', async () => {
-      const tracker = new IDEHealthTracker({
-        storageFile: testStorageFile,
-        autoSave: false,
-      });
-
-      // Record multiple interactions rapidly
-      const promises = [];
-      for (let i = 0; i < 20; i++) {
-        promises.push(tracker.recordSuccess('cursor', 120000 + i * 100));
-      }
-      await Promise.all(promises);
-
-      await tracker.save();
-
-      // Verify all were recorded
-      const metrics = await tracker.getHealthMetrics('cursor');
-      expect(metrics.successCount).toBe(20);
-    });
-
-    it('should create backup before overwriting', async () => {
-      const tracker1 = new IDEHealthTracker({ storageFile: testStorageFile });
-      await tracker1.recordSuccess('cursor', 120000);
-      await tracker1.save();
-
-      // Verify file exists
-      const fileExists = await fs.pathExists(testStorageFile);
-      expect(fileExists).toBe(true);
-
-      // Record more data (should create backup)
-      const tracker2 = new IDEHealthTracker({ storageFile: testStorageFile });
-      await tracker2.recordSuccess('windsurf', 180000);
-      await tracker2.save();
-
-      // Verify backup was created
-      const backupFile = `${testStorageFile}.bak`;
-      const backupExists = await fs.pathExists(backupFile);
-      expect(backupExists).toBe(true);
-
-      // Verify backup contains original data
-      const backupData = await fs.readJson(backupFile);
-      expect(backupData.ides.cursor).toBeDefined();
-      expect(backupData.ides.cursor.successCount).toBe(1);
-    });
-
-    it('should restore from backup on corrupted data', async () => {
-      // Create valid data
-      const tracker1 = new IDEHealthTracker({ storageFile: testStorageFile });
-      await tracker1.recordSuccess('cursor', 120000);
-      await tracker1.save();
-
-      // Corrupt the main file
-      await fs.writeFile(testStorageFile, 'invalid json {{{');
-
-      // Try to load - should restore from backup
-      const tracker2 = new IDEHealthTracker({ storageFile: testStorageFile });
-      const metrics = await tracker2.getHealthMetrics('cursor');
-
-      // Should have loaded from backup
-      expect(metrics.successCount).toBe(1);
-    });
-  });
-
-  describe('Multi-IDE Scenarios', () => {
-    it('should track multiple IDEs independently', async () => {
-      const tracker = new IDEHealthTracker({ storageFile: testStorageFile });
-
-      // Record interactions for different IDEs
-      await tracker.recordSuccess('cursor', 120000);
-      await tracker.recordSuccess('cursor', 115000);
-      await tracker.recordSuccess('windsurf', 200000);
-      await tracker.recordFailure('vscode', 'Error');
-      await tracker.recordQuota('github-copilot', 'Quota exceeded');
-
-      await tracker.save();
-
-      // Verify each IDE tracked separately
-      const allMetrics = await tracker.getAllHealthMetrics();
-      expect(allMetrics.size).toBe(4); // cursor, windsurf, vscode, github-copilot
-
-      expect(allMetrics.get('cursor').successCount).toBe(2);
-      expect(allMetrics.get('windsurf').successCount).toBe(1);
-      expect(allMetrics.get('vscode').failureCount).toBe(1);
-      expect(allMetrics.get('github-copilot').successCount).toBe(0);
-      expect(allMetrics.get('github-copilot').failureCount).toBe(0);
-    });
-
-    it('should recommend best IDE based on success rate', async () => {
-      const tracker = new IDEHealthTracker({ storageFile: testStorageFile });
-
-      // Cursor: 80% success (8/10)
-      for (let i = 0; i < 8; i++) {
-        await tracker.recordSuccess('cursor', 120000);
-      }
-      for (let i = 0; i < 2; i++) {
-        await tracker.recordFailure('cursor', 'Error');
-      }
-
-      // Windsurf: 60% success (6/10)
-      for (let i = 0; i < 6; i++) {
-        await tracker.recordSuccess('windsurf', 180000);
-      }
-      for (let i = 0; i < 4; i++) {
-        await tracker.recordFailure('windsurf', 'Error');
-      }
-
-      // VS Code: 100% but only 2 interactions (below threshold)
-      for (let i = 0; i < 2; i++) {
-        await tracker.recordSuccess('vscode', 150000);
-      }
-
-      const recommended = await tracker.getRecommendedIDE({ minInteractions: 10 });
-      expect(recommended).toBe('cursor');
-    });
-  });
-
-  describe('EWMA Calculation Persistence', () => {
-    it('should persist and recalculate EWMA correctly', async () => {
-      const tracker1 = new IDEHealthTracker({ storageFile: testStorageFile });
-
-      // Record response times with increasing pattern
-      await tracker1.recordSuccess('cursor', 100000);
-      await tracker1.recordSuccess('cursor', 110000);
-      await tracker1.recordSuccess('cursor', 120000);
-      await tracker1.save();
-
-      const metrics1 = await tracker1.getHealthMetrics('cursor');
-      const ewma1 = metrics1.averageResponseTime;
-      expect(ewma1).toBeGreaterThan(100000);
-      expect(ewma1).toBeLessThan(120000);
-
-      // Load in new instance and add more data
-      const tracker2 = new IDEHealthTracker({ storageFile: testStorageFile });
-      await tracker2.load();
-
-      await tracker2.recordSuccess('cursor', 130000);
-      const metrics2 = await tracker2.getHealthMetrics('cursor');
-      const ewma2 = metrics2.averageResponseTime;
-
-      // EWMA should have increased
-      expect(ewma2).toBeGreaterThan(ewma1);
-    });
-  });
-
-  describe('Consecutive Failures Across Sessions', () => {
-    it('should maintain consecutive failure count across restarts', async () => {
-      const tracker1 = new IDEHealthTracker({ storageFile: testStorageFile });
-
-      // Record 3 failures
-      await tracker1.recordFailure('cursor', 'Error 1');
-      await tracker1.recordFailure('cursor', 'Error 2');
-      await tracker1.recordFailure('cursor', 'Error 3');
-      await tracker1.save();
-
-      // Load in new instance
-      const tracker2 = new IDEHealthTracker({ storageFile: testStorageFile });
-      await tracker2.load();
-
-      const metrics = await tracker2.getHealthMetrics('cursor');
-      expect(metrics.consecutiveFailures).toBe(3);
-
-      // Add 2 more failures to trigger threshold
-      let eventEmitted = false;
-      tracker2.on('consecutive-failures', () => {
-        eventEmitted = true;
-      });
-
-      await tracker2.recordFailure('cursor', 'Error 4');
-      await tracker2.recordFailure('cursor', 'Error 5');
-
-      expect(eventEmitted).toBe(true);
-    });
-
-    it('should reset consecutive failures on success across sessions', async () => {
-      const tracker1 = new IDEHealthTracker({ storageFile: testStorageFile });
-
-      // Record failures
-      await tracker1.recordFailure('cursor', 'Error 1');
-      await tracker1.recordFailure('cursor', 'Error 2');
-      await tracker1.save();
-
-      // Load in new instance and record success
-      const tracker2 = new IDEHealthTracker({ storageFile: testStorageFile });
-      await tracker2.load();
-
-      await tracker2.recordSuccess('cursor', 120000);
-
-      const metrics = await tracker2.getHealthMetrics('cursor');
-      expect(metrics.consecutiveFailures).toBe(0);
-      expect(metrics.successCount).toBe(1);
-      expect(metrics.failureCount).toBe(2);
-    });
-  });
-
-  describe('Timeout Configuration Persistence', () => {
-    it('should persist timeout configuration', async () => {
-      const tracker1 = new IDEHealthTracker({ storageFile: testStorageFile });
-
-      // Record some data
-      await tracker1.recordSuccess('cursor', 120000);
-      await tracker1.save();
-
-      // Verify timeout config persisted
-      const data = await fs.readJson(testStorageFile);
-      expect(data.timeoutConfig).toBeDefined();
-      expect(data.timeoutConfig.mode).toBe('fixed');
-      expect(data.timeoutConfig.defaultTimeout).toBe(1800000);
-      expect(data.timeoutConfig.bufferPercentage).toBe(0.4);
-    });
-  });
-});