vibecodingmachine-core 2026.1.3-2209 → 2026.1.23-1010

package/__tests__/provider-manager-fallback.test.js

@@ -0,0 +1,43 @@
+const ProviderManager = require('../src/ide-integration/provider-manager.cjs');
+
+describe('ProviderManager fallback behavior', () => {
+  let pm;
+
+  beforeEach(() => {
+    pm = new ProviderManager();
+    pm.clearAllRateLimits();
+  });
+
+  afterEach(() => {
+    pm.clearAllRateLimits();
+  });
+
+  test('isRateLimited should return true for provider when only legacy/model-agnostic key exists', () => {
+    // Simulate legacy stored key with model undefined (string 'undefined')
+    const resetTime = Date.now() + 10 * 60 * 1000; // 10 minutes from now
+    pm.rateLimits['antigravity:undefined'] = {
+      provider: 'antigravity',
+      model: undefined,
+      resetTime,
+      resetDate: new Date(resetTime).toISOString(),
+      reason: 'Quota limit reached',
+      markedAt: new Date().toISOString()
+    };
+
+    expect(pm.isRateLimited('antigravity', 'antigravity')).toBe(true);
+    const t = pm.getTimeUntilReset('antigravity', 'antigravity');
+    expect(t).toBeGreaterThan(0);
+  });
+
+  test('getRateLimitInfo should return earliest reset for provider when model-specific not present', () => {
+    const resetA = Date.now() + 60 * 60 * 1000; // 60m
+    const resetB = Date.now() + 5 * 60 * 1000;  // 5m
+
+    pm.rateLimits['antigravity:legacy'] = { provider: 'antigravity', model: 'legacy', resetTime: resetA, reason: 'legacy', markedAt: new Date().toISOString() };
+    pm.rateLimits['antigravity:other'] = { provider: 'antigravity', model: 'other', resetTime: resetB, reason: 'other', markedAt: new Date().toISOString() };
+
+    const info = pm.getRateLimitInfo('antigravity', 'antigravity');
+    expect(info.isRateLimited).toBe(true);
+    expect(info.resetTime).toBe(resetB);
+  });
+});

package/__tests__/provider-manager-rate-limit.test.js

@@ -0,0 +1,61 @@
+const ProviderManager = require('../src/ide-integration/provider-manager.cjs');
+
+describe('ProviderManager rate limit handling', () => {
+  let pm;
+
+  beforeEach(() => {
+    pm = new ProviderManager();
+    pm.clearAllRateLimits();
+  });
+
+  afterEach(() => {
+    pm.clearAllRateLimits();
+  });
+
+  test('markRateLimited with undefined model normalizes model to provider', () => {
+    // Call with model undefined to simulate IDE provider case
+    pm.markRateLimited('antigravity', undefined, 'Quota limit reached');
+
+    // The provider should be considered rate-limited when queried using provider as model
+    expect(pm.isRateLimited('antigravity', 'antigravity')).toBe(true);
+
+    const info = pm.getRateLimitInfo('antigravity', 'antigravity');
+    expect(info.isRateLimited).toBe(true);
+    expect(info.resetTime).toBeGreaterThan(Date.now());
+
+    const ms = pm.getTimeUntilReset('antigravity', 'antigravity');
+    expect(ms).toBeGreaterThan(0);
+  });
+
+
+  test('parses "resets Month Day at Time" format correctly', () => {
+    // Mock Date.now to Jan 13, 2026 10:00 AM
+    const mockNow = new Date('2026-01-13T10:00:00').getTime();
+    const originalDateNow = Date.now;
+    Date.now = jest.fn(() => mockNow);
+
+    try {
+      const errorMessage = 'Spending cap reached resets Jan 17 at 12pm';
+
+      // Expected: Jan 17 12:00 PM = 12:00 + (17-13)*24 hours
+      // Jan 13 10am to Jan 17 12pm
+      // Diff: 4 days + 2 hours = 98 hours
+      const expectedDuration = (4 * 24 * 60 * 60 * 1000) + (2 * 60 * 60 * 1000);
+
+      // Verify regex in test env
+      const regex = /resets\s+([a-zA-Z]+)\s+(\d{1,2})\s+at\s+(\d{1,2}(?::\d{2})?)\s*(am|pm)?/i;
+      const match = errorMessage.match(regex);
+      expect(match).not.toBeNull();
+
+      const duration = pm.parseRateLimitDuration(errorMessage);
+
+      // Allow for some minor variance if calculation logic differs slightly, but it should be close
+      expect(duration).toBeDefined();
+      expect(duration).not.toBeNull();
+      expect(Math.abs(duration - expectedDuration)).toBeLessThan(1000);
+
+    } finally {
+      Date.now = originalDateNow;
+    }
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibecodingmachine-core",
-  "version": "2026.01.03-2209",
+  "version": "2026.01.23-1010",
   "description": "Shared core logic for Vibe Coding Machine IDE integration",
   "main": "src/index.cjs",
   "module": "src/index.js",

package/src/compliance/compliance-manager.js

@@ -10,8 +10,11 @@ const fs = require('fs').promises
 const path = require('path')
 
 class ComplianceManager {
-  constructor() {
+  constructor(authToken = null) {
     this.userDb = new UserDatabase()
+    if (authToken) {
+      this.userDb.setAuthToken(authToken)
+    }
   }
 
   /**
@@ -19,7 +22,7 @@ class ComplianceManager {
    * Returns what needs to be acknowledged
    */
   async checkComplianceStatus(userId) {
-    const user = await this.userDb.getUser(userId)
+    const user = await this.userDb.getUser()
     
     if (!user) {
       throw new Error('User not found')

package/src/database/migrations.js

@@ -6,11 +6,11 @@
  */
 
 const { DynamoDBClient } = require('@aws-sdk/client-dynamodb')
-const { 
-  CreateTableCommand, 
-  DescribeTableCommand, 
+const {
+  CreateTableCommand,
+  DescribeTableCommand,
   UpdateTableCommand,
-  ListTablesCommand 
+  ListTablesCommand
 } = require('@aws-sdk/client-dynamodb')
 
 class DatabaseMigrations {
@@ -25,13 +25,15 @@ class DatabaseMigrations {
    */
   async runMigrations() {
     console.log('🔄 Running database migrations...')
-    
+
     try {
       await this.createUsersTable()
       await this.createComputersTable()
       await this.createProjectsTable()
       await this.createActivityTable()
-      
+      await this.createErrorsTable()
+      await this.createFeedbackTable()
+
       console.log('✅ All migrations completed successfully')
     } catch (error) {
       console.error('❌ Migration failed:', error)
@@ -44,7 +46,7 @@ class DatabaseMigrations {
    */
   async createUsersTable() {
     const tableName = 'vibecodingmachine-users'
-    
+
     if (await this.tableExists(tableName)) {
       console.log(`📋 Table ${tableName} already exists`)
       return
@@ -94,7 +96,7 @@ class DatabaseMigrations {
    */
   async createComputersTable() {
     const tableName = 'vibecodingmachine-computers'
-    
+
     if (await this.tableExists(tableName)) {
       console.log(`📋 Table ${tableName} already exists`)
       return
@@ -137,7 +139,7 @@ class DatabaseMigrations {
    */
   async createProjectsTable() {
     const tableName = 'vibecodingmachine-projects'
-    
+
     if (await this.tableExists(tableName)) {
       console.log(`📋 Table ${tableName} already exists`)
       return
@@ -180,7 +182,7 @@ class DatabaseMigrations {
    */
   async createActivityTable() {
     const tableName = 'vibecodingmachine-activity'
-    
+
     if (await this.tableExists(tableName)) {
       console.log(`📋 Table ${tableName} already exists`)
       return
@@ -222,6 +224,126 @@ class DatabaseMigrations {
     console.log(`✅ Created table: ${tableName}`)
   }
 
+  /**
+   * Create errors table for tracking application errors
+   */
+  async createErrorsTable() {
+    const tableName = 'vibecodingmachine-errors'
+
+    if (await this.tableExists(tableName)) {
+      console.log(`📋 Table ${tableName} already exists`)
+      return
+    }
+
+    const params = {
+      TableName: tableName,
+      KeySchema: [
+        { AttributeName: 'errorId', KeyType: 'HASH' }
+      ],
+      AttributeDefinitions: [
+        { AttributeName: 'errorId', AttributeType: 'S' }
+      ],
+      BillingMode: 'PAY_PER_REQUEST',
+      Tags: [
+        { Key: 'Application', Value: 'VibeCodingMachine' },
+        { Key: 'Environment', Value: process.env.NODE_ENV || 'development' }
+      ]
+    }
+
+    await this.client.send(new CreateTableCommand(params))
+    console.log(`✅ Created table: ${tableName}`)
+  }
+
+  /**
+   * Create feedback table for user comments
+   */
+  async createFeedbackTable() {
+    const tableName = 'vibecodingmachine-feedback'
+
+    if (await this.tableExists(tableName)) {
+      console.log(`📋 Table ${tableName} already exists`)
+      return
+    }
+
+    const params = {
+      TableName: tableName,
+      KeySchema: [
+        { AttributeName: 'feedbackId', KeyType: 'HASH' }
+      ],
+      AttributeDefinitions: [
+        { AttributeName: 'feedbackId', AttributeType: 'S' }
+      ],
+      BillingMode: 'PAY_PER_REQUEST',
+      Tags: [
+        { Key: 'Application', Value: 'VibeCodingMachine' },
+        { Key: 'Environment', Value: process.env.NODE_ENV || 'development' }
+      ]
+    }
+
+    await this.client.send(new CreateTableCommand(params))
+    console.log(`✅ Created table: ${tableName}`)
+  }
+
+  /**
+   * Create errors table for tracking application errors
+   */
+  async createErrorsTable() {
+    const tableName = 'vibecodingmachine-errors'
+
+    if (await this.tableExists(tableName)) {
+      console.log(`📋 Table ${tableName} already exists`)
+      return
+    }
+
+    const params = {
+      TableName: tableName,
+      KeySchema: [
+        { AttributeName: 'errorId', KeyType: 'HASH' }
+      ],
+      AttributeDefinitions: [
+        { AttributeName: 'errorId', AttributeType: 'S' }
+      ],
+      BillingMode: 'PAY_PER_REQUEST',
+      Tags: [
+        { Key: 'Application', Value: 'VibeCodingMachine' },
+        { Key: 'Environment', Value: process.env.NODE_ENV || 'development' }
+      ]
+    }
+
+    await this.client.send(new CreateTableCommand(params))
+    console.log(`✅ Created table: ${tableName}`)
+  }
+
+  /**
+   * Create feedback table for user comments
+   */
+  async createFeedbackTable() {
+    const tableName = 'vibecodingmachine-feedback'
+
+    if (await this.tableExists(tableName)) {
+      console.log(`📋 Table ${tableName} already exists`)
+      return
+    }
+
+    const params = {
+      TableName: tableName,
+      KeySchema: [
+        { AttributeName: 'feedbackId', KeyType: 'HASH' }
+      ],
+      AttributeDefinitions: [
+        { AttributeName: 'feedbackId', AttributeType: 'S' }
+      ],
+      BillingMode: 'PAY_PER_REQUEST',
+      Tags: [
+        { Key: 'Application', Value: 'VibeCodingMachine' },
+        { Key: 'Environment', Value: process.env.NODE_ENV || 'development' }
+      ]
+    }
+
+    await this.client.send(new CreateTableCommand(params))
+    console.log(`✅ Created table: ${tableName}`)
+  }
+
   /**
    * Check if a table exists
    */
@@ -272,10 +394,11 @@ class DatabaseMigrations {
    */
   async getAllTableStatus() {
     const tableNames = [
-      'vibecodingmachine-users',
       'vibecodingmachine-computers',
       'vibecodingmachine-projects',
-      'vibecodingmachine-activity'
+      'vibecodingmachine-activity',
+      'vibecodingmachine-errors',
+      'vibecodingmachine-feedback'
     ]
 
     const statuses = await Promise.all(

package/src/database/user-database-client.js

@@ -18,9 +18,21 @@ try {
 
 class UserDatabaseClient {
   constructor(apiBaseUrl = null) {
-    // Default to production API server, or use provided URL
-    this.apiBaseUrl = apiBaseUrl || process.env.VIBECODINGMACHINE_API_URL || 'https://api.vibecodingmachine.com';
+    // Check if we're in a development workspace
+    const fs = require('fs');
+    const path = require('path');
+    const rootDir = path.join(__dirname, '..', '..', '..', '..');
+    const isDevWorkspace = fs.existsSync(path.join(rootDir, '.git'));
+    
+    // Default to local dev server in development, production otherwise
+    if (isDevWorkspace && !apiBaseUrl && !process.env.VIBECODINGMACHINE_API_URL) {
+      this.apiBaseUrl = 'http://localhost:3457';
+    } else {
+      this.apiBaseUrl = apiBaseUrl || process.env.VIBECODINGMACHINE_API_URL || 'https://api.vibecodingmachine.com';
+    }
+    
     this.authToken = null;
+    console.log(require('chalk').gray(`UserDatabaseClient: Using API at ${this.apiBaseUrl}`));
   }
 
   /**
@@ -44,14 +56,36 @@ class UserDatabaseClient {
       headers.Authorization = `Bearer ${this.authToken}`;
     }
 
-    const response = await fetch(url, {
-      ...options,
-      headers
-    });
+    let response;
+    try {
+      response = await fetch(url, {
+        ...options,
+        headers
+      });
+    } catch (fetchError) {
+      const msg = `Connection failed: ${fetchError.message}`;
+      console.warn(`UserDatabaseClient: ${msg} [${url}]`);
+      throw new Error(msg);
+    }
 
     if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: 'Network error' }));
-      throw new Error(error.error || `HTTP ${response.status}`);
+      let errorDetail = '';
+      let bodyText = '';
+      try {
+        bodyText = await response.text();
+        try {
+          const errorJson = JSON.parse(bodyText);
+          errorDetail = errorJson.error || errorJson.message || '';
+        } catch (e) {
+          errorDetail = bodyText;
+        }
+      } catch (e) {
+        errorDetail = 'Could not read response body';
+      }
+
+      if (errorDetail.length > 200) errorDetail = errorDetail.substring(0, 200) + '...';
+      const errorMsg = errorDetail || `HTTP ${response.status}`;
+      throw new Error(errorMsg);
     }
 
     return response.json();
@@ -274,6 +308,27 @@ class UserDatabaseClient {
     return false; // Client-side can't check admin status
   }
 
+  /**
+   * Submit user feedback to the admin database
+   */
+  async submitFeedback(feedbackData) {
+    try {
+      const response = await this.apiRequest('/api/feedback', {
+        method: 'POST',
+        body: JSON.stringify({
+          timestamp: Date.now(),
+          hostname: os.hostname(),
+          platform: os.platform(),
+          ...feedbackData
+        })
+      });
+      return response;
+    } catch (error) {
+      console.warn('UserDatabase: submitFeedback failed:', error.message);
+      throw error;
+    }
+  }
+
   /**
    * Report an error to the admin database for tracking and fixing
    */

package/src/database/user-schema.js

@@ -115,6 +115,13 @@ class UserDatabase {
     return this.apiClient.isAdmin(userId)
   }
 
+  /**
+   * Submit user feedback to the admin database
+   */
+  async submitFeedback(feedbackData) {
+    return this.apiClient.submitFeedback(feedbackData)
+  }
+
   /**
    * Report an error to the admin database for tracking and fixing
    */