vibecodingmachine-core 2026.1.23-1010 → 2026.1.29-1432

package/src/health-tracking/__tests__/interaction-recorder.test.js

@@ -1,392 +0,0 @@
-/**
- * Unit tests for InteractionRecorder
- * @jest-environment node
- */
-
-const { InteractionRecorder } = require('../interaction-recorder');
-const { ValidationError } = require('../errors');
-
-describe('InteractionRecorder', () => {
-  let recorder;
-  let mockStorage;
-
-  beforeEach(() => {
-    // Create mock storage
-    mockStorage = {
-      data: {
-        version: '1.0.0',
-        lastUpdated: new Date().toISOString(),
-        ides: {},
-        timeoutConfig: {},
-        defaultRequirement: null,
-      },
-      async read() {
-        return JSON.parse(JSON.stringify(this.data));
-      },
-      async write(data) {
-        this.data = JSON.parse(JSON.stringify(data));
-      },
-    };
-
-    recorder = new InteractionRecorder(mockStorage);
-  });
-
-  describe('record()', () => {
-    it('should record a success interaction', async () => {
-      const interaction = {
-        ideId: 'cursor',
-        timestamp: new Date(),
-        outcome: 'success',
-        responseTime: 120000,
-        timeoutUsed: 180000,
-        continuationPromptsDetected: 1,
-        requirementId: 'req-001',
-        errorMessage: null,
-      };
-
-      await recorder.record(interaction);
-
-      const data = await mockStorage.read();
-      expect(data.ides.cursor).toBeDefined();
-      expect(data.ides.cursor.interactions).toHaveLength(1);
-      expect(data.ides.cursor.interactions[0].outcome).toBe('success');
-      expect(data.ides.cursor.interactions[0].responseTime).toBe(120000);
-    });
-
-    it('should record a failure interaction', async () => {
-      const interaction = {
-        ideId: 'windsurf',
-        timestamp: new Date(),
-        outcome: 'failure',
-        responseTime: null,
-        timeoutUsed: 1800000,
-        continuationPromptsDetected: 0,
-        requirementId: 'req-002',
-        errorMessage: 'Timeout exceeded',
-      };
-
-      await recorder.record(interaction);
-
-      const data = await mockStorage.read();
-      expect(data.ides.windsurf.interactions).toHaveLength(1);
-      expect(data.ides.windsurf.interactions[0].outcome).toBe('failure');
-      expect(data.ides.windsurf.interactions[0].errorMessage).toBe('Timeout exceeded');
-      expect(data.ides.windsurf.interactions[0].responseTime).toBeNull();
-    });
-
-    it('should record a quota interaction', async () => {
-      const interaction = {
-        ideId: 'cursor',
-        timestamp: new Date(),
-        outcome: 'quota',
-        responseTime: null,
-        timeoutUsed: 1800000,
-        continuationPromptsDetected: 0,
-        requirementId: 'req-003',
-        errorMessage: 'Monthly quota exceeded',
-      };
-
-      await recorder.record(interaction);
-
-      const data = await mockStorage.read();
-      expect(data.ides.cursor.interactions).toHaveLength(1);
-      expect(data.ides.cursor.interactions[0].outcome).toBe('quota');
-    });
-
-    it('should convert Date timestamp to ISO string', async () => {
-      const timestamp = new Date('2025-01-21T12:00:00Z');
-      const interaction = {
-        ideId: 'cursor',
-        timestamp,
-        outcome: 'success',
-        responseTime: 120000,
-        timeoutUsed: 180000,
-        continuationPromptsDetected: 0,
-        requirementId: null,
-        errorMessage: null,
-      };
-
-      await recorder.record(interaction);
-
-      const data = await mockStorage.read();
-      expect(data.ides.cursor.interactions[0].timestamp).toBe('2025-01-21T12:00:00.000Z');
-      expect(typeof data.ides.cursor.interactions[0].timestamp).toBe('string');
-    });
-
-    it('should initialize IDE record if it does not exist', async () => {
-      const interaction = {
-        ideId: 'new-ide',
-        timestamp: new Date(),
-        outcome: 'success',
-        responseTime: 120000,
-        timeoutUsed: 180000,
-        continuationPromptsDetected: 0,
-        requirementId: null,
-        errorMessage: null,
-      };
-
-      await recorder.record(interaction);
-
-      const data = await mockStorage.read();
-      expect(data.ides['new-ide']).toBeDefined();
-      expect(data.ides['new-ide'].interactions).toHaveLength(1);
-      expect(data.ides['new-ide'].successCount).toBe(0);
-      expect(data.ides['new-ide'].failureCount).toBe(0);
-    });
-
-    it('should enforce max 100 interactions per IDE', async () => {
-      // Add 120 interactions
-      for (let i = 0; i < 120; i++) {
-        const interaction = {
-          ideId: 'cursor',
-          timestamp: new Date(),
-          outcome: 'success',
-          responseTime: 120000 + i,
-          timeoutUsed: 180000,
-          continuationPromptsDetected: 0,
-          requirementId: null,
-          errorMessage: null,
-        };
-        await recorder.record(interaction);
-      }
-
-      const data = await mockStorage.read();
-      expect(data.ides.cursor.interactions.length).toBeLessThanOrEqual(100);
-    });
-
-    it('should remove oldest interaction when exceeding max', async () => {
-      // Add interactions with distinct response times
-      for (let i = 0; i < 101; i++) {
-        const interaction = {
-          ideId: 'cursor',
-          timestamp: new Date(Date.now() + i * 1000),
-          outcome: 'success',
-          responseTime: 100000 + i,
-          timeoutUsed: 180000,
-          continuationPromptsDetected: 0,
-          requirementId: `req-${i}`,
-          errorMessage: null,
-        };
-        await recorder.record(interaction);
-      }
-
-      const data = await mockStorage.read();
-      expect(data.ides.cursor.interactions).toHaveLength(100);
-      // First interaction (100000ms) should be removed
-      const firstResponseTime = data.ides.cursor.interactions[0].responseTime;
-      expect(firstResponseTime).toBe(100001); // Second interaction is now first
-    });
-
-    it('should throw ValidationError for invalid outcome', async () => {
-      const interaction = {
-        ideId: 'cursor',
-        timestamp: new Date(),
-        outcome: 'invalid-outcome',
-        responseTime: 120000,
-        timeoutUsed: 180000,
-        continuationPromptsDetected: 0,
-        requirementId: null,
-        errorMessage: null,
-      };
-
-      await expect(recorder.record(interaction))
-        .rejects
-        .toThrow(ValidationError);
-    });
-
-    it('should throw ValidationError for empty ideId', async () => {
-      const interaction = {
-        ideId: '',
-        timestamp: new Date(),
-        outcome: 'success',
-        responseTime: 120000,
-        timeoutUsed: 180000,
-        continuationPromptsDetected: 0,
-        requirementId: null,
-        errorMessage: null,
-      };
-
-      await expect(recorder.record(interaction))
-        .rejects
-        .toThrow(ValidationError);
-    });
-
-    it('should throw ValidationError for negative responseTime', async () => {
-      const interaction = {
-        ideId: 'cursor',
-        timestamp: new Date(),
-        outcome: 'success',
-        responseTime: -1000,
-        timeoutUsed: 180000,
-        continuationPromptsDetected: 0,
-        requirementId: null,
-        errorMessage: null,
-      };
-
-      await expect(recorder.record(interaction))
-        .rejects
-        .toThrow(ValidationError);
-    });
-
-    it('should allow null responseTime for failures', async () => {
-      const interaction = {
-        ideId: 'cursor',
-        timestamp: new Date(),
-        outcome: 'failure',
-        responseTime: null,
-        timeoutUsed: 180000,
-        continuationPromptsDetected: 0,
-        requirementId: null,
-        errorMessage: 'Timeout',
-      };
-
-      await recorder.record(interaction);
-
-      const data = await mockStorage.read();
-      expect(data.ides.cursor.interactions[0].responseTime).toBeNull();
-    });
-
-    it('should handle multiple IDEs independently', async () => {
-      const cursorInteraction = {
-        ideId: 'cursor',
-        timestamp: new Date(),
-        outcome: 'success',
-        responseTime: 120000,
-        timeoutUsed: 180000,
-        continuationPromptsDetected: 0,
-        requirementId: null,
-        errorMessage: null,
-      };
-
-      const windsurfInteraction = {
-        ideId: 'windsurf',
-        timestamp: new Date(),
-        outcome: 'failure',
-        responseTime: null,
-        timeoutUsed: 1800000,
-        continuationPromptsDetected: 0,
-        requirementId: null,
-        errorMessage: 'Error',
-      };
-
-      await recorder.record(cursorInteraction);
-      await recorder.record(windsurfInteraction);
-
-      const data = await mockStorage.read();
-      expect(data.ides.cursor.interactions).toHaveLength(1);
-      expect(data.ides.windsurf.interactions).toHaveLength(1);
-      expect(data.ides.cursor.interactions[0].outcome).toBe('success');
-      expect(data.ides.windsurf.interactions[0].outcome).toBe('failure');
-    });
-  });
-
-  describe('getInteractions()', () => {
-    it('should retrieve interactions for a specific IDE', async () => {
-      const interaction1 = {
-        ideId: 'cursor',
-        timestamp: new Date(),
-        outcome: 'success',
-        responseTime: 120000,
-        timeoutUsed: 180000,
-        continuationPromptsDetected: 0,
-        requirementId: null,
-        errorMessage: null,
-      };
-
-      const interaction2 = {
-        ideId: 'cursor',
-        timestamp: new Date(),
-        outcome: 'failure',
-        responseTime: null,
-        timeoutUsed: 180000,
-        continuationPromptsDetected: 0,
-        requirementId: null,
-        errorMessage: 'Error',
-      };
-
-      await recorder.record(interaction1);
-      await recorder.record(interaction2);
-
-      const interactions = await recorder.getInteractions('cursor');
-      expect(interactions).toHaveLength(2);
-      expect(interactions[0].outcome).toBe('success');
-      expect(interactions[1].outcome).toBe('failure');
-    });
-
-    it('should return empty array for IDE with no interactions', async () => {
-      const interactions = await recorder.getInteractions('nonexistent-ide');
-      expect(interactions).toEqual([]);
-    });
-
-    it('should support limiting number of returned interactions', async () => {
-      // Add 15 interactions
-      for (let i = 0; i < 15; i++) {
-        await recorder.record({
-          ideId: 'cursor',
-          timestamp: new Date(),
-          outcome: 'success',
-          responseTime: 120000,
-          timeoutUsed: 180000,
-          continuationPromptsDetected: 0,
-          requirementId: null,
-          errorMessage: null,
-        });
-      }
-
-      const recentTen = await recorder.getInteractions('cursor', 10);
-      expect(recentTen).toHaveLength(10);
-    });
-  });
-
-  describe('clearInteractions()', () => {
-    it('should clear all interactions for a specific IDE', async () => {
-      await recorder.record({
-        ideId: 'cursor',
-        timestamp: new Date(),
-        outcome: 'success',
-        responseTime: 120000,
-        timeoutUsed: 180000,
-        continuationPromptsDetected: 0,
-        requirementId: null,
-        errorMessage: null,
-      });
-
-      await recorder.clearInteractions('cursor');
-
-      const interactions = await recorder.getInteractions('cursor');
-      expect(interactions).toEqual([]);
-    });
-
-    it('should not affect other IDEs when clearing one', async () => {
-      await recorder.record({
-        ideId: 'cursor',
-        timestamp: new Date(),
-        outcome: 'success',
-        responseTime: 120000,
-        timeoutUsed: 180000,
-        continuationPromptsDetected: 0,
-        requirementId: null,
-        errorMessage: null,
-      });
-
-      await recorder.record({
-        ideId: 'windsurf',
-        timestamp: new Date(),
-        outcome: 'success',
-        responseTime: 180000,
-        timeoutUsed: 180000,
-        continuationPromptsDetected: 0,
-        requirementId: null,
-        errorMessage: null,
-      });
-
-      await recorder.clearInteractions('cursor');
-
-      const cursorInteractions = await recorder.getInteractions('cursor');
-      const windsurfInteractions = await recorder.getInteractions('windsurf');
-
-      expect(cursorInteractions).toEqual([]);
-      expect(windsurfInteractions).toHaveLength(1);
-    });
-  });
-});

package/src/ide-integration/__tests__/applescript-manager-thread-closure.test.js

@@ -1,227 +0,0 @@
-/**
- * Jest tests for AppleScript Manager thread closure functionality
- * Tests the ability to close previous chat threads when starting new ones
- */
-
-import { AppleScriptManager } from '../applescript-manager.js';
-import { execSync } from 'child_process';
-
-// Mock child_process
-jest.mock('child_process', () => ({
-  execSync: jest.fn()
-}));Windsurf: Open Chat
-
-
-
-
-
-// Mock fs
-jest.mock('fs', () => ({
-  writeFileSync: jest.fn(),
-  unlinkSync: jest.fn()
-}));
-
-// Mock os
-jest.mock('os', () => ({
-  tmpdir: () => '/tmp'
-}));
-
-describe('AppleScriptManager - Thread Closure', () => {
-  let appleScriptManager;
-  let mockExecSync;
-
-  beforeEach(() => {
-    appleScriptManager = new AppleScriptManager();
-    mockExecSync = execSync;
-    mockExecSync.mockClear();
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('closePreviousChatThread', () => {
-    it('should close previous chat thread in Cursor', async () => {
-      // Mock successful execution
-      mockExecSync.mockReturnValue('Previous chat thread closed');
-
-      const result = await appleScriptManager.closePreviousChatThread('cursor');
-
-      expect(result.success).toBe(true);
-      expect(result.message).toContain('Previous chat thread closed');
-      expect(result.method).toBe('applescript');
-      expect(mockExecSync).toHaveBeenCalled();
-    });
-
-    it('should close previous chat thread in VS Code', async () => {
-      // Mock successful execution
-      mockExecSync.mockReturnValue('Previous chat thread closed');
-
-      const result = await appleScriptManager.closePreviousChatThread('vscode');
-
-      expect(result.success).toBe(true);
-      expect(result.message).toContain('Previous chat thread closed');
-      expect(result.method).toBe('applescript');
-      expect(mockExecSync).toHaveBeenCalled();
-    });
-
-    it('should close previous chat thread in Windsurf', async () => {
-      // Mock successful execution
-      mockExecSync.mockReturnValue('Previous chat thread closed');
-
-      const result = await appleScriptManager.closePreviousChatThread('windsurf');
-
-      expect(result.success).toBe(true);
-      expect(result.message).toContain('Previous chat thread closed');
-      expect(result.method).toBe('applescript');
-      expect(mockExecSync).toHaveBeenCalled();
-    });
-
-    it('should handle errors gracefully when closing threads', async () => {
-      // Mock execution error
-      mockExecSync.mockImplementation(() => {
-        throw new Error('Failed to close thread');
-      });
-
-      const result = await appleScriptManager.closePreviousChatThread('cursor');
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Failed to close thread');
-      expect(result.method).toBe('applescript');
-    });
-
-    it('should return error for unsupported IDE', async () => {
-      const result = await appleScriptManager.closePreviousChatThread('unsupported');
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Unsupported IDE');
-      expect(mockExecSync).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('sendTextWithThreadClosure', () => {
-    it('should close previous thread before sending new message to Cursor', async () => {
-      // Mock successful executions
-      mockExecSync
-        .mockReturnValueOnce('Previous chat thread closed')
-        .mockReturnValueOnce('Message sent to Cursor: Test message')
-        .mockReturnValueOnce('Message sent to Cursor: Test message');
-
-      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'cursor');
-
-      expect(result.success).toBe(true);
-      expect(result.message).toContain('Test message');
-      expect(mockExecSync).toHaveBeenCalledTimes(3); // Once for close, twice for send (sendText calls execSync twice)
-    });
-
-    it('should close previous thread before sending new message to VS Code', async () => {
-      // Mock successful executions
-      mockExecSync
-        .mockReturnValueOnce('Previous chat thread closed')
-        .mockImplementationOnce(() => {
-          // Simulate successful AppleScript execution for text sending
-          return 'Message sent via AppleScript to VS Code GitHub Copilot Chat';
-        });
-
-      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'vscode');
-
-      expect(result.success).toBe(true); // VS Code is now supported by AppleScript manager
-      expect(result.method).toBe('applescript');
-      expect(result.threadClosure).toContain('Previous thread closed');
-      expect(mockExecSync).toHaveBeenCalledTimes(2); // Once for thread closure, once for sending
-    });
-
-    it('should close previous thread before sending new message to Windsurf', async () => {
-      // Mock successful executions
-      mockExecSync
-        .mockReturnValueOnce('Previous chat thread closed')
-        .mockImplementationOnce(() => {
-          throw new Error('AppleScript failed');
-        });
-
-      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'windsurf');
-
-      expect(result.success).toBe(true);
-      expect(result.message).toContain('Test message');
-      expect(mockExecSync).toHaveBeenCalled(); // Should be called at least once for thread closure
-    });
-
-    it('should handle thread closure failure gracefully', async () => {
-      // Mock thread closure failure but successful message send
-      mockExecSync
-        .mockImplementationOnce(() => {
-          throw new Error('Failed to close thread');
-        })
-        .mockImplementationOnce(() => {
-          throw new Error('AppleScript failed');
-        });
-
-      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'cursor');
-
-      expect(result.success).toBe(true);
-      expect(result.message).toContain('Test message');
-      expect(result.warning).toContain('Failed to close previous thread');
-      expect(mockExecSync).toHaveBeenCalled(); // Should be called at least once
-    });
-
-    it('should handle both thread closure and message send failures', async () => {
-      // Mock both failures
-      mockExecSync
-        .mockImplementationOnce(() => {
-          throw new Error('Failed to close thread');
-        })
-        .mockImplementationOnce(() => {
-          throw new Error('AppleScript failed');
-        });
-
-      const result = await appleScriptManager.sendTextWithThreadClosure('Test message', 'cursor');
-
-      expect(result.success).toBe(true); // Should still succeed due to simulated fallback
-      expect(result.message).toContain('Test message');
-      expect(mockExecSync).toHaveBeenCalled(); // Should be called at least once
-    });
-
-    it('should validate input parameters', async () => {
-      const result = await appleScriptManager.sendTextWithThreadClosure('', 'cursor');
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Invalid text');
-      expect(mockExecSync).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('AppleScript Content Validation', () => {
-    it('should generate correct AppleScript for Cursor thread closure', async () => {
-      mockExecSync.mockReturnValue('Success');
-
-      await appleScriptManager.closePreviousChatThread('cursor');
-
-      const callArgs = mockExecSync.mock.calls[0][0];
-      expect(callArgs).toContain('osascript');
-      // The script content is written to a temp file, so we check the osascript call
-      expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('osascript'), expect.any(Object));
-    });
-
-    it('should generate correct AppleScript for VS Code thread closure', async () => {
-      mockExecSync.mockReturnValue('Success');
-
-      await appleScriptManager.closePreviousChatThread('vscode');
-
-      const callArgs = mockExecSync.mock.calls[0][0];
-      expect(callArgs).toContain('osascript');
-      // The script content is written to a temp file, so we check the osascript call
-      expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('osascript'), expect.any(Object));
-    });
-
-    it('should generate correct AppleScript for Windsurf thread closure', async () => {
-      mockExecSync.mockReturnValue('Success');
-
-      await appleScriptManager.closePreviousChatThread('windsurf');
-
-      const callArgs = mockExecSync.mock.calls[0][0];
-      expect(callArgs).toContain('osascript');
-      // The script content is written to a temp file, so we check the osascript call
-      expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('osascript'), expect.any(Object));
-    });
-  });
-});

package/test-quota-system.js

@@ -1,67 +0,0 @@
-const { fetchQuotaForAgent } = require('./src/quota-management/index.js');
-const sharedAuth = require('./src/auth/shared-auth-storage');
-const ProviderManager = require('./src/ide-integration/provider-manager.cjs');
-
-async function testQuotaSystem() {
-    console.log('🧪 Starting Quota System Verification Test...');
-
-    // 1. Test Global Iterations Quota
-    console.log('\n--- Test 1: Global Iterations ---');
-    // Mock sharedAuth.canRunAutoMode
-    const originalCanRun = sharedAuth.canRunAutoMode;
-    sharedAuth.canRunAutoMode = async () => ({
-        canRun: true,
-        todayUsage: 4,
-        maxIterations: 10
-    });
-
-    try {
-        const globalQuota = await fetchQuotaForAgent('global:iterations');
-        console.log('Global Quota Type:', globalQuota.type);
-        console.log('Global Remaining:', globalQuota.remaining);
-        console.log('Global Limit:', globalQuota.limit);
-        if (globalQuota.remaining === 6 && globalQuota.type === 'global') {
-            console.log('✅ Global iterations test passed');
-        } else {
-            console.log('❌ Global iterations test failed');
-        }
-    } catch (error) {
-        console.error('❌ Global iterations test error:', error);
-    } finally {
-        sharedAuth.canRunAutoMode = originalCanRun;
-    }
-
-    // 2. Test Local Agent (Infinite)
-    console.log('\n--- Test 2: Local Agent (Infinite) ---');
-    try {
-        const localQuota = await fetchQuotaForAgent('local-ollama:qwen2.5');
-        console.log('Local Quota Type:', localQuota.type);
-        console.log('Local Remaining:', localQuota.remaining);
-        if (localQuota.remaining === Infinity && localQuota.type === 'infinite') {
-            console.log('✅ Local agent test passed');
-        } else {
-            console.log('❌ Local agent test failed');
-        }
-    } catch (error) {
-        console.error('❌ Local agent test error:', error);
-    }
-
-    // 3. Test Provider Rate Limit
-    console.log('\n--- Test 3: Provider Rate Limit ---');
-    try {
-        const providerQuota = await fetchQuotaForAgent('anthropic:claude-3');
-        console.log('Provider Quota Type:', providerQuota.type);
-        console.log('Provider Available (Remaining > 0):', providerQuota.remaining > 0);
-        if (providerQuota.type === 'rate-limit') {
-            console.log('✅ Provider rate limit test passed');
-        } else {
-            console.log('❌ Provider rate limit test failed');
-        }
-    } catch (error) {
-        console.error('❌ Provider rate limit test error:', error);
-    }
-
-    console.log('\n🏁 Quota System Verification Finished.');
-}
-
-testQuotaSystem().catch(console.error);