vibecodingmachine-core 2025.12.25-1541 → 2026.1.3-2209

package/ERROR_REPORTING_API.md

@@ -0,0 +1,212 @@
+# Error Reporting API Documentation
+
+## Overview
+
+The error reporting system automatically sends error information to the admin database when the CLI or GUI encounters errors. This allows the admin to track issues and use VibeCodingMachine to fix itself.
+
+## Client Implementation
+
+The client-side error reporting is implemented in:
+- `packages/core/src/utils/error-reporter.js` - Error reporter utility
+- `packages/core/src/database/user-database-client.js` - API client with `reportError()` method
+- `packages/cli/bin/vibecodingmachine.js` - Global error handlers
+
+## API Endpoint Required
+
+### POST /api/errors/report
+
+Reports an error to the admin database for tracking and fixing.
+
+**Authentication**: Required (Bearer token)
+
+**Request Body**:
+```json
+{
+  "message": "The \"path\" argument must be of type string. Received null",
+  "stack": "TypeError: The \"path\" argument must be of type string...",
+  "name": "TypeError",
+  "code": "ERR_INVALID_ARG_TYPE",
+  "timestamp": 1704326400000,
+  "hostname": "Jesses-MacBook-Pro.local",
+  "platform": "darwin",
+  "arch": "arm64",
+  "nodeVersion": "v18.17.0",
+  "context": {
+    "command": "addRemoteRequirement",
+    "computerId": "OLSEN2018PC",
+    "requirementText": "Fix the login bug",
+    "cwd": "/Users/jesseolsen/repos/mediawink/allnightai",
+    "argv": ["computer:add-requirement", "OLSEN2018PC", "Fix the login bug"]
+  }
+}
+```
+
+**Response**:
+```json
+{
+  "success": true,
+  "errorId": "err_abc123xyz"
+}
+```
+
+**Error Response**:
+```json
+{
+  "error": "Failed to report error",
+  "details": "Database connection failed"
+}
+```
+
+## Database Schema
+
+The error reports should be stored in a DynamoDB table with the following structure:
+
+**Table Name**: `vibecodingmachine-errors`
+
+**Primary Key**: 
+- `errorId` (String) - Unique error identifier (generated server-side)
+
+**Attributes**:
+- `userId` (String) - User ID from auth token
+- `email` (String) - User email
+- `timestamp` (Number) - Unix timestamp when error occurred
+- `message` (String) - Error message
+- `stack` (String) - Error stack trace
+- `name` (String) - Error name/type
+- `code` (String) - Error code (if available)
+- `hostname` (String) - Computer hostname
+- `platform` (String) - OS platform (darwin, win32, linux)
+- `arch` (String) - CPU architecture
+- `nodeVersion` (String) - Node.js version
+- `context` (Map) - Additional context about the error
+- `status` (String) - Error status: "NEW", "INVESTIGATING", "FIXED", "IGNORED"
+- `reportedAt` (Number) - Server timestamp when error was reported
+
+**GSI (Global Secondary Index)**:
+- `userId-timestamp-index` - For querying errors by user and time
+- `status-timestamp-index` - For querying errors by status
+
+## Server Implementation Required
+
+The API server needs to implement the `/api/errors/report` endpoint:
+
+```javascript
+// Example implementation (pseudo-code)
+app.post('/api/errors/report', authenticateToken, async (req, res) => {
+  try {
+    const userId = req.user.userId;
+    const email = req.user.email;
+    
+    const errorId = generateErrorId(); // e.g., 'err_' + crypto.randomBytes(8).toString('hex')
+    
+    const errorReport = {
+      errorId,
+      userId,
+      email,
+      ...req.body,
+      status: 'NEW',
+      reportedAt: Date.now()
+    };
+    
+    // Save to DynamoDB
+    await dynamodb.put({
+      TableName: 'vibecodingmachine-errors',
+      Item: errorReport
+    }).promise();
+    
+    res.json({ success: true, errorId });
+  } catch (error) {
+    res.status(500).json({ 
+      error: 'Failed to report error',
+      details: error.message 
+    });
+  }
+});
+```
+
+## Usage Examples
+
+### Automatic Error Reporting (Global Handlers)
+
+```javascript
+// In CLI entry point
+const { errorReporter } = require('vibecodingmachine-core');
+
+// Initialize with auth token
+const token = await auth.getAuthToken();
+errorReporter.setAuthToken(token);
+
+// Global handlers automatically report errors
+process.on('uncaughtException', async (error) => {
+  await errorReporter.reportError(error, { type: 'uncaughtException' });
+});
+```
+
+### Manual Error Reporting
+
+```javascript
+const { errorReporter } = require('vibecodingmachine-core');
+
+try {
+  // Some operation that might fail
+  await addRemoteRequirement(computerId, requirementText);
+} catch (error) {
+  // Report error with context
+  await errorReporter.reportError(error, {
+    command: 'addRemoteRequirement',
+    computerId,
+    requirementText
+  });
+  throw error; // Re-throw to show user
+}
+```
+
+### Wrapping Functions
+
+```javascript
+const { errorReporter } = require('vibecodingmachine-core');
+
+// Wrap a function to automatically report errors
+const safeFunction = errorReporter.wrapFunction(
+  async (arg1, arg2) => {
+    // Function implementation
+  },
+  { functionName: 'myFunction' }
+);
+```
+
+## Admin Dashboard Integration
+
+The admin dashboard should display error reports with:
+- List of all errors (filterable by status, user, date)
+- Error details view (message, stack, context)
+- Ability to change error status
+- Statistics (errors per day, most common errors)
+- Link to create a requirement/issue from an error
+
+## Privacy Considerations
+
+The error reporter automatically filters sensitive information:
+- Passwords, tokens, and secrets are removed from arguments
+- Only non-sensitive context is included
+- Stack traces may contain file paths but not file contents
+
+## Testing
+
+To test error reporting:
+
+```bash
+# Trigger an error in the CLI
+vcm computer:add-requirement TESTPC null
+
+# Check that error was reported
+# (Admin dashboard should show the error)
+```
+
+## Future Enhancements
+
+- Automatic error grouping (similar errors grouped together)
+- Error frequency tracking
+- Automatic issue creation in GitHub
+- Email notifications for critical errors
+- Error trend analysis

package/ERROR_REPORTING_USAGE.md

@@ -0,0 +1,380 @@
+# Error Reporting Usage Guide
+
+## Quick Start
+
+### 1. Import the Error Reporter
+
+```javascript
+const { errorReporter } = require('vibecodingmachine-core');
+```
+
+### 2. Initialize with Auth Token
+
+```javascript
+const auth = require('./utils/auth');
+const token = await auth.getAuthToken();
+if (token) {
+  errorReporter.setAuthToken(token);
+}
+```
+
+### 3. Report Errors
+
+```javascript
+try {
+  // Your code here
+  await someOperation();
+} catch (error) {
+  // Report error with context
+  await errorReporter.reportError(error, {
+    command: 'someOperation',
+    additionalContext: 'value'
+  });
+  throw error; // Re-throw to show user
+}
+```
+
+## Usage Patterns
+
+### Pattern 1: Try-Catch with Error Reporting
+
+```javascript
+async function addRemoteRequirement(computerId, requirementText) {
+  try {
+    // Operation that might fail
+    const result = await performOperation(computerId, requirementText);
+    return result;
+  } catch (error) {
+    console.error(chalk.red('✗ Operation failed:'), error.message);
+    
+    // Report error with context
+    await errorReporter.reportError(error, {
+      command: 'addRemoteRequirement',
+      computerId,
+      requirementText
+    });
+    
+    throw error; // Re-throw to maintain error flow
+  }
+}
+```
+
+### Pattern 2: Global Error Handlers
+
+```javascript
+// In your main entry point
+const { errorReporter } = require('vibecodingmachine-core');
+
+// Initialize with auth token
+const token = await auth.getAuthToken();
+if (token) {
+  errorReporter.setAuthToken(token);
+}
+
+// Setup global handlers
+process.on('uncaughtException', async (error) => {
+  console.error('Uncaught Exception:', error);
+  await errorReporter.reportError(error, { 
+    type: 'uncaughtException' 
+  });
+  process.exit(1);
+});
+
+process.on('unhandledRejection', async (error) => {
+  console.error('Unhandled Rejection:', error);
+  await errorReporter.reportError(error, { 
+    type: 'unhandledRejection' 
+  });
+  process.exit(1);
+});
+```
+
+### Pattern 3: Function Wrapping
+
+```javascript
+const { errorReporter } = require('vibecodingmachine-core');
+
+// Wrap a function to automatically report errors
+const safeOperation = errorReporter.wrapFunction(
+  async (arg1, arg2) => {
+    // Your function implementation
+    return await performOperation(arg1, arg2);
+  },
+  { 
+    functionName: 'performOperation',
+    module: 'operations'
+  }
+);
+
+// Use the wrapped function
+try {
+  await safeOperation('value1', 'value2');
+} catch (error) {
+  // Error was already reported automatically
+  console.error('Operation failed:', error.message);
+}
+```
+
+### Pattern 4: Conditional Error Reporting
+
+```javascript
+const { errorReporter } = require('vibecodingmachine-core');
+
+// Enable/disable error reporting
+errorReporter.setEnabled(true);  // Enable
+errorReporter.setEnabled(false); // Disable
+
+// Example: Disable in development
+if (process.env.NODE_ENV === 'development') {
+  errorReporter.setEnabled(false);
+}
+```
+
+## Context Best Practices
+
+### Good Context Examples
+
+```javascript
+// ✅ GOOD - Includes relevant context
+await errorReporter.reportError(error, {
+  command: 'addRemoteRequirement',
+  computerId: 'OLSEN2018PC',
+  requirementText: 'Fix the login bug',
+  operation: 'file_write'
+});
+
+// ✅ GOOD - Includes user action context
+await errorReporter.reportError(error, {
+  action: 'sync',
+  syncDirection: 'upload',
+  fileCount: 5,
+  retryAttempt: 2
+});
+```
+
+### Bad Context Examples
+
+```javascript
+// ❌ BAD - Includes sensitive information
+await errorReporter.reportError(error, {
+  password: 'secret123',  // Don't include passwords!
+  apiKey: 'abc123xyz'     // Don't include API keys!
+});
+
+// ❌ BAD - Too much unnecessary data
+await errorReporter.reportError(error, {
+  entireFileContents: fs.readFileSync('large-file.txt'),
+  allEnvironmentVariables: process.env
+});
+
+// ❌ BAD - No context at all
+await errorReporter.reportError(error);
+```
+
+## What Gets Reported Automatically
+
+The error reporter automatically includes:
+
+- **Error Information**:
+  - `message` - Error message
+  - `stack` - Stack trace
+  - `name` - Error type (TypeError, ReferenceError, etc.)
+  - `code` - Error code (if available)
+
+- **System Information**:
+  - `timestamp` - When error occurred
+  - `hostname` - Computer hostname
+  - `platform` - OS platform (darwin, win32, linux)
+  - `arch` - CPU architecture (x64, arm64)
+  - `nodeVersion` - Node.js version
+
+- **Context Information**:
+  - `cwd` - Current working directory
+  - `argv` - Command line arguments (filtered for sensitive data)
+  - Any custom context you provide
+
+## Privacy & Security
+
+The error reporter automatically filters sensitive information:
+
+- Passwords
+- Tokens
+- Secrets
+- API keys
+- Authentication credentials
+
+**Example**:
+```javascript
+// These will be filtered out automatically
+const args = ['--password=secret', '--token=abc123'];
+await errorReporter.reportError(error, { args });
+// Reported args will be filtered
+```
+
+## Testing Error Reporting
+
+### Test 1: Manual Error
+
+```javascript
+const { errorReporter } = require('vibecodingmachine-core');
+
+// Initialize
+const token = await auth.getAuthToken();
+errorReporter.setAuthToken(token);
+
+// Create and report a test error
+const testError = new Error('Test error for reporting');
+testError.code = 'TEST_ERROR';
+
+await errorReporter.reportError(testError, {
+  test: true,
+  purpose: 'testing error reporting system'
+});
+
+console.log('Test error reported successfully');
+```
+
+### Test 2: Trigger Real Error
+
+```bash
+# Trigger an error in the CLI
+vcm computer:add-requirement TESTPC null
+
+# Check console output for error reporting
+# Check admin dashboard for error report
+```
+
+## Troubleshooting
+
+### Error Not Being Reported
+
+1. **Check Authentication**:
+   ```javascript
+   const token = await auth.getAuthToken();
+   console.log('Auth token:', token ? 'Present' : 'Missing');
+   ```
+
+2. **Check Error Reporter Status**:
+   ```javascript
+   console.log('Error reporter enabled:', errorReporter.enabled);
+   ```
+
+3. **Check Network**:
+   - Verify API server is running
+   - Check API endpoint URL
+   - Verify authentication token is valid
+
+### Silent Failures
+
+Error reporting is designed to fail silently to avoid disrupting the user experience. Check console warnings:
+
+```javascript
+// Look for warnings like:
+// "Failed to report error: Network error"
+// "UserDatabase: reportError failed: ..."
+```
+
+## Integration with Other Systems
+
+### Electron App
+
+```javascript
+// In main process
+const { errorReporter } = require('vibecodingmachine-core');
+
+// Initialize with user's auth token
+const token = await getUserAuthToken();
+errorReporter.setAuthToken(token);
+
+// Report renderer process errors
+ipcMain.on('renderer-error', async (event, error) => {
+  await errorReporter.reportError(error, {
+    source: 'renderer',
+    window: event.sender.id
+  });
+});
+```
+
+### Web Application
+
+```javascript
+// In your React/Vue app
+import { errorReporter } from 'vibecodingmachine-core';
+
+// Initialize with user's auth token
+const token = await getAuthToken();
+errorReporter.setAuthToken(token);
+
+// Report errors in error boundary
+class ErrorBoundary extends React.Component {
+  componentDidCatch(error, errorInfo) {
+    errorReporter.reportError(error, {
+      source: 'react',
+      componentStack: errorInfo.componentStack
+    });
+  }
+}
+```
+
+## API Reference
+
+### `errorReporter.setAuthToken(token)`
+
+Set the authentication token for error reporting.
+
+**Parameters**:
+- `token` (string) - JWT authentication token
+
+**Example**:
+```javascript
+const token = await auth.getAuthToken();
+errorReporter.setAuthToken(token);
+```
+
+### `errorReporter.setEnabled(enabled)`
+
+Enable or disable error reporting.
+
+**Parameters**:
+- `enabled` (boolean) - True to enable, false to disable
+
+**Example**:
+```javascript
+errorReporter.setEnabled(false); // Disable in development
+```
+
+### `errorReporter.reportError(error, context)`
+
+Report an error to the admin database.
+
+**Parameters**:
+- `error` (Error) - Error object to report
+- `context` (Object) - Additional context about the error
+
+**Returns**: Promise<boolean> - True if reported successfully
+
+**Example**:
+```javascript
+await errorReporter.reportError(error, {
+  command: 'sync',
+  operation: 'upload'
+});
+```
+
+### `errorReporter.wrapFunction(fn, context)`
+
+Wrap a function to automatically report errors.
+
+**Parameters**:
+- `fn` (Function) - Function to wrap
+- `context` (Object) - Context to include in error reports
+
+**Returns**: Function - Wrapped function
+
+**Example**:
+```javascript
+const safeFunction = errorReporter.wrapFunction(
+  async (arg) => { /* ... */ },
+  { functionName: 'myFunction' }
+);
+```

package/__tests__/utils/git-branch-manager.test.js

@@ -0,0 +1,61 @@
+const { execSync } = require('child_process');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { isGitRepo, getCurrentBranch, hasUncommittedChanges } = require('../../src/utils/git-branch-manager');
+
+describe('git-branch-manager', () => {
+    let tempRepoPath;
+
+    beforeEach(async () => {
+        tempRepoPath = path.join(os.tmpdir(), `vcm-test-repo-${Date.now()}`);
+        await fs.ensureDir(tempRepoPath);
+    });
+
+    afterEach(async () => {
+        await fs.remove(tempRepoPath);
+    });
+
+    const initRepo = () => {
+        execSync('git init', { cwd: tempRepoPath, stdio: 'ignore' });
+        execSync('git config user.email "test@example.com"', { cwd: tempRepoPath, stdio: 'ignore' });
+        execSync('git config user.name "Test User"', { cwd: tempRepoPath, stdio: 'ignore' });
+    };
+
+    test('isGitRepo identifies git repositories', () => {
+        expect(isGitRepo(tempRepoPath)).toBe(false);
+        initRepo();
+        expect(isGitRepo(tempRepoPath)).toBe(true);
+    });
+
+    test('getCurrentBranch returns the current branch name', async () => {
+        initRepo();
+        // Must commit something for HEAD to exist
+        await fs.writeFile(path.join(tempRepoPath, 'initial.txt'), 'init');
+        execSync('git add .', { cwd: tempRepoPath, stdio: 'ignore' });
+        execSync('git commit -m "initial commit"', { cwd: tempRepoPath, stdio: 'ignore' });
+
+        const branch = getCurrentBranch(tempRepoPath);
+        expect(branch).toMatch(/^(main|master)$/);
+    });
+
+    test('hasUncommittedChanges detects dirty repository', async () => {
+        initRepo();
+        // Should be false initially (even if empty)
+        expect(hasUncommittedChanges(tempRepoPath)).toBe(false);
+
+        // Create a file
+        await fs.writeFile(path.join(tempRepoPath, 'test.txt'), 'hello');
+        // Untracked file counts as uncommitted change
+        expect(hasUncommittedChanges(tempRepoPath)).toBe(true);
+
+        // Commit it
+        execSync('git add .', { cwd: tempRepoPath, stdio: 'ignore' });
+        execSync('git commit -m "initial commit"', { cwd: tempRepoPath, stdio: 'ignore' });
+        expect(hasUncommittedChanges(tempRepoPath)).toBe(false);
+
+        // Modify it
+        await fs.appendFile(path.join(tempRepoPath, 'test.txt'), ' world');
+        expect(hasUncommittedChanges(tempRepoPath)).toBe(true);
+    });
+});

package/package.json

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

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

@@ -273,6 +273,32 @@ class UserDatabaseClient {
   async isAdmin(userId) {
     return false; // Client-side can't check admin status
   }
+
+  /**
+   * Report an error to the admin database for tracking and fixing
+   */
+  async reportError(errorData) {
+    try {
+      const errorReport = {
+        timestamp: Date.now(),
+        hostname: os.hostname(),
+        platform: os.platform(),
+        arch: os.arch(),
+        nodeVersion: process.version,
+        ...errorData
+      };
+
+      await this.apiRequest('/api/errors/report', {
+        method: 'POST',
+        body: JSON.stringify(errorReport)
+      });
+
+      return true;
+    } catch (error) {
+      console.warn('UserDatabase: reportError failed:', error.message);
+      return false;
+    }
+  }
   // Helper methods (same as server-side)
   generateUserId(email) {
     return crypto.createHash('sha256').update(email.toLowerCase()).digest('hex').substring(0, 16);

package/src/database/user-schema.js

@@ -115,6 +115,13 @@ class UserDatabase {
     return this.apiClient.isAdmin(userId)
   }
 
+  /**
+   * Report an error to the admin database for tracking and fixing
+   */
+  async reportError(errorData) {
+    return this.apiClient.reportError(errorData)
+  }
+
   // Helper methods - delegate to API client
   generateUserId(email) {
     return this.apiClient.generateUserId(email)