stringray-ai 1.0.0

package/scripts/test-utils/test-quarantine.mjs

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+/**
+ * Test Quarantine System - Surgical isolation for problematic tests
+ * 
+ * Addresses key challenge: disable problematic tests in a suite, validate others, 
+ * then isolate and fix problematic tests
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+class TestQuarantine {
+  constructor() {
+    this.quarantineDir = 'src/__tests__/quarantine';
+    this.quarantineList = 'scripts/test-utils/quarantined-tests.json';
+  }
+
+  /**
+   * Initialize quarantine system
+   */
+  init() {
+    if (!fs.existsSync(this.quarantineDir)) {
+      fs.mkdirSync(this.quarantineDir, { recursive: true });
+    }
+    
+    if (!fs.existsSync(this.quarantineList)) {
+      this.saveQuarantineList([]);
+    }
+  }
+
+  /**
+   * Quarantine a problematic test file
+   */
+  quarantine(testFile, reason = 'Unknown issue') {
+    this.init();
+    
+    const fileName = path.basename(testFile);
+    const quarantinedPath = path.join(this.quarantineDir, fileName);
+    
+    // Move file to quarantine
+    if (fs.existsSync(testFile)) {
+      fs.renameSync(testFile, quarantinedPath);
+      console.log(`🚨 Quarantined: ${fileName} (${reason})`);
+    }
+    
+    // Update quarantine list
+    const list = this.loadQuarantineList();
+    list.push({
+      originalPath: testFile,
+      quarantinedPath,
+      fileName,
+      reason,
+      quarantinedAt: new Date().toISOString()
+    });
+    
+    this.saveQuarantineList(list);
+  }
+
+  /**
+   * Release a test from quarantine
+   */
+  release(fileName) {
+    const list = this.loadQuarantineList();
+    const entry = list.find(item => item.fileName === fileName);
+    
+    if (!entry) {
+      console.error(`❌ Test ${fileName} not found in quarantine`);
+      return false;
+    }
+    
+    // Move file back
+    if (fs.existsSync(entry.quarantinedPath)) {
+      fs.renameSync(entry.quarantinedPath, entry.originalPath);
+      console.log(`✅ Released: ${fileName}`);
+    }
+    
+    // Remove from list
+    const newList = list.filter(item => item.fileName !== fileName);
+    this.saveQuarantineList(newList);
+    
+    return true;
+  }
+
+  /**
+   * List quarantined tests
+   */
+  list() {
+    const list = this.loadQuarantineList();
+    
+    if (list.length === 0) {
+      console.log('✅ No tests in quarantine');
+      return;
+    }
+    
+    console.log('🚨 Quarantined Tests:');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    
+    list.forEach((item, index) => {
+      console.log(`${index + 1}. ${item.fileName}`);
+      console.log(`   Reason: ${item.reason}`);
+      console.log(`   Original: ${item.originalPath}`);
+      console.log(`   Quarantined: ${item.quarantinedAt}`);
+      console.log('');
+    });
+  }
+
+  /**
+   * Check if a test is quarantined
+   */
+  isQuarantined(fileName) {
+    const list = this.loadQuarantineList();
+    return list.some(item => item.fileName === fileName);
+  }
+
+  /**
+   * Get quarantine statistics
+   */
+  stats() {
+    const list = this.loadQuarantineList();
+    
+    console.log('📊 Quarantine Statistics:');
+    console.log(`   Total quarantined: ${list.length}`);
+    
+    if (list.length > 0) {
+      const reasons = {};
+      list.forEach(item => {
+        reasons[item.reason] = (reasons[item.reason] || 0) + 1;
+      });
+      
+      console.log('   Reasons:');
+      Object.entries(reasons).forEach(([reason, count]) => {
+        console.log(`     ${reason}: ${count}`);
+      });
+    }
+  }
+
+  /**
+   * Load quarantine list from file
+   */
+  loadQuarantineList() {
+    try {
+      if (fs.existsSync(this.quarantineList)) {
+        const data = fs.readFileSync(this.quarantineList, 'utf8');
+        return JSON.parse(data);
+      }
+    } catch (error) {
+      console.warn('⚠️  Could not load quarantine list:', error.message);
+    }
+    return [];
+  }
+
+  /**
+   * Save quarantine list to file
+   */
+  saveQuarantineList(list) {
+    try {
+      fs.writeFileSync(this.quarantineList, JSON.stringify(list, null, 2));
+    } catch (error) {
+      console.error('❌ Could not save quarantine list:', error.message);
+    }
+  }
+
+  /**
+   * Auto-quarantine failing tests from test results
+   */
+  autoQuarantineFromResults(testResults) {
+    if (!testResults.testResults) return;
+    
+    let quarantinedCount = 0;
+    
+    testResults.testResults.forEach(testFile => {
+      if (!testFile.status || testFile.status === 'failed') {
+        const fileName = path.basename(testFile.name);
+        this.quarantine(testFile.name, 'Auto-quarantined due to test failures');
+        quarantinedCount++;
+      }
+    });
+    
+    if (quarantinedCount > 0) {
+      console.log(`🚨 Auto-quarantined ${quarantinedCount} failing test files`);
+    }
+  }
+}
+
+// CLI interface
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const quarantine = new TestQuarantine();
+  
+  switch (command) {
+    case 'list':
+      quarantine.list();
+      break;
+      
+    case 'stats':
+      quarantine.stats();
+      break;
+      
+    case 'quarantine':
+      if (args.length < 3) {
+        console.error('Usage: node test-quarantine.js quarantine <file-path> <reason>');
+        process.exit(1);
+      }
+      quarantine.quarantine(args[1], args[2]);
+      break;
+      
+    case 'release':
+      if (args.length < 2) {
+        console.error('Usage: node test-quarantine.js release <file-name>');
+        process.exit(1);
+      }
+      const success = quarantine.release(args[1]);
+      process.exit(success ? 0 : 1);
+      break;
+      
+    case 'auto':
+      // Auto-quarantine from test results file
+      if (args.length < 2) {
+        console.error('Usage: node test-quarantine.js auto <results-file>');
+        process.exit(1);
+      }
+      try {
+        const results = JSON.parse(fs.readFileSync(args[1], 'utf8'));
+        quarantine.autoQuarantineFromResults(results);
+      } catch (error) {
+        console.error('❌ Could not process results file:', error.message);
+        process.exit(1);
+      }
+      break;
+      
+    default:
+      console.log('Test Quarantine System');
+      console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+      console.log('Commands:');
+      console.log('  list                    - List quarantined tests');
+      console.log('  stats                   - Show quarantine statistics');
+      console.log('  quarantine <file> <reason> - Quarantine a test file');
+      console.log('  release <filename>      - Release a test from quarantine');
+      console.log('  auto <results-file>     - Auto-quarantine from test results');
+      break;
+  }
+}
+
+export default TestQuarantine;

package/scripts/validate-codex.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+// Check if we're in the right directory
+import fs from "fs";
+import path from "path";
+
+if (!fs.existsSync("src/codex-injector.ts")) {
+  process.exit(1);
+}
+
+// Check if codex files exist
+const codexFiles = [
+  "docs/framework/agents_template.md",
+  ".strray/agents_template.md",
+];
+
+let codexFound = false;
+for (const file of codexFiles) {
+  if (fs.existsSync(file)) {
+    codexFound = true;
+
+    // Basic validation of codex content
+    try {
+      const content = fs.readFileSync(file, "utf-8");
+      const versionMatch = content.match(/\*\*Version\*\*:\s*(\d+\.\d+\.\d+)/);
+      if (versionMatch) {
+      }
+
+      const termMatches = content.match(/####\s*\d+\.\s/g);
+      if (termMatches) {
+      }
+    } catch (error) {}
+  }
+}
+
+if (!codexFound) {
+  process.exit(1);
+}
+
+// Check if built files exist
+if (fs.existsSync("dist")) {
+} else {
+}
+
+// Check package.json
+if (fs.existsSync("package.json")) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync("package.json", "utf-8"));
+  } catch (error) {}
+} else {
+  process.exit(1);
+}
+
+// Check .strray directory
+if (fs.existsSync(".strray")) {
+  if (fs.existsSync(".strray/codex.json")) {
+  } else {
+  }
+} else {
+}

package/scripts/validate-phase1.mjs

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+
+/**
+ * Phase 1 Validation Script
+ * Validates that StrRay Framework Phase 1 fixes work correctly
+ */
+
+// Make this a module to allow top-level await
+export {};
+
+// Path configuration for cross-environment compatibility
+const PROCESSORS_PATH = process.env.STRRAY_PROCESSORS_PATH || '../dist/processors';
+const STATE_PATH = process.env.STRRAY_STATE_PATH || '../dist/state';
+const ENFORCEMENT_PATH = process.env.STRRAY_ENFORCEMENT_PATH || '../dist/enforcement';
+
+// Dynamic imports for cross-environment compatibility
+const [{ ProcessorManager }, { StringRayStateManager }, { ruleEnforcer }] = await Promise.all([
+  import(PROCESSORS_PATH + '/processor-manager.js'),
+  import(STATE_PATH + '/state-manager.js'),
+  import(ENFORCEMENT_PATH + '/rule-enforcer.js')
+]);
+
+async function validatePhase1() {
+  console.log('🚀 StrRay Framework - Phase 1 Validation\n');
+  console.log('Validating: Build System + Core Enforcement\n');
+  console.log('=' .repeat(60));
+
+  let testsPassed = 0;
+  let totalTests = 0;
+
+  // Test 1: Rule Enforcer Functionality
+  console.log('📋 TEST 1: Rule Enforcer Core Functionality');
+  totalTests++;
+
+  try {
+    const stats = ruleEnforcer.getRuleStats();
+    const hasRules = stats.totalRules >= 11;
+    const hasCategories = Object.keys(stats.ruleCategories).length >= 3;
+
+    console.log(`   ✅ Rules registered: ${stats.totalRules} (expected: 11+)`);
+    console.log(`   ✅ Categories available: ${Object.keys(stats.ruleCategories).length}`);
+    console.log(`   ✅ Rule enforcer initialized: ${hasRules && hasCategories ? 'YES' : 'NO'}`);
+
+    if (hasRules && hasCategories) {
+      testsPassed++;
+      console.log('   🎯 RESULT: PASS ✅');
+    } else {
+      console.log('   ❌ RESULT: FAIL - Missing rules or categories');
+    }
+  } catch (error) {
+    console.log(`   ❌ RESULT: ERROR - ${error.message}`);
+  }
+
+  console.log();
+
+  // Test 2: Over-Engineering Detection
+  console.log('📋 TEST 2: Over-Engineering Detection');
+  totalTests++;
+
+  try {
+    const badCode = `
+      class A implements B, C, D {
+        method() {
+          if (x) {
+            if (y) {
+              if (z) {
+                if (w) {
+                  return true;
+                }
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    const result = await ruleEnforcer.validateOperation('write', {
+      operation: 'write',
+      newCode: badCode,
+      files: ['test.ts']
+    });
+
+    const blocksBadCode = !result.passed && result.errors.some(e =>
+      e.includes('over-engineering') || e.includes('nesting')
+    );
+
+    console.log(`   ✅ Blocks over-engineered code: ${blocksBadCode ? 'YES' : 'NO'}`);
+    console.log(`   📊 Violations detected: ${result.errors.length}`);
+
+    if (blocksBadCode) {
+      testsPassed++;
+      console.log('   🎯 RESULT: PASS ✅');
+    } else {
+      console.log('   ❌ RESULT: FAIL - Should block over-engineered code');
+    }
+  } catch (error) {
+    console.log(`   ❌ RESULT: ERROR - ${error.message}`);
+  }
+
+  console.log();
+
+  // Test 3: Processor Pipeline Integration
+  console.log('📋 TEST 3: Processor Pipeline Integration');
+  totalTests++;
+
+  try {
+    const stateManager = new StringRayStateManager();
+    const processorManager = new ProcessorManager(stateManager);
+
+    // Test processor execution
+    const testContext = {
+      operation: 'write',
+      data: {
+        content: 'console.log("test");',
+        filePath: 'test.js'
+      }
+    };
+
+    await processorManager.executePreProcessors('write', testContext);
+
+    console.log('   ✅ Processor pipeline executes without errors');
+    console.log('   ✅ Pre-processors completed successfully');
+
+    testsPassed++;
+    console.log('   🎯 RESULT: PASS ✅');
+
+  } catch (error) {
+    console.log(`   ❌ RESULT: ERROR - ${error.message}`);
+  }
+
+  console.log();
+
+  // Test 4: Codex Compliance Validation
+  console.log('📋 TEST 4: Codex Compliance Processor');
+  totalTests++;
+
+  try {
+    const stateManager = new StringRayStateManager();
+    const processorManager = new ProcessorManager(stateManager);
+
+    const complianceContext = {
+      operation: 'write',
+      data: {
+        content: 'class Test { method() { console.log("ok"); } }',
+        filePath: 'test.ts'
+      }
+    };
+
+    const result = await processorManager.executePreProcessors('write', complianceContext);
+
+    console.log('   ✅ Codex compliance processor runs');
+    console.log(`   📊 Processor result: ${result ? 'Generated' : 'None'}`);
+
+    testsPassed++;
+    console.log('   🎯 RESULT: PASS ✅');
+
+  } catch (error) {
+    console.log(`   ❌ RESULT: ERROR - ${error.message}`);
+  }
+
+  console.log('\n' + '='.repeat(60));
+
+  // Final Results
+  const successRate = Math.round((testsPassed / totalTests) * 100);
+
+  console.log('🎯 PHASE 1 VALIDATION RESULTS');
+  console.log('=' .repeat(60));
+  console.log(`Tests Passed: ${testsPassed}/${totalTests}`);
+  console.log(`Success Rate: ${successRate}%`);
+
+  if (successRate >= 75) {
+    console.log('✅ OVERALL RESULT: SUCCESS ✅');
+    console.log('🎉 Phase 1 validation complete!');
+    console.log('🚀 Build system stable, core enforcement functional');
+    console.log('📈 Ready to proceed to Phase 2');
+  } else {
+    console.log('❌ OVERALL RESULT: FAILED ❌');
+    console.log('⚠️ Phase 1 issues need resolution before proceeding');
+  }
+
+  console.log('=' .repeat(60));
+
+  process.exit(successRate >= 75 ? 0 : 1);
+}
+
+validatePhase1().catch(error => {
+  console.error('💥 Validation failed with error:', error.message);
+  process.exit(1);
+});

package/scripts/validation/run-validators.js

@@ -0,0 +1,114 @@
+import { SessionMigrationValidator } from "../../dist/validation/session-migration-validator.js";
+import { SessionCoordinationValidator } from "../../dist/validation/session-coordination-validator.js";
+import { SessionSecurityValidator } from "../../dist/validation/session-security-validator.js";
+import { StrRayStateManager } from "../../dist/state/state-manager.js";
+import { createSessionCoordinator } from "../../dist/delegation/session-coordinator.js";
+import { createSessionMonitor } from "../../dist/session/session-monitor.js";
+
+async function runValidatorTests() {
+  console.log("🛡️ Running Session Management Validator Tests...\n");
+
+  try {
+    // Setup components
+    const stateManager = new StrRayStateManager();
+    const sessionCoordinator = createSessionCoordinator(stateManager);
+    const sessionMonitor = createSessionMonitor(
+      stateManager,
+      sessionCoordinator,
+      null,
+    );
+
+    // Create test session
+    const sessionId = "validator-test-session";
+    const session = sessionCoordinator.initializeSession(sessionId);
+
+    // 1. Test Migration Validator
+    console.log("🧪 1. Testing SessionMigrationValidator...");
+    const migrationValidator = new SessionMigrationValidator(
+      stateManager,
+      sessionCoordinator,
+    );
+
+    const migrationPlan = {
+      sessionId,
+      targetCoordinator: "new-coordinator-1",
+      migrationSteps: [
+        "backup_current_state",
+        "update_coordinator",
+        "transfer_dependencies",
+        "verify_migration",
+      ],
+      rollbackSteps: ["restore_backup"],
+    };
+
+    const migrationValidation =
+      await migrationValidator.validateMigrationPlan(migrationPlan);
+    console.log("✅ Migration Plan Validation:");
+    console.log(`   Valid: ${migrationValidation.valid}`);
+    console.log(`   Errors: ${migrationValidation.errors.length}`);
+    console.log(`   Warnings: ${migrationValidation.warnings.length}\n`);
+
+    // 2. Test Coordination Validator
+    console.log("🧪 2. Testing SessionCoordinationValidator...");
+    const coordinationValidator = new SessionCoordinationValidator(
+      sessionCoordinator,
+      sessionMonitor,
+    );
+
+    const coordinationValidation =
+      await coordinationValidator.validateCommunicationPatterns(sessionId);
+    console.log("✅ Communication Pattern Validation:");
+    console.log(`   Valid: ${coordinationValidation.valid}`);
+    console.log(
+      `   Total Messages: ${coordinationValidation.metrics.totalMessages}`,
+    );
+    console.log(
+      `   Coordination Efficiency: ${(coordinationValidation.metrics.coordinationEfficiency * 100).toFixed(1)}%\n`,
+    );
+
+    // 3. Test Security Validator
+    console.log("🧪 3. Testing SessionSecurityValidator...");
+    const securityValidator = new SessionSecurityValidator(
+      sessionCoordinator,
+      stateManager,
+      null,
+    );
+
+    const accessValidation =
+      await securityValidator.validateAccessControl(sessionId);
+    console.log("✅ Access Control Validation:");
+    console.log(`   Valid: ${accessValidation.valid}`);
+    console.log(
+      `   Read Access Agents: ${accessValidation.permissions.readAccess.length}`,
+    );
+    console.log(
+      `   Admin Access Agents: ${accessValidation.permissions.adminAccess.length}\n`,
+    );
+
+    // Summary
+    const allValid =
+      migrationValidation.valid &&
+      coordinationValidation.valid &&
+      accessValidation.valid;
+    console.log("🎯 VALIDATOR TEST SUMMARY:");
+    console.log(
+      `Overall Success: ${allValid ? "✅ ALL PASSED" : "⚠️ SOME ISSUES"}`,
+    );
+    console.log("Session Management Validation: OPERATIONAL ✅");
+
+    const totalIssues =
+      migrationValidation.errors.length +
+      coordinationValidation.issues.length +
+      accessValidation.issues.length;
+    if (totalIssues > 0) {
+      console.log(
+        `\n⚠️  Total Validation Issues: ${totalIssues} (may include expected test scenarios)`,
+      );
+    }
+  } catch (error) {
+    console.error("❌ Validator tests failed:", error);
+    process.exit(1);
+  }
+}
+
+runValidatorTests();