stringray-ai 1.0.0

package/scripts/validation/validate-reports.ts

@@ -0,0 +1,114 @@
+import { ReportContentValidator } from "../../dist/validation/report-content-validator.js";
+
+async function validateAllReports() {
+  console.log("🔍 Validating All Generated Reports for Hidden Issues...\n");
+
+  const validator = new ReportContentValidator();
+  const reports = [
+    {
+      path: "./SESSION_FIXES_REPORT_CORRECTED.md",
+      type: "session" as const,
+      description: "Session Management Fixes Report",
+    },
+    {
+      path: "./SESSION_FIXES_REPORT_FINAL.md",
+      type: "session" as const,
+      description: "Session Management Final Report",
+    },
+  ];
+
+  let totalIssues = 0;
+  let totalRisk = 0;
+  const riskLevels = { low: 0, medium: 0, high: 0, critical: 0 };
+
+  for (const report of reports) {
+    console.log(`📄 Validating: ${report.description}`);
+    console.log(`   Path: ${report.path}`);
+
+    try {
+      const validation = await validator.validateReportContent(
+        report.path,
+        report.type,
+      );
+
+      console.log(`   ✅ Valid: ${validation.valid}`);
+      console.log(
+        `   📊 Risk Level: ${validation.summary.riskLevel.toUpperCase()}`,
+      );
+      console.log(`   🔴 Critical Errors: ${validation.summary.errorCount}`);
+      console.log(`   🟡 Warnings: ${validation.summary.warningCount}`);
+      console.log(
+        `   ❌ False Positives: ${validation.summary.falsePositiveCount}`,
+      );
+      console.log(
+        `   ⚠️ Inconsistencies: ${validation.summary.inconsistencyCount}`,
+      );
+
+      if (validation.issues.length > 0) {
+        console.log("   📋 Issues Found:");
+        validation.issues.forEach((issue) => console.log(`      • ${issue}`));
+      }
+
+      // Track totals
+      totalIssues += validation.issues.length;
+      riskLevels[validation.summary.riskLevel]++;
+
+      // Show details for high-risk reports
+      if (
+        validation.summary.riskLevel === "high" ||
+        validation.summary.riskLevel === "critical"
+      ) {
+        console.log("   📋 Critical Details:");
+        if (validation.details.criticalErrors.length > 0) {
+          console.log("      🔴 Critical Errors:");
+          validation.details.criticalErrors.forEach((err) =>
+            console.log(`         • ${err}`),
+          );
+        }
+        if (validation.details.falsePositives.length > 0) {
+          console.log("      ❌ False Positives:");
+          validation.details.falsePositives.forEach((fp) =>
+            console.log(`         • ${fp}`),
+          );
+        }
+      }
+    } catch (error) {
+      console.log(`   ❌ Validation Failed: ${error}`);
+    }
+
+    console.log("");
+  }
+
+  // Summary
+  console.log("🎯 REPORT VALIDATION SUMMARY:");
+  console.log(`   📊 Total Reports Analyzed: ${reports.length}`);
+  console.log(`   ⚠️ Total Issues Detected: ${totalIssues}`);
+  console.log(`   📈 Risk Distribution:`);
+  Object.entries(riskLevels).forEach(([level, count]) => {
+    if (count > 0) console.log(`      ${level.toUpperCase()}: ${count}`);
+  });
+
+  const overallStatus =
+    totalIssues === 0
+      ? "✅ ALL CLEAR"
+      : riskLevels.critical > 0
+        ? "🚨 CRITICAL ISSUES"
+        : riskLevels.high > 0
+          ? "⚠️ HIGH RISK"
+          : riskLevels.medium > 0
+            ? "🟡 MEDIUM RISK"
+            : "✅ LOW RISK";
+
+  console.log(`   🎖️ Overall Status: ${overallStatus}`);
+
+  // Recommendations
+  if (totalIssues > 0) {
+    console.log("\n💡 RECOMMENDATIONS:");
+    console.log("   • Review reports with HIGH/CRITICAL risk levels");
+    console.log("   • Address false positive claims in reports");
+    console.log("   • Investigate inconsistencies in metrics");
+    console.log("   • Consider report generation improvements");
+  }
+}
+
+validateAllReports();

package/scripts/verify-phase1.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+/**
+ * StrRay Framework v1.0.0 - Boot Sequence Verification Script
+ *
+ * Tests the complete boot sequence and Phase 1 implementations.
+ */
+
+// Path configuration for cross-environment compatibility
+const BOOT_PATH = process.env.STRRAY_BOOT_PATH || "../dist/boot-orchestrator";
+const DELEGATION_PATH = process.env.STRRAY_DELEGATION_PATH || "../dist/delegation";
+const SESSION_PATH = process.env.STRRAY_SESSION_PATH || "../dist/session";
+
+import { BootOrchestrator } from "../dist/boot-orchestrator.js";
+import {
+  createAgentDelegator,
+  createSessionCoordinator,
+} from "../dist/delegation/index.js";
+import { createSessionCleanupManager } from "../dist/session/session-cleanup-manager.js";
+import { createSessionMonitor } from "../dist/session/session-monitor.js";
+import { createSessionStateManager } from "../dist/session/session-state-manager.js";
+
+async function testBootSequence() {
+  console.log("🚀 StrRay Phase 1 Verification: Boot Sequence Test");
+  console.log("==================================================");
+
+  try {
+    // Test 1: Boot Orchestrator
+    console.log("\n📋 Test 1: Boot Orchestrator");
+    const bootOrchestrator = new BootOrchestrator({
+      processorActivation: true,
+      enableEnforcement: true,
+      sessionManagement: true,
+      agentLoading: false,
+    });
+
+    const bootResult = await bootOrchestrator.executeBootSequence();
+    console.log("✅ Boot sequence result:", {
+      success: bootResult.success,
+      orchestratorLoaded: bootResult.orchestratorLoaded,
+      processorsActivated: bootResult.processorsActivated,
+      enforcementEnabled: bootResult.enforcementEnabled,
+      codexComplianceActive: bootResult.codexComplianceActive,
+      errors: bootResult.errors,
+    });
+
+    if (!bootResult.success) {
+      throw new Error(`Boot sequence failed: ${bootResult.errors.join(", ")}`);
+    }
+
+    // Test 2: Delegation System
+    console.log("\n🎯 Test 2: Delegation System");
+    const stateManager = bootOrchestrator.stateManager;
+    const agentDelegator = createAgentDelegator(stateManager);
+    const sessionCoordinator = createSessionCoordinator(stateManager);
+
+    const session = sessionCoordinator.initializeSession(
+      "verification_session",
+    );
+    console.log("✅ Session initialized:", session.sessionId);
+
+    const testRequest = {
+      operation: "refactor",
+      description: "Refactor complex authentication module",
+      context: {
+        files: ["auth.ts", "user.ts"],
+        changeVolume: 300,
+        dependencies: 5,
+        riskLevel: "medium",
+      },
+    };
+
+    const delegation = await agentDelegator.analyzeDelegation(testRequest);
+    console.log("✅ Delegation analyzed:", {
+      strategy: delegation.strategy,
+      agents: delegation.agents,
+      complexity: delegation.complexity.level,
+      score: delegation.complexity.score,
+    });
+
+    // Test 3: Session Management
+    console.log("\n🔄 Test 3: Session Management");
+    const cleanupManager = createSessionCleanupManager(stateManager);
+    const sessionMonitor = createSessionMonitor(
+      stateManager,
+      sessionCoordinator,
+      cleanupManager,
+    );
+
+    cleanupManager.registerSession(session.sessionId);
+    sessionMonitor.registerSession(session.sessionId);
+
+    const health = await sessionMonitor.performHealthCheck(session.sessionId);
+    console.log("✅ Session health check:", {
+      status: health.status,
+      activeAgents: health.activeAgents,
+      issues: health.issues.length,
+    });
+
+    // Test 4: Processor Activation
+    console.log("\n⚙️ Test 4: Processor Activation");
+    const processorManager = stateManager.get("processor:manager");
+    if (processorManager) {
+      const healthStatus = processorManager.getProcessorHealth();
+      console.log(
+        "✅ Processor health:",
+        healthStatus.map((h) => ({
+          name: h.name,
+          status: h.status,
+          successRate: Math.round(h.successRate * 100) + "%",
+        })),
+      );
+
+      // Test pre/post processors
+      const preResults = await processorManager.executePreProcessors(
+        "test_operation",
+        { test: true },
+      );
+      console.log("✅ Pre-processors executed:", preResults.length);
+
+      const postResults = await processorManager.executePostProcessors(
+        "test_operation",
+        { test: true },
+        preResults,
+      );
+      console.log("✅ Post-processors executed:", postResults.length);
+    }
+
+    // Cleanup
+    sessionCoordinator.cleanupSession(session.sessionId);
+    cleanupManager.manualCleanup(session.sessionId);
+
+    console.log("\n🎉 All Phase 1 verification tests passed!");
+    console.log("✅ Boot sequence: WORKING");
+    console.log("✅ Processor activation: WORKING");
+    console.log("✅ Delegation system: WORKING");
+    console.log("✅ Session management: WORKING");
+  } catch (error) {
+    console.error("❌ Verification failed:", error);
+    process.exit(1);
+  }
+}
+
+testBootSequence();