vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/README.md

@@ -13,6 +13,13 @@ src/
 ├── ide-integration/     # CDP, AppleScript, quota detection
 ├── chat-management/     # Message handling, polling
 ├── autonomous-mode/     # Feature implementation logic
+├── validation/          # File size and constitutional compliance
+├── monitoring/          # Real-time file monitoring and alerts
+├── models/              # Data models for compliance reporting
+├── analysis/           # Code analysis and refactoring tools
+├── refactoring/        # Automated refactoring utilities
+├── agents/             # AI agent management and validation
+├── config/             # Configuration management
 └── utils/              # Shared utilities
 ```
 
@@ -21,8 +28,241 @@ src/
 ```javascript
 import { CDPManager } from '@vibecodingmachine/core/ide-integration/cdp-manager.js';
 import { ChatManager } from '@vibecodingmachine/core/chat-management/chat-manager.js';
+import { LineLimitValidator } from '@vibecodingmachine/core/validation/line-limit-validator.js';
+import { FileMonitor } from '@vibecodingmachine/core/monitoring/file-monitor.js';
+```
+
+## Refactoring Tools and Processes
+
+### 555-Line File Size Compliance
+
+This package provides comprehensive tools for maintaining the constitutional requirement that no source file exceeds 555 lines.
+
+#### Core Validation Tools
+
+- **LineLimitValidator** (`src/validation/line-limit-validator.js`)
+  - Validates files against 555-line limit
+  - Provides configurable warning and critical thresholds
+  - Generates detailed compliance reports
+
+- **ConstitutionValidator** (`src/validation/constitution-validator.js`)
+  - Validates constitutional compliance beyond file size
+  - Checks code structure, documentation, naming conventions
+  - Identifies circular dependencies and other issues
+
+#### Monitoring and Alerting
+
+- **FileMonitor** (`src/monitoring/file-monitor.js`)
+  - Real-time file system monitoring
+  - Automatic validation on file changes
+  - Configurable debouncing and filtering
+
+- **AlertSystem** (`src/monitoring/alert-system.js`)
+  - Intelligent alerting for compliance issues
+  - Configurable severity levels and escalation
+  - Multiple notification channels
+
+#### Reporting and Metrics
+
+- **ComplianceReporter** (`src/validation/compliance-reporter.js`)
+  - Generates comprehensive compliance reports
+  - Multiple output formats (JSON, HTML, Markdown)
+  - Executive summaries and recommendations
+
+- **MetricsCalculator** (`src/validation/metrics-calculator.js`)
+  - Calculates compliance metrics and trends
+  - Performance and quality indicators
+  - Risk assessment and technical debt analysis
+
+#### Data Models
+
+- **ComplianceReport** (`src/models/compliance-report.js`)
+  - Complete compliance data model
+  - File summaries and issue tracking
+  - Recommendation generation
+
+### Refactoring Utilities
+
+#### Analysis Tools
+
+- **CodebaseScanner** (`src/analysis/codebase-scanner.js`)
+  - Scans entire codebase for compliance issues
+  - Excludes third-party libraries automatically
+  - Configurable file type filtering
+
+- **BoundaryDetector** (`src/analysis/boundary-detector.js`)
+  - AST-based logical boundary detection
+  - Identifies refactoring opportunities
+  - Suggests module split points
+
+#### Automated Refactoring
+
+- **FileSplitter** (`src/refactoring/file-splitter.js`)
+  - Safe automated file splitting
+  - AST-based code transformation
+  - Preserves functionality and imports
+
+- **ImportManager** (`src/refactoring/import-manager.js`)
+  - Automatic import statement updates
+  - Circular dependency resolution
+  - Dependency mapping validation
+
+### Usage Examples
+
+#### Basic File Validation
+
+```javascript
+const { LineLimitValidator } = require('./validation/line-limit-validator');
+
+const validator = new LineLimitValidator({
+  maxLines: 555,
+  warningThreshold: 500,
+  criticalThreshold: 800
+});
+
+const result = validator.validateFile('./src/my-file.js');
+console.log(`File is ${result.isValid ? 'compliant' : 'non-compliant'}`);
+```
+
+#### Real-time Monitoring
+
+```javascript
+const { FileMonitor } = require('./monitoring/file-monitor');
+const { AlertSystem } = require('./monitoring/alert-system');
+
+const alertSystem = new AlertSystem({
+  channels: ['console', 'file'],
+  enableEscalation: true
+});
+
+const monitor = new FileMonitor({
+  watchPaths: ['./src'],
+  enableConstitutionalValidation: true
+});
+
+monitor.on('violationDetected', (data) => {
+  console.log(`Violation in ${data.filePath}: ${data.validationResults.lineCount} lines`);
+});
+
+await monitor.start();
+```
+
+#### Generating Compliance Reports
+
+```javascript
+const { ComplianceReporter } = require('./validation/compliance-reporter');
+
+const reporter = new ComplianceReporter({
+  outputDir: './reports',
+  formats: ['json', 'html', 'markdown'],
+  includeMetrics: true
+});
+
+const reportResult = await reporter.generateReport(validationResults);
+console.log(`Report saved to: ${reportResult.files[0].filePath}`);
+```
+
+#### Automated Refactoring
+
+```javascript
+const { FileSplitter } = require('./refactoring/file-splitter');
+const { ImportManager } = require('./refactoring/import-manager');
+
+const splitter = new FileSplitter({
+  maxLines: 555,
+  preserveFunctionality: true
+});
+
+const refactoringResult = await splitter.splitFile('./src/large-file.js');
+console.log(`Split into ${refactoringResult.newFiles.length} files`);
+
+// Update imports
+const importManager = new ImportManager();
+await importManager.updateImports(refactoringResult.affectedFiles);
+```
+
+### CLI Integration
+
+The package integrates with the CLI through the `check-compliance` command:
+
+```bash
+# Basic compliance check
+npm run check-compliance
+
+# Full validation with constitutional checks
+npm run check-compliance:full
+
+# CI/CD integration
+npm run check-compliance:ci
+
+# Strict validation (fails on warnings)
+npm run check-compliance:strict
+```
+
+### Pre-commit Integration
+
+A pre-commit hook is provided for automatic validation:
+
+```bash
+# The hook is automatically installed at .git/hooks/pre-commit
+# It validates staged files before allowing commits
+```
+
+### Configuration
+
+Configuration is managed through `src/config/refactoring-config.js`:
+
+```javascript
+module.exports = {
+  limits: {
+    maxFileSize: 555,
+    warningThreshold: 500,
+    criticalThreshold: 800
+  },
+  exclusions: [
+    'node_modules',
+    '.git',
+    'dist',
+    'build'
+  ],
+  validation: {
+    enableConstitutional: true,
+    enableCircularDependencyCheck: true,
+    enableNamingValidation: true
+  }
+};
 ```
 
 ## Development
 
 This package is part of the Vibe Coding Machine monorepo. See the root README for development instructions.
+
+### Testing
+
+Run the package tests with:
+
+```bash
+cd packages/core
+npm test
+```
+
+### Contributing
+
+When contributing to this package:
+
+1. Ensure all new files comply with the 555-line limit
+2. Add appropriate tests for new functionality
+3. Update documentation as needed
+4. Run compliance validation before committing
+
+## Constitutional Compliance
+
+This package is designed to enforce the project's constitutional requirements:
+
+- **File Size Limit**: No source file exceeds 555 lines
+- **Code Structure**: Proper modular organization
+- **Documentation**: Adequate documentation for all components
+- **Testing**: Test-first development approach
+- **Quality**: High code quality standards
+
+All tools in this package are designed to help maintain these standards automatically.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibecodingmachine-core",
-  "version": "2026.02.20-0438",
+  "version": "2026.02.26-1642",
   "description": "Shared core logic for Vibe Coding Machine IDE integration",
   "main": "src/index.cjs",
   "module": "src/index.js",
@@ -18,17 +18,25 @@
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
+    "test:unit": "jest --testPathPattern=unit",
+    "test:integration": "jest --testPathPattern=integration",
+    "test:ci": "jest --ci --coverage --watchAll=false",
+    "test:regression": "../../scripts/run-regression-tests.sh",
+    "test:package": "../../scripts/test-package.sh",
+    "test:comprehensive": "npm run test:unit && npm run test:integration && npm run test:regression",
     "dev": "echo 'Core package - development mode'"
   },
   "dependencies": {
     "@aws-sdk/client-bedrock-runtime": "^3.932.0",
+    "@aws-sdk/client-cognito-identity-provider": "^3.600.0",
     "@aws-sdk/client-dynamodb": "^3.600.0",
     "@aws-sdk/lib-dynamodb": "^3.600.0",
-    "@aws-sdk/client-cognito-identity-provider": "^3.600.0",
     "chrome-remote-interface": "^0.33.0",
     "fs-extra": "^11.1.1",
     "jsonwebtoken": "^9.0.2",
     "jwks-rsa": "^3.2.0",
+    "node-fetch": "^3.3.2",
+    "ora": "^9.3.0",
     "ws": "^8.18.0"
   },
   "optionalDependencies": {

package/src/agents/Agent.js

@@ -0,0 +1,300 @@
+/**
+ * Agent Entity
+ *
+ * Represents an AI coding agent that can be installed and verified.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const { AgentStatus } = require('./AgentStatus');
+const InstallationMethod = require('./InstallationMethod');
+
+/**
+ * Agent class representing an AI coding agent
+ */
+class Agent {
+  /**
+   * Create a new Agent instance
+   * @param {Object} config - Agent configuration
+   * @param {string} config.id - Unique identifier (e.g., "claude-code")
+   * @param {string} config.name - Display name (e.g., "Claude Code")
+   * @param {string} config.description - Brief description of the agent
+   * @param {boolean} config.enabled - Whether user has enabled this agent
+   * @param {AgentStatus} config.status - Current installation state
+   * @param {string} config.statusMessage - Human-readable status message
+   * @param {InstallationMethod[]} config.installationMethods - Available installation approaches
+   * @param {string[]} config.verificationCommands - Commands to verify installation
+   * @param {Date} config.lastChecked - Timestamp of last check attempt
+   * @param {Date} config.lastVerified - Timestamp of last successful verification
+   */
+  constructor(config = {}) {
+    this.id = config.id || '';
+    this.name = config.name || '';
+    this.description = config.description || '';
+    this.enabled = config.enabled !== undefined ? config.enabled : false;
+    this.status = config.status || AgentStatus.NOT_INSTALLED;
+    this.statusMessage = config.statusMessage || '';
+    this.installationMethods = config.installationMethods || [];
+    this.verificationCommands = config.verificationCommands || [];
+    this.lastChecked = config.lastChecked || null;
+    this.lastVerified = config.lastVerified || null;
+
+    this.validate();
+  }
+
+  /**
+   * Validate agent configuration
+   * @throws {Error} If configuration is invalid
+   */
+  validate() {
+    if (!this.id || typeof this.id !== 'string') {
+      throw new Error('Agent must have a valid non-empty string id');
+    }
+
+    if (!this.name || typeof this.name !== 'string') {
+      throw new Error('Agent must have a valid non-empty string name');
+    }
+
+    if (!Array.isArray(this.installationMethods) || this.installationMethods.length === 0) {
+      throw new Error('Agent must have at least one installation method');
+    }
+
+    if (this.enabled && (!Array.isArray(this.verificationCommands) || this.verificationCommands.length === 0)) {
+      throw new Error('Enabled agent must have verification commands');
+    }
+
+    // Validate installation methods
+    this.installationMethods.forEach((method, index) => {
+      if (!(method instanceof InstallationMethod)) {
+        throw new Error(`Installation method at index ${index} must be an InstallationMethod instance`);
+      }
+    });
+  }
+
+  /**
+   * Update agent status
+   * @param {AgentStatus} newStatus - New status
+   * @param {string} message - Optional status message
+   */
+  updateStatus(newStatus, message = '') {
+    const oldStatus = this.status;
+    this.status = newStatus;
+    this.lastChecked = new Date();
+
+    if (newStatus === AgentStatus.VERIFIED) {
+      this.lastVerified = new Date();
+    }
+
+    return {
+      oldStatus,
+      newStatus,
+      message,
+      timestamp: this.lastChecked
+    };
+  }
+
+  /**
+   * Check if agent is installed (not NOT_INSTALLED)
+   * @returns {boolean}
+   */
+  isInstalled() {
+    return this.status !== AgentStatus.NOT_INSTALLED;
+  }
+
+  /**
+   * Check if agent is verified and functional
+   * @returns {boolean}
+   */
+  isVerified() {
+    return this.status === AgentStatus.VERIFIED;
+  }
+
+  /**
+   * Check if agent can be checked (enabled and not disabled)
+   * @returns {boolean}
+   */
+  canBeChecked() {
+    return this.enabled && this.status !== AgentStatus.DISABLED;
+  }
+
+  /**
+   * Get installation method by type
+   * @param {string} type - Installation method type
+   * @returns {InstallationMethod|null}
+   */
+  getInstallationMethod(type) {
+    return this.installationMethods.find(method => method.type === type) || null;
+  }
+
+  /**
+   * Get preferred installation method (lowest priority number)
+   * @returns {InstallationMethod|null}
+   */
+  getPreferredInstallationMethod() {
+    if (this.installationMethods.length === 0) {
+      return null;
+    }
+
+    return this.installationMethods.reduce((preferred, current) => {
+      return (current.priority < preferred.priority) ? current : preferred;
+    });
+  }
+
+  /**
+   * Add installation method
+   * @param {InstallationMethod} method - Installation method to add
+   */
+  addInstallationMethod(method) {
+    if (!(method instanceof InstallationMethod)) {
+      throw new Error('Method must be an InstallationMethod instance');
+    }
+
+    // Check for duplicate types
+    const existing = this.getInstallationMethod(method.type);
+    if (existing) {
+      throw new Error(`Installation method of type ${method.type} already exists`);
+    }
+
+    this.installationMethods.push(method);
+    this.installationMethods.sort((a, b) => a.priority - b.priority);
+  }
+
+  /**
+   * Remove installation method
+   * @param {string} type - Installation method type to remove
+   * @returns {boolean} - True if method was removed
+   */
+  removeInstallationMethod(type) {
+    const index = this.installationMethods.findIndex(method => method.type === type);
+    if (index !== -1) {
+      this.installationMethods.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Convert agent to plain object
+   * @returns {Object}
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      enabled: this.enabled,
+      status: this.status,
+      installationMethods: this.installationMethods.map(method => method.toJSON()),
+      verificationCommands: [...this.verificationCommands],
+      lastChecked: this.lastChecked,
+      lastVerified: this.lastVerified
+    };
+  }
+
+  /**
+   * Create agent from plain object data
+   * @param {Object} data - Plain object data
+   * @returns {Agent}
+   */
+  static fromJSON(data) {
+    let installationMethods = [];
+    
+    // Handle different installation data formats
+    if (data.installationMethods) {
+      // Direct array of InstallationMethod objects
+      installationMethods = data.installationMethods
+        .map(methodData => InstallationMethod.fromJSON(methodData));
+    } else if (data.installation && data.installation.methods) {
+      // Nested format from agents.json: installation.methods[]
+      installationMethods = data.installation.methods
+        .map(methodData => InstallationMethod.fromJSON({
+          type: methodData.type,
+          command: methodData.command,
+          packageId: methodData.package,
+          verificationCommand: methodData.verifyCommand,
+          priority: 1
+        }));
+    }
+
+    // Extract verification commands from different formats
+    let verificationCommands = data.verificationCommands || [];
+    if (data.installation && data.installation.verification && data.installation.verification.command) {
+      verificationCommands = [data.installation.verification.command];
+    }
+
+    return new Agent({
+      ...data,
+      installationMethods,
+      verificationCommands
+    });
+  }
+
+  /**
+   * Create agent configuration for common AI agents
+   * @param {string} agentId - Agent identifier
+   * @returns {Agent|null}
+   */
+  static createCommonAgent(agentId) {
+    const configurations = {
+      'claude-code': {
+        name: 'Claude Code',
+        description: 'Anthropic Claude Code AI assistant',
+        enabled: true,
+        verificationCommands: ['claude --version'],
+        installationMethods: [
+          // Will be populated with actual InstallationMethod instances
+        ]
+      },
+      'github-copilot': {
+        name: 'GitHub Copilot',
+        description: 'GitHub Copilot CLI assistant',
+        enabled: true,
+        verificationCommands: ['gh copilot --version'],
+        installationMethods: []
+      },
+      'gemini-cli': {
+        name: 'Gemini CLI',
+        description: 'Google Gemini CLI assistant',
+        enabled: true,
+        verificationCommands: ['gemini --version'],
+        installationMethods: []
+      },
+      'cursor-cli': {
+        name: 'Cursor CLI',
+        description: 'Cursor AI assistant CLI',
+        enabled: false, // Disabled by default due to WSL requirement
+        verificationCommands: ['cursor --version'],
+        installationMethods: []
+      }
+    };
+
+    const config = configurations[agentId];
+    if (!config) {
+      return null;
+    }
+
+    return new Agent({
+      id: agentId,
+      ...config
+    });
+  }
+
+  /**
+   * Convert agent to JSON representation
+   * @returns {Object} Plain object representation
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      enabled: this.enabled,
+      status: this.status,
+      installationMethods: this.installationMethods.map(method => method.toJSON()),
+      verificationCommands: this.verificationCommands,
+      lastChecked: this.lastChecked,
+      lastVerified: this.lastVerified
+    };
+  }
+}
+
+module.exports = Agent;