vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/analysis/strategy-generator.js

@@ -8,30 +8,13 @@
 const path = require('path');
 const RefactoringConfig = require('../config/refactoring-config');
 
-/**
- * Strategy types
- */
 const STRATEGY_TYPES = {
-  SPLIT_FILE: 'split_file',
-  EXTRACT_FUNCTIONS: 'extract_functions',
-  EXTRACT_CLASSES: 'extract_classes',
-  EXTRACT_UTILITIES: 'extract_utilities',
-  EXTRACT_CONSTANTS: 'extract_constants',
-  REORGANIZE_IMPORTS: 'reorganize_imports',
-  MERGE_SMALL_FILES: 'merge_small_files',
-  RESTRUCTURE_DIRECTORIES: 'restructure_directories',
-  OPTIMIZE_DEPENDENCIES: 'optimize_dependencies'
+  SPLIT_FILE: 'split_file', EXTRACT_FUNCTIONS: 'extract_functions', EXTRACT_CLASSES: 'extract_classes',
+  EXTRACT_UTILITIES: 'extract_utilities', EXTRACT_CONSTANTS: 'extract_constants', REORGANIZE_IMPORTS: 'reorganize_imports',
+  MERGE_SMALL_FILES: 'merge_small_files', RESTRUCTURE_DIRECTORIES: 'restructure_directories', OPTIMIZE_DEPENDENCIES: 'optimize_dependencies'
 };
 
-/**
- * Priority levels
- */
-const PRIORITY_LEVELS = {
-  CRITICAL: 'critical',
-  HIGH: 'high',
-  MEDIUM: 'medium',
-  LOW: 'low'
-};
+const PRIORITY_LEVELS = { CRITICAL: 'critical', HIGH: 'high', MEDIUM: 'medium', LOW: 'low' };
 
 /**
  * Refactoring strategy class
@@ -58,29 +41,12 @@ class RefactoringStrategy {
     };
   }
 
-  generateId() {
-    return `strategy_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  addStep(step) {
-    this.steps.push(step);
-  }
-
-  addDependency(dependency) {
-    this.dependencies.push(dependency);
-  }
-
-  setEstimatedEffort(effort) {
-    this.estimatedEffort = effort;
-  }
-
-  setRiskLevel(risk) {
-    this.riskLevel = risk;
-  }
-
-  setImpact(impact) {
-    this.impact = { ...this.impact, ...impact };
-  }
+  generateId() { return `strategy_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`; }
+  addStep(step) { this.steps.push(step); }
+  addDependency(dependency) { this.dependencies.push(dependency); }
+  setEstimatedEffort(effort) { this.estimatedEffort = effort; }
+  setRiskLevel(risk) { this.riskLevel = risk; }
+  setImpact(impact) { this.impact = { ...this.impact, ...impact }; }
 }
 
 /**
@@ -677,10 +643,9 @@ class StrategyGenerator {
    * Estimate effort for file splitting
    */
   estimateSplitEffort(fileAnalysis, splitPoints) {
-    const baseEffort = 5; // Base effort for any split
-    const splitEffort = splitPoints.length * 2; // 2 effort per split point
-    const sizeEffort = Math.ceil(fileAnalysis.lineCount / 100); // 1 effort per 100 lines
-    
+    const baseEffort = 5;
+    const splitEffort = splitPoints.length * 2;
+    const sizeEffort = Math.ceil(fileAnalysis.lineCount / 100);
     return baseEffort + splitEffort + sizeEffort;
   }
 
@@ -689,20 +654,16 @@ class StrategyGenerator {
    */
   assessSplitRisk(fileAnalysis) {
     let risk = 'medium';
-    
     if (fileAnalysis.lineCount > 1000) {
       risk = 'high';
     } else if (fileAnalysis.lineCount < 300) {
       risk = 'low';
     }
-    
-    // Consider complexity
     if (fileAnalysis.categorization && fileAnalysis.categorization.complexity === 'VERY_COMPLEX') {
       risk = 'high';
     } else if (fileAnalysis.categorization && fileAnalysis.categorization.complexity === 'SIMPLE') {
       risk = 'low';
     }
-    
     return risk;
   }
 
@@ -724,18 +685,15 @@ class StrategyGenerator {
    */
   groupSmallFiles(smallFiles) {
     const groups = {};
-    
     for (const file of smallFiles) {
       const pkg = this.extractPackage(file.path);
       const type = this.extractFileType(file.path);
       const key = `${pkg}/${type}`;
-      
       if (!groups[key]) {
         groups[key] = [];
       }
       groups[key].push(file);
     }
-
     return groups;
   }
 
@@ -756,20 +714,12 @@ class StrategyGenerator {
            basename.includes('util') ? 'utility' : 'main';
   }
 
-  /**
-   * Prioritize strategies
-   */
   prioritizeStrategies() {
     const priorityOrder = {
-      [PRIORITY_LEVELS.CRITICAL]: 0,
-      [PRIORITY_LEVELS.HIGH]: 1,
-      [PRIORITY_LEVELS.MEDIUM]: 2,
-      [PRIORITY_LEVELS.LOW]: 3
+      [PRIORITY_LEVELS.CRITICAL]: 0, [PRIORITY_LEVELS.HIGH]: 1,
+      [PRIORITY_LEVELS.MEDIUM]: 2, [PRIORITY_LEVELS.LOW]: 3
     };
-
-    this.strategies.sort((a, b) => {
-      return priorityOrder[a.priority] - priorityOrder[b.priority];
-    });
+    this.strategies.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
   }
 
   /**

package/src/analysis/type-priority-calculator.js

@@ -0,0 +1,18 @@
+/**
+ * Type Priority Calculator
+ */
+
+function calculateTypePriority(data) {
+  // Calculate type priority
+  const typePriority = 0;
+  if (data.type === 'high') {
+    typePriority += 10;
+  } else if (data.type === 'medium') {
+    typePriority += 5;
+  } else {
+    typePriority += 1;
+  }
+  return typePriority;
+}
+
+export { calculateTypePriority };

package/src/analysis/urgency-priority-calculator.js

@@ -0,0 +1,18 @@
+/**
+ * Urgency Priority Calculator
+ */
+
+function calculateUrgencyPriority(data) {
+  // Calculate urgency priority
+  const urgencyPriority = 0;
+  if (data.urgency === 'high') {
+    urgencyPriority += 20;
+  } else if (data.urgency === 'medium') {
+    urgencyPriority += 10;
+  } else {
+    urgencyPriority += 2;
+  }
+  return urgencyPriority;
+}
+
+export { calculateUrgencyPriority };

package/src/auto-mode/AutoModeBusinessLogic.js

@@ -70,8 +70,6 @@ class AutoModeBusinessLogic {
    */
   getAvailableProviders(savedConfig) {
     const providers = [];
-
-    // Check for Groq (current primary)
     const groqApiKey = process.env.GROQ_API_KEY || savedConfig.groqApiKey;
     if (groqApiKey && groqApiKey.trim()) {
       providers.push({
@@ -80,8 +78,6 @@ class AutoModeBusinessLogic {
         apiKey: groqApiKey
       });
     }
-
-    // Check for Anthropic (Claude)
     const anthropicApiKey = process.env.ANTHROPIC_API_KEY || savedConfig.anthropicApiKey;
     if (anthropicApiKey && anthropicApiKey.trim()) {
       providers.push({
@@ -90,8 +86,6 @@ class AutoModeBusinessLogic {
         apiKey: anthropicApiKey
       });
     }
-
-    // Check for OpenAI
     const openaiApiKey = process.env.OPENAI_API_KEY || savedConfig.openaiApiKey;
     if (openaiApiKey && openaiApiKey.trim()) {
       providers.push({
@@ -100,13 +94,10 @@ class AutoModeBusinessLogic {
         apiKey: openaiApiKey
       });
     }
-
-    // Always add Ollama as fallback (local, no API key needed)
     providers.push({
       provider: 'ollama',
       model: 'qwen2.5-coder:32b'
     });
-
     return providers;
   }
 
@@ -119,11 +110,9 @@ class AutoModeBusinessLogic {
     try {
       const { getRequirementsPath } = require('../index');
       const reqPath = await getRequirementsPath(repoPath);
-
       if (!reqPath || !await fs.pathExists(reqPath)) {
         return { isDone: false, actuallyComplete: false };
       }
-
       const content = await fs.readFile(reqPath, 'utf8');
       const lines = content.split('\n');
 
@@ -236,30 +225,21 @@ class AutoModeBusinessLogic {
           updatedLines.push(line);
           continue;
         }
-
-        // Find not yet completed section
         if (line.includes('## ⏳ Requirements not yet completed')) {
           inNotYetCompleted = true;
           inVerifiedSection = false;
           updatedLines.push(line);
           continue;
         }
-
-        // Check if we're in verified section and this is requirement to move
         if (inVerifiedSection && trimmed.startsWith('- ')) {
           const lineRequirement = line.substring(2).trim();
-          // Remove date prefix if present (format: "2025-11-05: **requirement**")
           const cleanRequirement = lineRequirement.replace(/^\d{4}-\d{2}-\d{2}:\s*\*\*/, '').replace(/\*\*$/, '').trim();
           const cleanRequirementText = requirementText.replace(/\*\*/g, '').trim();
-
           if (lineRequirement.includes(requirementText) || cleanRequirement === cleanRequirementText) {
-            // Skip this line (don't add it to updatedLines)
             requirementFound = true;
             continue;
           }
         }
-
-        // If we're in not yet completed section and haven't added requirement yet, add it at the top
         if (inNotYetCompleted && !requirementFound && trimmed.startsWith('- ')) {
           // Add the requirement before the first existing requirement
           const newUpdatedLines = lines.slice(0, i);
@@ -269,17 +249,12 @@ class AutoModeBusinessLogic {
           await fs.writeFile(reqPath, newUpdatedLines.join('\n'));
           return { success: true };
         }
-
-        // Reset section flags when hitting new sections
         if (trimmed.startsWith('##')) {
           inVerifiedSection = false;
           inNotYetCompleted = false;
         }
-
         updatedLines.push(line);
       }
-
-      // If requirement wasn't found in verified section, try to add it to not yet completed anyway
       if (!requirementFound) {
         // Find the not yet completed section and add requirement at the top
         const newUpdatedLines = lines.slice();
@@ -797,21 +772,8 @@ class AutoModeBusinessLogic {
     }
   }
 
-  /**
-   * Update auto mode state
-   * @param {Object} newState - New state to merge
-   */
-  updateState(newState) {
-    Object.assign(this.state, newState);
-  }
-
-  /**
-   * Get current auto mode state
-   * @returns {Object} Current state
-   */
-  getState() {
-    return { ...this.state };
-  }
+  updateState(newState) { Object.assign(this.state, newState); }
+  getState() { return { ...this.state }; }
 
   /**
    * Reset auto mode state

package/src/commands/disable-requirement.js

@@ -0,0 +1,60 @@
+const RUICommand = require('./base');
+const { disableRequirement } = require('../utils/requirement-enable-disable');
+
+/**
+ * RUI Command: Disable Requirement
+ * Implements requirement disable action following RUI pattern
+ */
+
+class DisableRequirementCommand extends RUICommand {
+  constructor() {
+    super({
+      verb: 'PUT',
+      resource: 'requirements',
+      description: 'Disable a specific requirement',
+      shortcuts: ['rd', 'disable req', 'put req disable'],
+      synonyms: ['disable', 'deactivate'],
+      parameters: [
+        {
+          name: 'requirementText',
+          type: 'string',
+          required: true,
+          description: 'Exact text of the requirement to disable'
+        }
+      ],
+      examples: [
+        'app disable requirement "Add user authentication"',
+        'app rd "Add user authentication"',
+        'app put requirements "Add user authentication" --status disabled'
+      ]
+    });
+  }
+
+  async execute(params = {}) {
+    // Validate required parameters
+    if (!params.requirementText) {
+      throw new Error('Required parameter missing: requirementText');
+    }
+
+    // Call the core disable function
+    const result = await disableRequirement(params.requirementText);
+    
+    if (!result.success) {
+      throw new Error(result.message);
+    }
+    
+    return {
+      success: true,
+      data: {
+        requirement: {
+          text: params.requirementText,
+          status: 'disabled',
+          disabledAt: new Date().toISOString()
+        }
+      },
+      message: result.message
+    };
+  }
+}
+
+module.exports = DisableRequirementCommand;

package/src/commands/disable-spec.js

@@ -0,0 +1,60 @@
+const RUICommand = require('./base');
+const { disableSpec } = require('../utils/specification-enable-disable');
+
+/**
+ * RUI Command: Disable Spec
+ * Implements spec disable action following RUI pattern
+ */
+
+class DisableSpecCommand extends RUICommand {
+  constructor() {
+    super({
+      verb: 'PUT',
+      resource: 'specs',
+      description: 'Disable a specific specification',
+      shortcuts: ['sd', 'disable sp', 'put sp disable'],
+      synonyms: ['disable', 'deactivate'],
+      parameters: [
+        {
+          name: 'specId',
+          type: 'string',
+          required: true,
+          description: 'ID of the specification to disable (e.g., "001-agent-defaults")'
+        }
+      ],
+      examples: [
+        'app disable spec 001-agent-defaults',
+        'app sd 001-agent-defaults',
+        'app put specs 001-agent-defaults --status disabled'
+      ]
+    });
+  }
+
+  async execute(params = {}) {
+    // Validate required parameters
+    if (!params.specId) {
+      throw new Error('Required parameter missing: specId');
+    }
+
+    // Call the core disable function
+    const result = await disableSpec(params.specId);
+    
+    if (!result.success) {
+      throw new Error(result.message);
+    }
+    
+    return {
+      success: true,
+      data: {
+        spec: {
+          id: params.specId,
+          status: 'disabled',
+          disabledAt: new Date().toISOString()
+        }
+      },
+      message: result.message
+    };
+  }
+}
+
+module.exports = DisableSpecCommand;

package/src/commands/enable-requirement.js

@@ -0,0 +1,60 @@
+const RUICommand = require('./base');
+const { enableRequirement } = require('../utils/requirement-enable-disable');
+
+/**
+ * RUI Command: Enable Requirement
+ * Implements requirement enable action following RUI pattern
+ */
+
+class EnableRequirementCommand extends RUICommand {
+  constructor() {
+    super({
+      verb: 'PUT',
+      resource: 'requirements',
+      description: 'Enable a specific requirement',
+      shortcuts: ['re', 'enable req', 'put req enable'],
+      synonyms: ['enable', 'activate'],
+      parameters: [
+        {
+          name: 'requirementText',
+          type: 'string',
+          required: true,
+          description: 'Exact text of the requirement to enable'
+        }
+      ],
+      examples: [
+        'app enable requirement "Add user authentication"',
+        'app re "Add user authentication"',
+        'app put requirements "Add user authentication" --status enabled'
+      ]
+    });
+  }
+
+  async execute(params = {}) {
+    // Validate required parameters
+    if (!params.requirementText) {
+      throw new Error('Required parameter missing: requirementText');
+    }
+
+    // Call the core enable function
+    const result = await enableRequirement(params.requirementText);
+    
+    if (!result.success) {
+      throw new Error(result.message);
+    }
+    
+    return {
+      success: true,
+      data: {
+        requirement: {
+          text: params.requirementText,
+          status: 'enabled',
+          enabledAt: new Date().toISOString()
+        }
+      },
+      message: result.message
+    };
+  }
+}
+
+module.exports = EnableRequirementCommand;

package/src/commands/enable-spec.js

@@ -0,0 +1,60 @@
+const RUICommand = require('./base');
+const { enableSpec } = require('../utils/specification-enable-disable');
+
+/**
+ * RUI Command: Enable Spec
+ * Implements spec enable action following RUI pattern
+ */
+
+class EnableSpecCommand extends RUICommand {
+  constructor() {
+    super({
+      verb: 'PUT',
+      resource: 'specs',
+      description: 'Enable a specific specification',
+      shortcuts: ['se', 'enable sp', 'put sp enable'],
+      synonyms: ['enable', 'activate'],
+      parameters: [
+        {
+          name: 'specId',
+          type: 'string',
+          required: true,
+          description: 'ID of the specification to enable (e.g., "001-agent-defaults")'
+        }
+      ],
+      examples: [
+        'app enable spec 001-agent-defaults',
+        'app se 001-agent-defaults',
+        'app put specs 001-agent-defaults --status enabled'
+      ]
+    });
+  }
+
+  async execute(params = {}) {
+    // Validate required parameters
+    if (!params.specId) {
+      throw new Error('Required parameter missing: specId');
+    }
+
+    // Call the core enable function
+    const result = await enableSpec(params.specId);
+    
+    if (!result.success) {
+      throw new Error(result.message);
+    }
+    
+    return {
+      success: true,
+      data: {
+        spec: {
+          id: params.specId,
+          status: 'enabled',
+          enabledAt: new Date().toISOString()
+        }
+      },
+      message: result.message || `Specification ${params.specId} enabled successfully`
+    };
+  }
+}
+
+module.exports = EnableSpecCommand;

package/src/commands/registry.js

@@ -24,12 +24,7 @@ class RUICommandRegistry {
     // Validate command structure
     this.validateCommand(command);
     
-    this.commands.set(key, {
-      ...command,
-      shortcuts: command.shortcuts || [],
-      synonyms: command.synonyms || [],
-      registeredAt: new Date()
-    });
+    this.commands.set(key, command);
   }
 
   /**

package/src/commands/requirements.js

@@ -16,7 +16,7 @@ class ListRequirementsCommand extends RUICommand {
       handler: async (params = {}) => {
         // Import requirements parser to get real requirements data
         const { parseRequirementsFile } = require('../utils/requirements-parser');
-        const { getOrCreateRequirementsFilePath } = require('../utils/requirement-helpers');
+        const { getRequirementsFilePath, createRequirementsFile, requirementsFileExists } = require('../utils/requirement-helpers');
         const { getTodoSpecifications } = require('../utils/specification-helpers');
         const fs = require('fs-extra');
 
@@ -24,7 +24,13 @@ class ListRequirementsCommand extends RUICommand {
 
         try {
           // Get the requirements file path
-          const reqPath = await getOrCreateRequirementsFilePath(repoPath);
+          let reqPath = await getRequirementsFilePath(repoPath);
+          
+          // Create file if it doesn't exist
+          if (!await requirementsFileExists(repoPath)) {
+            await createRequirementsFile(repoPath);
+            reqPath = await getRequirementsFilePath(repoPath);
+          }
 
           // Load todo specifications in parallel with requirements check
           const todoSpecifications = await getTodoSpecifications(repoPath);

package/src/ide-integration/applescript-manager.cjs

@@ -1784,34 +1784,19 @@ class AppleScriptManager {
               key code 53
               delay 0.5
 
-              -- Try multiple approaches to focus Cascade chat input
-              -- Approach 1: Cmd+Shift+L (original)
-              keystroke "l" using {command down, shift down}
-              delay 1.0
+              -- Sequential approach with proper delays for reliability
+              -- Step 1: Select Windsurf and wait
+              delay 3
               
-              -- Approach 2: Cmd+L (alternative)
+              -- Step 2: Command+L (first attempt)
               keystroke "l" using {command down}
-              delay 1.0
+              delay 3
               
-              -- Approach 3: Click on chat area
-              try
-                set textAreas to text areas of window 1
-                if (count of textAreas) > 0 then
-                  click first text area
-                  delay 0.5
-                end if
-              on error
-                -- Continue if click fails
-              end try
+              -- Step 3: Command+Shift+L (second attempt)  
+              keystroke "l" using {command down, shift down}
+              delay 3
               
-              -- Approach 4: Tab navigation to find chat input
-              repeat 5 times
-                key code 48 -- Tab key
-                delay 0.2
-              end repeat
-              delay 0.5
-
-              -- Clear any auto-inserted context (e.g. @terminal:zsh)
+              -- Step 4: Clear any auto-inserted context and send text
               keystroke "a" using {command down}
               delay 0.3
               key code 51

package/src/ide-integration/cdp-handlers/chat-reader.js

@@ -0,0 +1,44 @@
+/**
+ * Handles reading chat text from IDEs
+ */
+export class ChatReader {
+  constructor(connectionHandler) {
+    this.connectionHandler = connectionHandler;
+  }
+
+  /**
+   * Read chat text from an IDE
+   * @param {string} ide - The IDE name
+   * @returns {Promise<string>} The chat text
+   */
+  async readChatText(ide) {
+    try {
+      const { Runtime } = await this.connectionHandler.connectToIDE(ide);
+
+      const expression = `(() => {
+        try {
+          // Look for chat messages in various possible locations
+          const chatMessages = document.querySelectorAll('[class*="message"], [class*="chat"], [class*="conversation"]');
+          const messages = [];
+
+          chatMessages.forEach(msg => {
+            const text = msg.textContent || msg.innerText;
+            if (text && text.trim()) {
+              messages.push(text.trim());
+            }
+          });
+
+          return messages.join('\\n\\n');
+        } catch (error) {
+          return 'Error reading chat: ' + error.message;
+        }
+      })()`;
+
+      const { result } = await Runtime.evaluate({ expression, returnByValue: true });
+      return result.value || '[]';
+    } catch (error) {
+      console.error(`Error reading chat from ${ide}:`, error);
+      return `Error: ${error.message}`;
+    }
+  }
+}