stringray-ai 1.0.0

package/scripts/check-logs.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+
+# StrRay Framework Usage Logger Checker
+# Displays current framework component usage logs
+
+echo "🎯 STRRAY FRAMEWORK USAGE LOGGER CHECKER"
+echo "=========================================="
+echo ""
+
+# Check if we're in the right directory
+if [ ! -f "src/framework-logger.ts" ]; then
+    echo "❌ Error: Not in StrRay project directory"
+    echo "Please run from the root of the StrRay project"
+    exit 1
+fi
+
+echo "📊 Checking framework component status..."
+echo ""
+
+# Check for recent StrRay log messages in console history
+echo "🔍 Checking for recent framework activity..."
+echo ""
+
+# Check for actual framework-activity.log file
+if [ -f ".opencode/logs/framework-activity.log" ]; then
+    echo "✅ Framework activity log found!"
+    echo ""
+    echo "📄 Recent Log Entries:"
+    echo "──────────────────────"
+    tail -10 .opencode/logs/framework-activity.log
+    echo ""
+    echo "📊 Log Statistics:"
+    TOTAL_LOGS=$(wc -l < .opencode/logs/framework-activity.log)
+    SUCCESS_COUNT=$(grep -c "SUCCESS" .opencode/logs/framework-activity.log)
+    ERROR_COUNT=$(grep -c "ERROR" .opencode/logs/framework-activity.log)
+    INFO_COUNT=$(grep -c "INFO" .opencode/logs/framework-activity.log)
+
+    echo "   Total log entries: $TOTAL_LOGS"
+    echo "   Success operations: $SUCCESS_COUNT"
+    echo "   Error operations: $ERROR_COUNT"
+    echo "   Info operations: $INFO_COUNT"
+else
+    echo "ℹ️  Framework activity log not found yet"
+    echo "ℹ️  Run framework operations to generate log entries"
+fi
+
+echo ""
+echo "📋 Framework Components with Logging:"
+echo "   • codex-injector (hook executions, validations)"
+echo "   • processor-manager (pre/post processing)"
+echo "   • state-manager (get/set/clear operations)"
+echo "   • boot-orchestrator (initialization sequence)"
+echo ""
+echo "🔍 Log Format:"
+echo "   ✅ [component] action - STATUS"
+echo ""
+echo "💡 To verify framework is active:"
+echo "   1. Perform an action using a critical tool (write, edit, multiedit, batch)"
+echo "   2. Check console output for StrRay log messages"
+echo "   3. Look for 'codex-injector' and 'processor-manager' activity"
+echo ""
+echo "✅ Framework usage logging is now active and monitoring"

package/scripts/debug/debug-context-enhancement.ts

@@ -0,0 +1,116 @@
+/**
+ * Context Enhancement Debug Script
+ * Debug the context enhancement process to see why it's failing
+ */
+
+import { frameworkLogger } from "./src/framework-logger.js";
+import { ComplexityAnalyzer } from "./src/delegation/complexity-analyzer.js";
+import { CodebaseContextAnalyzer } from "./src/delegation/codebase-context-analyzer.js";
+import { ASTCodeParser } from "./src/delegation/ast-code-parser.js";
+import { DependencyGraphBuilder } from "./src/delegation/dependency-graph-builder.js";
+
+async function debugContextEnhancement() {
+  console.log("🔧 DEBUGGING CONTEXT ENHANCEMENT PROCESS");
+  console.log("======================================");
+
+  // Create context providers
+  console.log("\n🏗️ Creating context providers...");
+  const contextAnalyzer = new CodebaseContextAnalyzer();
+  const astParser = new ASTCodeParser();
+  const dependencyBuilder = new DependencyGraphBuilder(
+    contextAnalyzer,
+    astParser,
+  );
+
+  console.log("✅ Context providers created");
+
+  // Create complexity analyzer and set providers
+  console.log("\n🔗 Setting up complexity analyzer with context providers...");
+  const complexityAnalyzer = new ComplexityAnalyzer();
+  complexityAnalyzer.setContextProviders(
+    contextAnalyzer,
+    astParser,
+    dependencyBuilder,
+  );
+  console.log("✅ Context providers connected to complexity analyzer");
+
+  // Test context enhancement with a file path
+  console.log("\n🎯 Testing context enhancement with file path...");
+  const testContext = {
+    fileCount: 5,
+    changeVolume: 100,
+    dependencies: 3,
+    riskLevel: "medium" as const,
+    filePath: "src/delegation/agent-delegator.ts",
+  };
+
+  console.log("Test context:", testContext);
+
+  try {
+    console.log("\n📊 Running complexity analysis with context enhancement...");
+    const metrics = await complexityAnalyzer.analyzeComplexity(
+      "refactor",
+      testContext,
+    );
+    console.log("✅ Context enhancement succeeded!");
+    console.log("Enhanced metrics:", {
+      fileCount: metrics.fileCount,
+      changeVolume: metrics.changeVolume,
+      dependencies: metrics.dependencies,
+      riskLevel: metrics.riskLevel,
+      estimatedDuration: metrics.estimatedDuration,
+    });
+  } catch (error) {
+    console.log("❌ Context enhancement failed:", error);
+
+    // Check individual components
+    console.log("\n🔍 Checking individual context providers...");
+
+    try {
+      console.log("Testing CodebaseContextAnalyzer...");
+      const analysis = await contextAnalyzer.analyzeCodebase();
+      console.log(
+        "✅ CodebaseContextAnalyzer works - files:",
+        analysis.structure.totalFiles,
+      );
+    } catch (e) {
+      console.log("❌ CodebaseContextAnalyzer failed:", e);
+    }
+
+    try {
+      console.log("Testing ASTCodeParser...");
+      const astAnalysis = await astParser.analyzeFile(
+        "src/delegation/agent-delegator.ts",
+      );
+      console.log(
+        "✅ ASTCodeParser works - functions:",
+        astAnalysis.structure.functions.length,
+      );
+    } catch (e) {
+      console.log("❌ ASTCodeParser failed:", e);
+    }
+  }
+
+  // Check logs for any errors
+  console.log("\n📋 Checking recent logs for errors...");
+  const recentLogs = frameworkLogger.getRecentLogs(20);
+  const errorLogs = recentLogs.filter(
+    (log) => log.status === "error" || log.action.includes("failed"),
+  );
+
+  if (errorLogs.length > 0) {
+    console.log("Recent errors:");
+    errorLogs.forEach((log) => {
+      console.log(
+        `  ${log.timestamp} [${log.component}] ${log.action}: ${JSON.stringify(log.details)}`,
+      );
+    });
+  } else {
+    console.log("No recent errors found");
+  }
+
+  console.log("\n✅ Context enhancement debugging complete!");
+}
+
+// Run the debug
+debugContextEnhancement().catch(console.error);

package/scripts/debug/debug-rules.mjs

@@ -0,0 +1,23 @@
+import { ruleEnforcer } from './dist/enforcement/rule-enforcer.js';
+
+async function debugRuleLoading() {
+  console.log('🔍 Debugging Rule Loading\n');
+
+  // Check how many rules are loaded
+  const stats = ruleEnforcer.getRuleStats();
+  console.log(`Total rules loaded: ${stats.totalRules}`);
+  console.log(`Enabled rules: ${stats.enabledRules}`);
+  console.log(`Disabled rules: ${stats.disabledRules}`);
+
+  console.log('\nRule categories:');
+  Object.entries(stats.ruleCategories).forEach(([category, count]) => {
+    console.log(`  ${category}: ${count}`);
+  });
+
+  console.log('\nChecking for module-system-consistency rule...');
+  // The rule should be there since we added it
+
+  console.log('\n🎯 Debug Complete');
+}
+
+debugRuleLoading().catch(console.error);

package/scripts/demo/demo-clickable-monitoring.mjs

@@ -0,0 +1,116 @@
+/**
+ * Clickable Agent Monitoring Integration Demo
+ * Demonstrates the enhanced multi-agent orchestration with clickable monitoring
+ */
+
+import { enhancedMultiAgentOrchestrator } from '../dist/orchestrator/enhanced-multi-agent-orchestrator.js';
+
+async function demonstrateClickableAgentMonitoring() {
+  console.log('🚀 Demonstrating Enhanced Multi-Agent Orchestration with Clickable Monitoring\n');
+
+  // Spawn multiple agents with dependencies
+  console.log('📋 Spawning agents with dependency management...\n');
+
+  // Spawn architect agent first (no dependencies)
+  const architectAgent = await enhancedMultiAgentOrchestrator.spawnAgent({
+    agentType: 'architect',
+    task: 'Design user authentication system architecture',
+    priority: 'high'
+  });
+
+  console.log(`✅ Architect agent spawned: ${architectAgent.id} (clickable: ${architectAgent.clickable})\n`);
+
+  // Spawn enforcer agent that depends on architect
+  const enforcerAgent = await enhancedMultiAgentOrchestrator.spawnAgent({
+    agentType: 'enforcer',
+    task: 'Validate authentication system against codex rules',
+    priority: 'high',
+    dependencies: [architectAgent.id] // Depends on architect completion
+  });
+
+  console.log(`⏳ Enforcer agent queued: ${enforcerAgent.id} (waiting for dependencies)\n`);
+
+  // Spawn librarian agent (independent)
+  const librarianAgent = await enhancedMultiAgentOrchestrator.spawnAgent({
+    agentType: 'librarian',
+    task: 'Research authentication best practices and patterns',
+    priority: 'medium'
+  });
+
+  console.log(`✅ Librarian agent spawned: ${librarianAgent.id} (clickable: ${librarianAgent.clickable})\n`);
+
+  // Demonstrate monitoring interface
+  console.log('📊 Real-time Monitoring Interface:\n');
+
+  // Monitor progress for 10 seconds
+  const monitorInterval = setInterval(() => {
+    const monitoringData = enhancedMultiAgentOrchestrator.getMonitoringInterface();
+
+    console.log('📈 Current Agent Status:');
+    Object.entries(monitoringData).forEach(([id, agent]) => {
+      const status = agent.status === 'spawning' ? '🔄 Spawning' :
+                    agent.status === 'active' ? '⚡ Active' :
+                    agent.status === 'completed' ? '✅ Completed' :
+                    agent.status === 'failed' ? '❌ Failed' : '🚫 Cancelled';
+
+      console.log(`  ${id}: ${agent.agentType} - ${status} (${agent.progress}%) ${agent.clickable ? '🖱️ Clickable' : ''}`);
+    });
+    console.log('');
+  }, 2000);
+
+  // Wait for all agents to complete
+  await new Promise(resolve => setTimeout(resolve, 15000));
+
+  clearInterval(monitorInterval);
+
+  // Final status report
+  console.log('🏁 Final Agent Status Report:\n');
+
+  const finalStats = enhancedMultiAgentOrchestrator.getStatistics();
+  console.log(`📊 Orchestration Statistics:`);
+  console.log(`  Active Agents: ${finalStats.activeAgents}`);
+  console.log(`  Completed Agents: ${finalStats.completedAgents}`);
+  console.log(`  Failed Agents: ${finalStats.failedAgents}`);
+  console.log(`  Total Agents Spawned: ${finalStats.totalSpawned}\n`);
+
+  const monitoringData = enhancedMultiAgentOrchestrator.getMonitoringInterface();
+  console.log('📋 Final Agent Details:');
+  Object.entries(monitoringData).forEach(([id, agent]) => {
+    const duration = agent.endTime && agent.startTime ? agent.endTime - agent.startTime : 0;
+    console.log(`  ${id}: ${agent.agentType}`);
+    console.log(`    Status: ${agent.status}`);
+    console.log(`    Duration: ${duration}ms`);
+    console.log(`    Clickable: ${agent.clickable}`);
+    console.log(`    Monitorable: ${agent.monitorable}`);
+    if (agent.result) console.log(`    Result: ${typeof agent.result === 'object' ? 'Complex result' : agent.result}`);
+    if (agent.error) console.log(`    Error: ${agent.error}`);
+    console.log('');
+  });
+
+  // Demonstrate cancellation capability
+  console.log('🚫 Demonstrating agent cancellation...\n');
+
+  const cancellableAgent = await enhancedMultiAgentOrchestrator.spawnAgent({
+    agentType: 'security-auditor',
+    task: 'Perform comprehensive security audit',
+    priority: 'high'
+  });
+
+  console.log(`✅ Security auditor spawned: ${cancellableAgent.id}\n`);
+
+  // Cancel after 2 seconds
+  setTimeout(async () => {
+    const cancelled = await enhancedMultiAgentOrchestrator.cancelAgent(cancellableAgent.id);
+    console.log(`🚫 Agent ${cancellableAgent.id} cancellation: ${cancelled ? 'SUCCESS' : 'FAILED'}\n`);
+  }, 2000);
+
+  // Wait for cancellation to complete
+  await new Promise(resolve => setTimeout(resolve, 3000));
+
+  // Final cleanup
+  await enhancedMultiAgentOrchestrator.shutdown();
+  console.log('🔄 Enhanced Multi-Agent Orchestrator shutdown complete');
+}
+
+// Run the demonstration
+demonstrateClickableAgentMonitoring().catch(console.error);

package/scripts/demo/profiling-demo.js

@@ -0,0 +1,108 @@
+import { advancedProfiler } from "./src/monitoring/advanced-profiler";
+import { enterpriseMonitoringSystem } from "./src/monitoring/enterprise-monitoring-system";
+// Simulate agent operations with profiling
+async function simulateAgentOperations() {
+  console.log("🎯 Starting Advanced Profiling Demo...\n");
+  // Enable profiling
+  advancedProfiler.enableProfiling();
+  console.log("📊 Advanced profiler enabled\n");
+  // Start monitoring system
+  await enterpriseMonitoringSystem.start();
+  console.log("📈 Enterprise monitoring system started\n");
+  const operations = [
+    { agent: "enforcer", operation: "codex-validation", duration: 150 },
+    { agent: "architect", operation: "design-review", duration: 300 },
+    { agent: "orchestrator", operation: "task-coordination", duration: 200 },
+    {
+      agent: "bug-triage-specialist",
+      operation: "error-analysis",
+      duration: 400,
+    },
+    { agent: "code-reviewer", operation: "quality-check", duration: 250 },
+    {
+      agent: "security-auditor",
+      operation: "vulnerability-scan",
+      duration: 350,
+    },
+    { agent: "refactorer", operation: "code-optimization", duration: 500 },
+    { agent: "test-architect", operation: "test-strategy", duration: 180 },
+  ];
+  console.log("🔄 Simulating agent operations...\n");
+  // Simulate agent operations
+  for (let i = 0; i < operations.length; i++) {
+    const op = operations[i];
+    const operationId = `demo-op-${i}`;
+    // Start profiling
+    advancedProfiler.startProfiling(operationId, op.agent, op.operation);
+    // Simulate operation
+    await new Promise((resolve) => setTimeout(resolve, op.duration));
+    // End profiling (simulate some failures)
+    const success = Math.random() > 0.1; // 90% success rate
+    advancedProfiler.endProfiling(
+      operationId,
+      success,
+      success ? undefined : "Simulated error",
+    );
+  }
+  console.log("\n📊 Generating performance metrics...\n");
+  // Get metrics for each agent
+  const agents = [
+    "enforcer",
+    "architect",
+    "orchestrator",
+    "bug-triage-specialist",
+    "code-reviewer",
+    "security-auditor",
+    "refactorer",
+    "test-architect",
+  ];
+  agents.forEach((agent) => {
+    const metrics = advancedProfiler.getMetrics(agent);
+    console.log(`🤖 ${agent}:`);
+    console.log(`   Operations: ${metrics.totalOperations}`);
+    console.log(
+      `   Success Rate: ${((metrics.successfulOperations / metrics.totalOperations) * 100).toFixed(1)}%`,
+    );
+    console.log(`   Average Duration: ${metrics.averageDuration.toFixed(2)}ms`);
+    console.log(
+      `   Memory Delta: ${(metrics.memoryDelta / 1024 / 1024).toFixed(2)}MB`,
+    );
+    console.log(`   Slowest: ${metrics.slowestOperation}`);
+    console.log(`   Fastest: ${metrics.fastestOperation}\n`);
+  });
+  // Get system-wide metrics
+  const systemMetrics = advancedProfiler.getMetrics();
+  console.log("🌐 System-wide Metrics:");
+  console.log(`   Total Operations: ${systemMetrics.totalOperations}`);
+  console.log(
+    `   Overall Success Rate: ${((systemMetrics.successfulOperations / systemMetrics.totalOperations) * 100).toFixed(1)}%`,
+  );
+  console.log(
+    `   Average Duration: ${systemMetrics.averageDuration.toFixed(2)}ms`,
+  );
+  console.log(
+    `   Memory Delta: ${(systemMetrics.memoryDelta / 1024 / 1024).toFixed(2)}MB\n`,
+  );
+  // Get monitoring status
+  const status = enterpriseMonitoringSystem.getMonitoringStatus();
+  console.log("📈 Monitoring System Status:");
+  console.log(`   Running: ${status.running}`);
+  console.log(`   Instance ID: ${status.instanceId}`);
+  console.log(`   Metrics Collected: ${status.metricsCollected}`);
+  console.log(`   Active Alerts: ${status.alertsActive}`);
+  console.log(`   Health Checks: ${status.healthChecksPerformed}`);
+  console.log(`   Cluster Nodes: ${status.clusterNodes}`);
+  console.log(`   Uptime: ${Math.floor(status.uptime / 1000 / 60)} minutes\n`);
+  // Wait for report generation
+  console.log("⏳ Waiting for performance report generation...");
+  await new Promise((resolve) => setTimeout(resolve, 65000)); // Wait for report generation
+  console.log("\n🎉 Profiling demo completed successfully!");
+  console.log(
+    "📊 Check the .strray/profiles/ directory for performance reports",
+  );
+  // Cleanup
+  enterpriseMonitoringSystem.stop();
+  advancedProfiler.disableProfiling();
+}
+// Run the demo
+simulateAgentOperations().catch(console.error);

package/scripts/demo/profiling-demo.ts

@@ -0,0 +1,126 @@
+import { advancedProfiler } from "./src/monitoring/advanced-profiler";
+import { enterpriseMonitoringSystem } from "./src/monitoring/enterprise-monitoring-system";
+
+// Simulate agent operations with profiling
+async function simulateAgentOperations() {
+  console.log("🎯 Starting Advanced Profiling Demo...\n");
+
+  // Enable profiling
+  advancedProfiler.enableProfiling();
+  console.log("📊 Advanced profiler enabled\n");
+
+  // Start monitoring system
+  await enterpriseMonitoringSystem.start();
+  console.log("📈 Enterprise monitoring system started\n");
+
+  const operations = [
+    { agent: "enforcer", operation: "codex-validation", duration: 150 },
+    { agent: "architect", operation: "design-review", duration: 300 },
+    { agent: "orchestrator", operation: "task-coordination", duration: 200 },
+    {
+      agent: "bug-triage-specialist",
+      operation: "error-analysis",
+      duration: 400,
+    },
+    { agent: "code-reviewer", operation: "quality-check", duration: 250 },
+    {
+      agent: "security-auditor",
+      operation: "vulnerability-scan",
+      duration: 350,
+    },
+    { agent: "refactorer", operation: "code-optimization", duration: 500 },
+    { agent: "test-architect", operation: "test-strategy", duration: 180 },
+  ];
+
+  console.log("🔄 Simulating agent operations...\n");
+
+  // Simulate agent operations
+  for (let i = 0; i < operations.length; i++) {
+    const op = operations[i];
+    const operationId = `demo-op-${i}`;
+
+    // Start profiling
+    advancedProfiler.startProfiling(operationId, op.agent, op.operation);
+
+    // Simulate operation
+    await new Promise((resolve) => setTimeout(resolve, op.duration));
+
+    // End profiling (simulate some failures)
+    const success = Math.random() > 0.1; // 90% success rate
+    advancedProfiler.endProfiling(
+      operationId,
+      success,
+      success ? undefined : "Simulated error",
+    );
+  }
+
+  console.log("\n📊 Generating performance metrics...\n");
+
+  // Get metrics for each agent
+  const agents = [
+    "enforcer",
+    "architect",
+    "orchestrator",
+    "bug-triage-specialist",
+    "code-reviewer",
+    "security-auditor",
+    "refactorer",
+    "test-architect",
+  ];
+
+  agents.forEach((agent) => {
+    const metrics = advancedProfiler.getMetrics(agent);
+    console.log(`🤖 ${agent}:`);
+    console.log(`   Operations: ${metrics.totalOperations}`);
+    console.log(
+      `   Success Rate: ${((metrics.successfulOperations / metrics.totalOperations) * 100).toFixed(1)}%`,
+    );
+    console.log(`   Average Duration: ${metrics.averageDuration.toFixed(2)}ms`);
+    console.log(
+      `   Memory Delta: ${(metrics.memoryDelta / 1024 / 1024).toFixed(2)}MB`,
+    );
+    console.log(`   Slowest: ${metrics.slowestOperation}`);
+    console.log(`   Fastest: ${metrics.fastestOperation}\n`);
+  });
+
+  // Get system-wide metrics
+  const systemMetrics = advancedProfiler.getMetrics();
+  console.log("🌐 System-wide Metrics:");
+  console.log(`   Total Operations: ${systemMetrics.totalOperations}`);
+  console.log(
+    `   Overall Success Rate: ${((systemMetrics.successfulOperations / systemMetrics.totalOperations) * 100).toFixed(1)}%`,
+  );
+  console.log(
+    `   Average Duration: ${systemMetrics.averageDuration.toFixed(2)}ms`,
+  );
+  console.log(
+    `   Memory Delta: ${(systemMetrics.memoryDelta / 1024 / 1024).toFixed(2)}MB\n`,
+  );
+
+  // Get monitoring status
+  const status = enterpriseMonitoringSystem.getMonitoringStatus();
+  console.log("📈 Monitoring System Status:");
+  console.log(`   Running: ${status.running}`);
+  console.log(`   Instance ID: ${status.instanceId}`);
+  console.log(`   Metrics Collected: ${status.metricsCollected}`);
+  console.log(`   Active Alerts: ${status.alertsActive}`);
+  console.log(`   Health Checks: ${status.healthChecksPerformed}`);
+  console.log(`   Cluster Nodes: ${status.clusterNodes}`);
+  console.log(`   Uptime: ${Math.floor(status.uptime / 1000 / 60)} minutes\n`);
+
+  // Wait for report generation
+  console.log("⏳ Waiting for performance report generation...");
+  await new Promise((resolve) => setTimeout(resolve, 65000)); // Wait for report generation
+
+  console.log("\n🎉 Profiling demo completed successfully!");
+  console.log(
+    "📊 Check the .strray/profiles/ directory for performance reports",
+  );
+
+  // Cleanup
+  enterpriseMonitoringSystem.stop();
+  advancedProfiler.disableProfiling();
+}
+
+// Run the demo
+simulateAgentOperations().catch(console.error);