vibecodingmachine-core 2026.1.29-1711 → 2026.2.20-423

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibecodingmachine-core",
-  "version": "2026.1.29-1711",
+  "version": "2026.02.20-0423",
   "description": "Shared core logic for Vibe Coding Machine IDE integration",
   "main": "src/index.cjs",
   "module": "src/index.js",
@@ -28,7 +28,8 @@
     "chrome-remote-interface": "^0.33.0",
     "fs-extra": "^11.1.1",
     "jsonwebtoken": "^9.0.2",
-    "jwks-rsa": "^3.2.0"
+    "jwks-rsa": "^3.2.0",
+    "ws": "^8.18.0"
   },
   "optionalDependencies": {
     "node-pty": "^1.0.0"

package/src/agents/validation.js

@@ -0,0 +1,244 @@
+/**
+ * Agent Guideline Validation System
+ * Validates that AI agents follow constitutional requirements
+ */
+
+class AgentGuidelineValidator {
+  constructor() {
+    this.violations = [];
+  }
+
+  /**
+   * Validate agent's compliance with AGENTS.md guidelines
+   * @param {Object} context - Agent context and actions
+   * @returns {Object} Validation result
+   */
+  validateAgentCompliance(context) {
+    this.violations = [];
+
+    // Check if agent read AGENTS.md first
+    if (!context.readAgentsMd) {
+      this.violations.push({
+        type: 'AGENTS_MD_NOT_READ',
+        message: 'Agent must read AGENTS.md before making changes',
+        severity: 'error'
+      });
+    }
+
+    // Check if agent followed constitution
+    if (!context.followedConstitution) {
+      this.violations.push({
+        type: 'CONSTITUTION_NOT_FOLLOWED',
+        message: 'Agent must follow constitution guidelines',
+        severity: 'error'
+      });
+    }
+
+    // Check if agent used RUI pattern
+    if (!context.usedRUIPattern) {
+      this.violations.push({
+        type: 'RUI_PATTERN_NOT_USED',
+        message: 'Agent must use RUI pattern for interfaces',
+        severity: 'warning'
+      });
+    }
+
+    // Check packages/core modifications
+    if (context.modifiedCorePackage && !context.ranNpmInstall) {
+      this.violations.push({
+        type: 'NPM_INSTALL_NOT_RUN',
+        message: 'Agent must run npm install after modifying packages/core',
+        severity: 'error'
+      });
+    }
+
+    // Check file size compliance
+    if (context.createdLargeFiles) {
+      this.violations.push({
+        type: 'FILE_SIZE_LIMIT_EXCEEDED',
+        message: 'Files must not exceed 555 lines',
+        severity: 'error'
+      });
+    }
+
+    // Check for trailing whitespace
+    if (context.hasTrailingWhitespace) {
+      this.violations.push({
+        type: 'TRAILING_WHITESPACE',
+        message: 'Files must not have trailing whitespace',
+        severity: 'warning'
+      });
+    }
+
+    // Check for missing newlines
+    if (context.missingNewlines) {
+      this.violations.push({
+        type: 'MISSING_NEWLINES',
+        message: 'Files must end with newline (POSIX standard)',
+        severity: 'warning'
+      });
+    }
+
+    // Check for duplicate code
+    if (context.createdDuplicateCode) {
+      this.violations.push({
+        type: 'DUPLICATE_CODE',
+        message: 'Agent should merge duplicate code, not create new duplicates',
+        severity: 'error'
+      });
+    }
+
+    // Check for fallback code
+    if (context.createdFallbackCode) {
+      this.violations.push({
+        type: 'FALLBACK_CODE_CREATED',
+        message: 'Agent should log errors instead of creating fallback code',
+        severity: 'error'
+      });
+    }
+    
+    // Check test-first development
+    this.validateTestFirst(context);
+    
+    return {
+      compliant: this.violations.length === 0,
+      violations: this.violations,
+      summary: this.generateSummary()
+    };
+  }
+
+  /**
+   * Generate validation summary
+   * @private
+   */
+  generateSummary() {
+    const errors = this.violations.filter(v => v.severity === 'error');
+    const warnings = this.violations.filter(v => v.severity === 'warning');
+    
+    return {
+      total: this.violations.length,
+      errors: errors.length,
+      warnings: warnings.length,
+      criticalIssues: errors.map(e => e.message)
+    };
+  }
+
+  /**
+   * Check if agent followed test-first development
+   * @param {Object} context - Agent context
+   * @returns {boolean} Whether test-first was followed
+   */
+  validateTestFirst(context) {
+    if (!context.wroteTestsFirst) {
+      this.violations.push({
+        type: 'TESTS_NOT_WRITTEN_FIRST',
+        message: 'Tests must be written before implementation (TDD approach)',
+        severity: 'error'
+      });
+    }
+
+    return context.wroteTestsFirst;
+  }
+
+  /**
+   * Check if agent performed code cleanup
+   * @param {Object} context - Agent context
+   * @returns {boolean} Whether cleanup was performed
+   */
+  validateCodeCleanup(context) {
+    if (!context.performedCodeCleanup) {
+      this.violations.push({
+        type: 'CODE_CLEANUP_NOT_PERFORMED',
+        message: 'Agent must perform code cleanup pass after implementation',
+        severity: 'warning'
+      });
+    }
+
+    return context.performedCodeCleanup;
+  }
+
+  /**
+   * Validate file size compliance
+   * @param {Array} files - Files to check
+   * @returns {Object} File size validation result
+   */
+  validateFileSize(files) {
+    const violations = [];
+    
+    for (const file of files) {
+      if (file.lineCount > 555) {
+        violations.push({
+          file: file.path,
+          lines: file.lineCount,
+          message: `File exceeds 555 lines: ${file.lineCount} lines`
+        });
+      }
+    }
+
+    return {
+      compliant: violations.length === 0,
+      violations
+    };
+  }
+
+  /**
+   * Get constitutional requirements checklist
+   * @returns {Array} Array of requirement items
+   */
+  getConstitutionalChecklist() {
+    return [
+      {
+        id: 'read_agents_md',
+        description: 'Read AGENTS.md before making changes',
+        required: true
+      },
+      {
+        id: 'follow_constitution',
+        description: 'Follow constitution guidelines',
+        required: true
+      },
+      {
+        id: 'use_rui_pattern',
+        description: 'Use RUI pattern for interfaces',
+        required: true
+      },
+      {
+        id: 'library_first',
+        description: 'Use packages/core for business logic',
+        required: true
+      },
+      {
+        id: 'npm_install_after_core',
+        description: 'Run npm install after modifying packages/core',
+        required: true
+      },
+      {
+        id: 'test_first',
+        description: 'Write tests before implementation',
+        required: true
+      },
+      {
+        id: 'file_size_limit',
+        description: 'Keep files under 555 lines',
+        required: true
+      },
+      {
+        id: 'code_cleanup',
+        description: 'Perform code cleanup pass',
+        required: true
+      },
+      {
+        id: 'no_fallbacks',
+        description: 'Do not create fallback code',
+        required: true
+      },
+      {
+        id: 'merge_ready_code',
+        description: 'Code must be merge-ready (no trailing whitespace, proper newlines)',
+        required: true
+      }
+    ];
+  }
+}
+
+module.exports = AgentGuidelineValidator;

package/src/commands/agents.js

@@ -0,0 +1,61 @@
+const RUICommand = require('./base');
+
+/**
+ * RUI Command: List Agents
+ * Implements GET agents command following RUI pattern
+ */
+
+class ListAgentsCommand extends RUICommand {
+  constructor() {
+    super({
+      verb: 'GET',
+      resource: 'agents',
+      description: 'List all available agents with their status and configuration',
+      shortcuts: ['la', 'list ag', 'get ag'],
+      synonyms: ['list', 'get'],
+      handler: async (params = {}) => {
+        // This would integrate with the actual agent system
+        // For now, return mock data for testing
+        return {
+          agents: [
+            {
+              id: 'cursor-cli',
+              name: 'Cursor CLI Agent',
+              status: 'enabled',
+              description: 'Manages Cursor CLI integration',
+              configuration: {
+                timeout: 30000,
+                autoSave: true
+              }
+            },
+            {
+              id: 'claude-cli',
+              name: 'Claude CLI Agent',
+              status: 'disabled',
+              description: 'Manages Claude CLI integration',
+              configuration: {
+                timeout: 25000,
+                autoSave: false
+              }
+            },
+            {
+              id: 'test-agent',
+              name: 'Test Agent',
+              status: 'enabled',
+              description: 'Test agent for development',
+              configuration: {
+                timeout: 10000,
+                debug: true
+              }
+            }
+          ],
+          total: 3,
+          enabled: 2,
+          disabled: 1
+        };
+      }
+    });
+  }
+}
+
+module.exports = ListAgentsCommand;

package/src/commands/base.js

@@ -0,0 +1,162 @@
+/**
+ * Base RUI Command Interface
+ * Defines the standard interface for all RUI commands
+ */
+
+class RUICommand {
+  constructor(options = {}) {
+    this.verb = options.verb;
+    this.resource = options.resource;
+    this.description = options.description;
+    this.handler = options.handler;
+    this.shortcuts = options.shortcuts || [];
+    this.synonyms = options.synonyms || [];
+    this.parameters = options.parameters || [];
+    this.examples = options.examples || [];
+    this.registeredAt = new Date();
+  }
+
+  /**
+   * Execute the command with given parameters
+   * @param {Object} params - Command parameters
+   * @returns {Promise<Object>} Command execution result
+   */
+  async execute(params = {}) {
+    const startTime = Date.now();
+    
+    try {
+      // Validate parameters
+      this.validateParameters(params);
+      
+      // Execute the handler
+      const result = await this.handler(params);
+      
+      return {
+        success: true,
+        data: result,
+        executionTime: Date.now() - startTime,
+        command: `${this.verb} ${this.resource}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        executionTime: Date.now() - startTime,
+        command: `${this.verb} ${this.resource}`
+      };
+    }
+  }
+
+  /**
+   * Get command signature for help
+   * @returns {string} Command signature
+   */
+  getSignature() {
+    const parts = [this.verb, this.resource];
+    
+    if (this.parameters.length > 0) {
+      const paramStr = this.parameters
+        .map(param => {
+          const required = param.required ? '' : '[]';
+          return `<${param.name}${required}>`;
+        })
+        .join(' ');
+      parts.push(paramStr);
+    }
+
+    return parts.join(' ');
+  }
+
+  /**
+   * Get all available shortcuts
+   * @returns {Array} Array of shortcuts
+   */
+  getShortcuts() {
+    return [...this.shortcuts];
+  }
+
+  /**
+   * Get all synonyms
+   * @returns {Array} Array of synonyms
+   */
+  getSynonyms() {
+    return [...this.synonyms];
+  }
+
+  /**
+   * Get command examples
+   * @returns {Array} Array of examples
+   */
+  getExamples() {
+    return [...this.examples];
+  }
+
+  /**
+   * Validate parameters against command definition
+   * @private
+   */
+  validateParameters(params) {
+    for (const param of this.parameters) {
+      if (param.required && !(param.name in params)) {
+        throw new Error(`Required parameter missing: ${param.name}`);
+      }
+      
+      if (param.name in params) {
+        const value = params[param.name];
+        this.validateParameterValue(param, value);
+      }
+    }
+  }
+
+  /**
+   * Validate individual parameter value
+   * @private
+   */
+  validateParameterValue(param, value) {
+    if (param.type && typeof value !== param.type) {
+      throw new Error(`Parameter ${param.name} must be of type ${param.type}, got ${typeof value}`);
+    }
+    
+    if (param.validation && !param.validation.every(rule => this.validateRule(rule, value))) {
+      throw new Error(`Parameter ${param.name} validation failed: ${value}`);
+    }
+  }
+
+  /**
+   * Validate a single validation rule
+   * @private
+   */
+  validateRule(rule, value) {
+    if (rule.startsWith('enum:')) {
+      const allowedValues = rule.substring(5).split(',').map(v => v.trim());
+      return allowedValues.includes(value);
+    }
+    
+    if (rule.startsWith('regex:')) {
+      const pattern = new RegExp(rule.substring(6));
+      return pattern.test(value);
+    }
+    
+    return true; // Default to valid
+  }
+
+  /**
+   * Get command metadata
+   * @returns {Object} Command metadata
+   */
+  getMetadata() {
+    return {
+      verb: this.verb,
+      resource: this.resource,
+      description: this.description,
+      shortcuts: this.shortcuts,
+      synonyms: this.synonyms,
+      parameters: this.parameters,
+      examples: this.examples,
+      signature: this.getSignature(),
+      registeredAt: this.registeredAt
+    };
+  }
+}
+
+module.exports = RUICommand;

package/src/commands/create-agent.js

@@ -0,0 +1,96 @@
+const RUICommand = require('./base');
+
+/**
+ * RUI Command: Create Agent
+ * Implements POST agent command following RUI pattern
+ */
+
+class CreateAgentCommand extends RUICommand {
+  constructor() {
+    super({
+      verb: 'POST',
+      resource: 'agents',
+      description: 'Create a new agent with specified configuration',
+      shortcuts: ['ca', 'create ag', 'post ag'],
+      synonyms: ['create', 'post', 'add'],
+      parameters: [
+        {
+          name: 'name',
+          type: 'string',
+          required: true,
+          description: 'Unique identifier for the agent'
+        },
+        {
+          name: 'description',
+          type: 'string',
+          required: false,
+          description: 'Human-readable description of the agent'
+        },
+        {
+          name: 'type',
+          type: 'string',
+          required: true,
+          description: 'Type of agent (cli, gui, service)',
+          enum: ['cli', 'gui', 'service']
+        },
+        {
+          name: 'configuration',
+          type: 'object',
+          required: false,
+          description: 'Initial configuration for the agent'
+        }
+      ],
+      examples: [
+        'app create agent test-agent --name "Test Agent" --type cli --description "Agent for testing"',
+        'app ca test-agent --name "Test Agent" --type cli',
+        'app post agents --name "API Agent" --type service'
+      ]
+    });
+  }
+
+  async execute(params = {}) {
+    // Validate required parameters
+    if (!params.name) {
+      throw new Error('Required parameter missing: name');
+    }
+
+    if (!params.type) {
+      throw new Error('Required parameter missing: type');
+    }
+
+    // Validate type
+    const validTypes = ['cli', 'gui', 'service'];
+    if (!validTypes.includes(params.type)) {
+      throw new Error(`Invalid type: ${params.type}. Must be one of: ${validTypes.join(', ')}`);
+    }
+
+    // This would create the agent in the actual system
+    // For now, return success response for testing
+    return {
+      success: true,
+      data: {
+        agent: {
+          id: this.generateAgentId(params.name),
+          name: params.name,
+          description: params.description || `Agent ${params.name}`,
+          type: params.type,
+          configuration: params.configuration || {},
+          status: 'created',
+          createdAt: new Date().toISOString()
+        }
+      },
+      message: `Agent ${params.name} created successfully`
+    };
+  }
+
+  /**
+   * Generate unique agent ID
+   * @private
+   */
+  generateAgentId(name) {
+    // Convert to lowercase, replace spaces with hyphens
+    return name.toLowerCase().replace(/\s+/g, '-');
+  }
+}
+
+module.exports = CreateAgentCommand;

package/src/commands/disable-agent.js

@@ -0,0 +1,54 @@
+const RUICommand = require('./base');
+
+/**
+ * RUI Command: Disable Agent
+ * Implements agent disable action following RUI pattern
+ */
+
+class DisableAgentCommand extends RUICommand {
+  constructor() {
+    super({
+      verb: 'PUT', // Using PUT for update operations
+      resource: 'agents',
+      description: 'Disable a specific agent',
+      shortcuts: ['ad', 'disable ag', 'put ag disable'],
+      synonyms: ['disable', 'deactivate'],
+      parameters: [
+        {
+          name: 'agentId',
+          type: 'string',
+          required: true,
+          description: 'ID of the agent to disable'
+        }
+      ],
+      examples: [
+        'app disable agent test-agent',
+        'app ad test-agent',
+        'app put agents test-agent --status disabled'
+      ]
+    });
+  }
+
+  async execute(params = {}) {
+    // Validate required parameters
+    if (!params.agentId) {
+      throw new Error('Required parameter missing: agentId');
+    }
+
+    // This would integrate with the actual agent management system
+    // For now, return success response for testing
+    return {
+      success: true,
+      data: {
+        agent: {
+          id: params.agentId,
+          status: 'disabled',
+          disabledAt: new Date().toISOString()
+        }
+      },
+      message: `Agent ${params.agentId} disabled successfully`
+    };
+  }
+}
+
+module.exports = DisableAgentCommand;

package/src/commands/enable-agent.js

@@ -0,0 +1,54 @@
+const RUICommand = require('./base');
+
+/**
+ * RUI Command: Enable Agent
+ * Implements agent enable action following RUI pattern
+ */
+
+class EnableAgentCommand extends RUICommand {
+  constructor() {
+    super({
+      verb: 'PUT', // Using PUT for update operations
+      resource: 'agents',
+      description: 'Enable a specific agent',
+      shortcuts: ['ae', 'enable ag', 'put ag enable'],
+      synonyms: ['enable', 'activate'],
+      parameters: [
+        {
+          name: 'agentId',
+          type: 'string',
+          required: true,
+          description: 'ID of the agent to enable'
+        }
+      ],
+      examples: [
+        'app enable agent test-agent',
+        'app ae test-agent',
+        'app put agents test-agent --status enabled'
+      ]
+    });
+  }
+
+  async execute(params = {}) {
+    // Validate required parameters
+    if (!params.agentId) {
+      throw new Error('Required parameter missing: agentId');
+    }
+
+    // This would integrate with the actual agent management system
+    // For now, return success response for testing
+    return {
+      success: true,
+      data: {
+        agent: {
+          id: params.agentId,
+          status: 'enabled',
+          enabledAt: new Date().toISOString()
+        }
+      },
+      message: `Agent ${params.agentId} enabled successfully`
+    };
+  }
+}
+
+module.exports = EnableAgentCommand;