vibecodingmachine-core 2026.1.3-2209 → 2026.1.22-1441

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

@@ -0,0 +1,392 @@
+/**
+ * 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/health-tracking/errors.js

@@ -0,0 +1,50 @@
+/**
+ * Custom Error Classes for Health Tracking Module
+ *
+ * @module errors
+ */
+
+/**
+ * Thrown when input validation fails
+ * @extends Error
+ */
+class ValidationError extends Error {
+  /**
+   * @param {string} message - Description of validation failure
+   * @param {string} field - Field name that failed validation
+   * @param {*} value - Invalid value
+   */
+  constructor(message, field, value) {
+    super(message);
+    this.name = 'ValidationError';
+    this.field = field;
+    this.value = value;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+/**
+ * Thrown when file system operations fail
+ * @extends Error
+ */
+class FileSystemError extends Error {
+  /**
+   * @param {string} message - Description of file system error
+   * @param {string} path - File path that caused the error
+   * @param {string} operation - Operation that failed ('read' | 'write' | 'delete' | 'backup' | 'restore')
+   * @param {Error} [originalError] - Original error that caused this error
+   */
+  constructor(message, path, operation, originalError) {
+    super(message);
+    this.name = 'FileSystemError';
+    this.path = path;
+    this.operation = operation;
+    this.originalError = originalError;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+module.exports = {
+  ValidationError,
+  FileSystemError,
+};