vibecodingmachine-core 2025.12.25-25 → 2026.1.22-1441

package/src/requirement-numbering.js

@@ -0,0 +1,164 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Get metadata file path for storing requirement counter
+ * @param {string} repoPath - Path to repository
+ * @returns {string} Path to metadata file
+ */
+function getMetadataPath(repoPath) {
+  return path.join(repoPath, '.vibecodingmachine', 'requirement-metadata.json');
+}
+
+/**
+ * Get the next requirement number for this repository
+ * @param {string} repoPath - Path to repository
+ * @returns {Promise<number>} Next requirement number
+ */
+async function getNextRequirementNumber(repoPath) {
+  const metadataPath = getMetadataPath(repoPath);
+
+  try {
+    await fs.ensureFile(metadataPath);
+    const metadata = await fs.readJson(metadataPath).catch(() => ({ lastRequirementNumber: 0 }));
+
+    const nextNumber = (metadata.lastRequirementNumber || 0) + 1;
+
+    // Save the incremented number
+    metadata.lastRequirementNumber = nextNumber;
+    await fs.writeJson(metadataPath, metadata, { spaces: 2 });
+
+    return nextNumber;
+  } catch (error) {
+    // Default to 1 if there's any error
+    console.error('Error getting next requirement number:', error.message);
+    return 1;
+  }
+}
+
+/**
+ * Set the last requirement number (used during initialization)
+ * @param {string} repoPath - Path to repository
+ * @param {number} lastNumber - Last requirement number
+ */
+async function setLastRequirementNumber(repoPath, lastNumber) {
+  const metadataPath = getMetadataPath(repoPath);
+
+  await fs.ensureFile(metadataPath);
+  const metadata = await fs.readJson(metadataPath).catch(() => ({}));
+  metadata.lastRequirementNumber = lastNumber;
+  await fs.writeJson(metadataPath, metadata, { spaces: 2 });
+}
+
+/**
+ * Extract requirement number from requirement title
+ * @param {string} title - Requirement title
+ * @returns {number|null} Requirement number or null if not found
+ */
+function extractRequirementNumber(title) {
+  const match = title.match(/^R(\d+):/);
+  return match ? parseInt(match[1], 10) : null;
+}
+
+/**
+ * Number all existing requirements in a requirements file
+ * @param {string} reqPath - Path to requirements file
+ * @param {string} repoPath - Path to repository
+ * @returns {Promise<number>} Number of requirements numbered
+ */
+async function numberAllRequirements(reqPath, repoPath) {
+  if (!await fs.pathExists(reqPath)) {
+    return 0;
+  }
+
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+  const newLines = [];
+
+  let requirementCount = 0;
+  let maxExistingNumber = 0;
+
+  // First pass: collect existing numbers and count requirements
+  for (const line of lines) {
+    if (line.trim().startsWith('###')) {
+      const title = line.trim().substring(3).trim();
+      const existingNumber = extractRequirementNumber(title);
+
+      if (existingNumber) {
+        maxExistingNumber = Math.max(maxExistingNumber, existingNumber);
+      } else {
+        // This requirement needs numbering
+        requirementCount++;
+      }
+    }
+  }
+
+  // Start numbering from max existing + 1
+  let currentNumber = maxExistingNumber + 1;
+  let numbered = 0;
+
+  // Second pass: add numbers to requirements that don't have them
+  for (const line of lines) {
+    if (line.trim().startsWith('###')) {
+      const title = line.trim().substring(3).trim();
+      const existingNumber = extractRequirementNumber(title);
+
+      if (!existingNumber) {
+        // Add number to this requirement
+        newLines.push(`### R${currentNumber}: ${title}`);
+        currentNumber++;
+        numbered++;
+      } else {
+        // Keep existing numbered requirement as-is
+        newLines.push(line);
+      }
+    } else {
+      newLines.push(line);
+    }
+  }
+
+  // Save the updated file
+  await fs.writeFile(reqPath, newLines.join('\n'));
+
+  // Update metadata with the highest number used
+  await setLastRequirementNumber(repoPath, currentNumber - 1);
+
+  return numbered;
+}
+
+/**
+ * Create a git branch name from requirement number and title
+ * @param {number} reqNumber - Requirement number
+ * @param {string} title - Requirement title
+ * @returns {string} Branch name (e.g., "R1_email_system")
+ */
+function createBranchName(reqNumber, title) {
+  // Remove requirement number from title if present
+  let cleanTitle = title.replace(/^R\d+:\s*/, '').trim();
+
+  // Take first few words (up to 3-4 words, max 30 chars)
+  const words = cleanTitle.split(/\s+/);
+  let branchSuffix = '';
+
+  for (const word of words) {
+    const candidate = branchSuffix ? `${branchSuffix}_${word}` : word;
+    if (candidate.length > 30) break;
+    branchSuffix = candidate;
+  }
+
+  // Clean up branch suffix: lowercase, remove special chars
+  branchSuffix = branchSuffix
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '');
+
+  return branchSuffix ? `R${reqNumber}_${branchSuffix}` : `R${reqNumber}`;
+}
+
+module.exports = {
+  getNextRequirementNumber,
+  setLastRequirementNumber,
+  extractRequirementNumber,
+  numberAllRequirements,
+  createBranchName
+};

package/src/sync/aws-setup.js

@@ -116,12 +116,12 @@ async function setupCognitoWithGoogle() {
     
     // Add Google OAuth provider if not already configured
     try {
-      const googleClientId = process.env.GOOGLE_CLIENT_ID;
+      const googleClientId = process.env.REACT_APP_GOOGLE_CLIENT_ID;
       const googleClientSecret = process.env.GOOGLE_CLIENT_SECRET;
       
       if (!googleClientId || !googleClientSecret) {
         console.log('⚠ Google OAuth credentials not provided. Skipping Google provider setup.');
-        console.log('  Set GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET environment variables.');
+        console.log('  Set REACT_APP_GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET environment variables.');
         return { userPoolId: existingPoolId, status: 'existing' };
       }
       
@@ -198,7 +198,7 @@ async function setupCognitoWithGoogle() {
     console.log(`✓ Created Cognito User Pool: ${userPoolId}`);
     
     // Add Google OAuth provider first (if credentials provided)
-    const googleClientId = process.env.GOOGLE_CLIENT_ID;
+    const googleClientId = process.env.REACT_APP_GOOGLE_CLIENT_ID;
     const googleClientSecret = process.env.GOOGLE_CLIENT_SECRET;
     
     let supportedProviders = ['COGNITO'];
@@ -231,7 +231,7 @@ async function setupCognitoWithGoogle() {
       }
     } else {
       console.log('⚠ Google OAuth credentials not provided');
-      console.log('  Set GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET to enable Google login');
+      console.log('  Set REACT_APP_GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET to enable Google login');
     }
     
     // Create app client

package/src/utils/admin-utils.js

@@ -0,0 +1,33 @@
+/**
+ * Admin Utilities for VibeCodingMachine
+ */
+
+const ADMIN_EMAILS = [
+    'jesse.d.olsen@gmail.com'
+];
+
+/**
+ * Check if an email belongs to an administrator
+ * @param {string} email - The email to check
+ * @returns {boolean} True if the email is an admin email
+ */
+function isAdmin(email) {
+    if (!email) return false;
+    return ADMIN_EMAILS.includes(email.toLowerCase().trim());
+}
+
+/**
+ * Check if the application should automatically start implementation
+ * based on the user's email (admin feedback)
+ * @param {string} email - The email of the feedback sender
+ * @returns {boolean} True if auto-start should be triggered
+ */
+function shouldAutoStart(email) {
+    return isAdmin(email);
+}
+
+module.exports = {
+    isAdmin,
+    shouldAutoStart,
+    ADMIN_EMAILS
+};

package/src/utils/error-reporter.js

@@ -0,0 +1,117 @@
+/**
+ * Global Error Reporter for VibeCodingMachine
+ * 
+ * Automatically reports errors to the admin database for tracking and fixing.
+ * This helps the admin know about issues and use VibeCodingMachine to fix itself.
+ */
+
+class ErrorReporter {
+  constructor() {
+    this.enabled = true;
+    this.db = null;
+    
+    try {
+      const UserDatabase = require('../database/user-schema');
+      this.db = new UserDatabase();
+    } catch (error) {
+      console.warn('ErrorReporter: Failed to initialize UserDatabase:', error.message);
+      this.enabled = false;
+    }
+  }
+
+  /**
+   * Set authentication token for error reporting
+   */
+  setAuthToken(token) {
+    if (this.db) {
+      this.db.setAuthToken(token);
+    }
+  }
+
+  /**
+   * Enable or disable error reporting
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+
+  /**
+   * Report an error to the admin database
+   */
+  async reportError(error, context = {}) {
+    if (!this.enabled) {
+      return false;
+    }
+
+    try {
+      const errorData = {
+        message: error.message || String(error),
+        stack: error.stack || '',
+        name: error.name || 'Error',
+        code: error.code || '',
+        context: {
+          ...context,
+          cwd: process.cwd(),
+          argv: process.argv.slice(2).filter(arg => 
+            !arg.includes('password') && 
+            !arg.includes('token') &&
+            !arg.includes('secret')
+          )
+        }
+      };
+
+      await this.db.reportError(errorData);
+      return true;
+    } catch (reportError) {
+      // Silently fail - don't block the application
+      console.warn('Failed to report error:', reportError.message);
+      return false;
+    }
+  }
+
+  /**
+   * Wrap a function to automatically report errors
+   */
+  wrapFunction(fn, context = {}) {
+    return async (...args) => {
+      try {
+        return await fn(...args);
+      } catch (error) {
+        await this.reportError(error, {
+          ...context,
+          functionName: fn.name,
+          args: args.filter(arg => 
+            typeof arg !== 'object' || 
+            !JSON.stringify(arg).match(/password|token|secret/i)
+          )
+        });
+        throw error;
+      }
+    };
+  }
+
+  /**
+   * Create a global error handler for uncaught exceptions
+   */
+  setupGlobalHandlers() {
+    process.on('uncaughtException', async (error) => {
+      await this.reportError(error, {
+        type: 'uncaughtException'
+      });
+    });
+
+    process.on('unhandledRejection', async (error) => {
+      await this.reportError(error, {
+        type: 'unhandledRejection'
+      });
+    });
+  }
+}
+
+// Singleton instance
+const errorReporter = new ErrorReporter();
+
+module.exports = {
+  ErrorReporter,
+  errorReporter
+};

package/src/utils/git-branch-manager.js

@@ -0,0 +1,278 @@
+const { execSync } = require('child_process');
+const path = require('path');
+const { createBranchName, extractRequirementNumber } = require('../requirement-numbering');
+
+/**
+ * Check if a directory is a git repository
+ * @param {string} repoPath - Path to check
+ * @returns {boolean} True if it's a git repo
+ */
+function isGitRepo(repoPath) {
+  try {
+    execSync('git rev-parse --git-dir', {
+      cwd: repoPath,
+      stdio: 'ignore'
+    });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Get current git branch name
+ * @param {string} repoPath - Path to repository
+ * @returns {string|null} Current branch name or null
+ */
+function getCurrentBranch(repoPath) {
+  try {
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+      cwd: repoPath,
+      encoding: 'utf8'
+    }).trim();
+    return branch;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Create a feature branch for a requirement
+ * @param {string} repoPath - Path to repository
+ * @param {string} requirementTitle - Full requirement title (e.g., "R1: Email System")
+ * @returns {Promise<{success: boolean, branchName: string|null, parentBranch: string|null, error: string|null}>}
+ */
+async function createRequirementBranch(repoPath, requirementTitle) {
+  try {
+    if (!isGitRepo(repoPath)) {
+      return {
+        success: false,
+        branchName: null,
+        parentBranch: null,
+        error: 'Not a git repository'
+      };
+    }
+
+    // Extract requirement number from title
+    const reqNumber = extractRequirementNumber(requirementTitle);
+    if (!reqNumber) {
+      return {
+        success: false,
+        branchName: null,
+        parentBranch: null,
+        error: 'Requirement number not found in title'
+      };
+    }
+
+    // Get parent branch (current branch before creating new one)
+    const parentBranch = getCurrentBranch(repoPath);
+    if (!parentBranch) {
+      return {
+        success: false,
+        branchName: null,
+        parentBranch: null,
+        error: 'Could not determine current branch'
+      };
+    }
+
+    // Create branch name
+    const branchName = createBranchName(reqNumber, requirementTitle);
+
+    // Check if branch already exists
+    try {
+      execSync(`git rev-parse --verify ${branchName}`, {
+        cwd: repoPath,
+        stdio: 'ignore'
+      });
+
+      // Branch exists, check it out
+      execSync(`git checkout ${branchName}`, {
+        cwd: repoPath,
+        stdio: 'ignore'
+      });
+
+      return {
+        success: true,
+        branchName,
+        parentBranch,
+        error: null,
+        alreadyExists: true
+      };
+    } catch (error) {
+      // Branch doesn't exist, create it
+      execSync(`git checkout -b ${branchName}`, {
+        cwd: repoPath,
+        stdio: 'ignore'
+      });
+
+      return {
+        success: true,
+        branchName,
+        parentBranch,
+        error: null,
+        alreadyExists: false
+      };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      branchName: null,
+      parentBranch: null,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Merge a requirement branch back to parent and delete it
+ * @param {string} repoPath - Path to repository
+ * @param {string} requirementTitle - Full requirement title
+ * @param {string} parentBranch - Parent branch to merge into
+ * @returns {Promise<{success: boolean, error: string|null}>}
+ */
+async function mergeRequirementBranch(repoPath, requirementTitle, parentBranch = 'main') {
+  try {
+    if (!isGitRepo(repoPath)) {
+      return { success: false, error: 'Not a git repository' };
+    }
+
+    // Extract requirement number
+    const reqNumber = extractRequirementNumber(requirementTitle);
+    if (!reqNumber) {
+      return { success: false, error: 'Requirement number not found in title' };
+    }
+
+    // Create branch name
+    const branchName = createBranchName(reqNumber, requirementTitle);
+
+    // Checkout parent branch
+    execSync(`git checkout ${parentBranch}`, {
+      cwd: repoPath,
+      stdio: 'ignore'
+    });
+
+    // Merge the feature branch
+    execSync(`git merge --no-ff ${branchName} -m "Merge ${branchName}"`, {
+      cwd: repoPath,
+      stdio: 'ignore'
+    });
+
+    // Delete the feature branch
+    execSync(`git branch -d ${branchName}`, {
+      cwd: repoPath,
+      stdio: 'ignore'
+    });
+
+    return { success: true, error: null };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Remove a feature by reverting its merge commit
+ * @param {string} repoPath - Path to repository
+ * @param {string} requirementTitle - Full requirement title
+ * @returns {Promise<{success: boolean, error: string|null}>}
+ */
+async function removeRequirementFeature(repoPath, requirementTitle) {
+  try {
+    if (!isGitRepo(repoPath)) {
+      return { success: false, error: 'Not a git repository' };
+    }
+
+    // Extract requirement number
+    const reqNumber = extractRequirementNumber(requirementTitle);
+    if (!reqNumber) {
+      return { success: false, error: 'Requirement number not found in title' };
+    }
+
+    // Create branch name to search for
+    const branchName = createBranchName(reqNumber, requirementTitle);
+
+    // Find the merge commit for this branch
+    const mergeCommit = execSync(
+      `git log --grep="Merge ${branchName}" --oneline --format="%H" -1`,
+      {
+        cwd: repoPath,
+        encoding: 'utf8'
+      }
+    ).trim();
+
+    if (!mergeCommit) {
+      return { success: false, error: 'Merge commit not found for this requirement' };
+    }
+
+    // Revert the merge commit
+    execSync(`git revert -m 1 ${mergeCommit} --no-edit`, {
+      cwd: repoPath,
+      stdio: 'ignore'
+    });
+
+    return { success: true, error: null };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Get list of all requirement branches
+ * @param {string} repoPath - Path to repository
+ * @returns {Array<{branchName: string, reqNumber: number}>}
+ */
+function listRequirementBranches(repoPath) {
+  try {
+    if (!isGitRepo(repoPath)) {
+      return [];
+    }
+
+    const branches = execSync('git branch --list "R*"', {
+      cwd: repoPath,
+      encoding: 'utf8'
+    });
+
+    return branches
+      .split('\n')
+      .map(b => b.trim().replace(/^\*\s*/, ''))
+      .filter(b => b && b.startsWith('R'))
+      .map(b => {
+        const match = b.match(/^R(\d+)/);
+        return {
+          branchName: b,
+          reqNumber: match ? parseInt(match[1], 10) : 0
+        };
+      })
+      .filter(b => b.reqNumber > 0)
+      .sort((a, b) => a.reqNumber - b.reqNumber);
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * Check if there are any uncommitted changes in the repository
+ * @param {string} repoPath - Path to repository
+ * @returns {boolean} True if there are uncommitted changes
+ */
+function hasUncommittedChanges(repoPath) {
+  try {
+    // Check for staged and unstaged changes
+    const status = execSync('git status --porcelain', {
+      cwd: repoPath,
+      encoding: 'utf8'
+    }).trim();
+    return status.length > 0;
+  } catch (error) {
+    return false;
+  }
+}
+
+module.exports = {
+  isGitRepo,
+  getCurrentBranch,
+  hasUncommittedChanges,
+  createRequirementBranch,
+  mergeRequirementBranch,
+  removeRequirementFeature,
+  listRequirementBranches
+};