stringray-ai 1.0.0

package/scripts/framework/validate-multi-agent-orchestration.sh

@@ -0,0 +1,195 @@
+#!/bin/bash
+
+# Multi-Agent Orchestration Validator
+echo "🔍 Multi-Agent Orchestration System Validator"
+echo "=============================================="
+
+# Test 1: Agent Configuration Validation
+echo ""
+echo "1️⃣ Testing Agent Configurations..."
+# Check all agents with complete configurations
+AGENTS=("enforcer" "architect" "test-architect" "bug-triage-specialist" "code-reviewer" "security-auditor" "refactorer" "librarian" "explore" "oracle" "multimodal-looker" "frontend-ui-ux-engineer" "document-writer")
+MISSING_AGENTS=()
+INVALID_AGENTS=()
+
+for agent in "${AGENTS[@]}"; do
+    # Detect if we're in .opencode directory or parent directory
+    if [ -f "agents/${agent}.md" ]; then
+        AGENT_MD_PATH="agents/${agent}.md"
+    elif [ -f ".opencode/agents/${agent}.md" ]; then
+        AGENT_MD_PATH=".opencode/agents/${agent}.md"
+    else
+        MISSING_AGENTS+=("$agent")
+        continue
+    fi
+
+    if [ -f "agents/${agent}.yml" ]; then
+        AGENT_YML_PATH="agents/${agent}.yml"
+    elif [ -f ".opencode/agents/${agent}.yml" ]; then
+        AGENT_YML_PATH=".opencode/agents/${agent}.yml"
+    else
+        MISSING_AGENTS+=("${agent}.yml")
+        continue
+    fi
+
+    # Check if YAML has required fields
+    if [ -f "$AGENT_YML_PATH" ]; then
+        if ! grep -q "capabilities:" "$AGENT_YML_PATH"; then
+            INVALID_AGENTS+=("$agent.yml (missing capabilities)")
+        fi
+        if ! grep -q "model:" "$AGENT_YML_PATH"; then
+            INVALID_AGENTS+=("$agent.yml (missing model)")
+        fi
+    fi
+done
+
+if [ ${#MISSING_AGENTS[@]} -eq 0 ]; then
+    echo "✅ All agent configuration files present"
+else
+    echo "❌ Missing agent configurations: ${MISSING_AGENTS[*]}"
+fi
+
+if [ ${#INVALID_AGENTS[@]} -eq 0 ]; then
+    echo "✅ All agent configurations are valid"
+else
+    echo "❌ Invalid agent configurations: ${INVALID_AGENTS[*]}"
+fi
+
+# Test 2: Multi-Agent Configuration
+echo ""
+echo "2️⃣ Testing Multi-Agent Orchestration Configuration..."
+
+# Detect if we're in .opencode directory or parent directory
+if [ -f "oh-my-opencode.json" ]; then
+    CONFIG_FILE="oh-my-opencode.json"
+elif [ -f ".opencode/oh-my-opencode.json" ]; then
+    CONFIG_FILE=".opencode/oh-my-opencode.json"
+else
+    echo "❌ oh-my-opencode.json not found"
+    return 1
+fi
+
+if grep -q '"enabled": true' "$CONFIG_FILE" && grep -q '"multi_agent_orchestration"' "$CONFIG_FILE"; then
+    echo "✅ Multi-agent orchestration is enabled"
+else
+    echo "❌ Multi-agent orchestration is not enabled"
+fi
+
+if grep -q '"max_concurrent_agents": 5' "$CONFIG_FILE"; then
+    echo "✅ Max concurrent agents set correctly (5)"
+else
+    echo "❌ Max concurrent agents not set correctly"
+fi
+
+# Test 3: Agent Delegation System
+echo ""
+echo "3️⃣ Testing Agent Delegation System..."
+node -e "
+(async () => {
+  try {
+    const { createAgentDelegator } = await import('./dist/delegation/agent-delegator.js');
+    const { StrRayStateManager } = await import('./dist/state/state-manager.js');
+
+    const stateManager = new StrRayStateManager();
+    const delegator = createAgentDelegator(stateManager);
+
+    // Test delegation analysis
+    const result = await delegator.analyzeDelegation({
+      operation: 'test-strategy',
+      description: 'Test delegation analysis',
+      context: { test: true },
+      priority: 'medium'
+    });
+
+    console.log('✅ Agent delegation system operational');
+    console.log('   Strategy:', result.strategy);
+    console.log('   Agents selected:', result.agents.length);
+
+    // Test agent capabilities
+    const capabilities = delegator.getDelegationMetrics();
+    console.log('✅ Agent capabilities loaded');
+    console.log('   Total delegations tracked:', capabilities.totalDelegations);
+
+  } catch (error) {
+    console.log('❌ Agent delegation system error:', error.message);
+  }
+})();
+" 2>/dev/null
+
+# Test 4: Agent Event Handling
+echo ""
+echo "4️⃣ Testing Agent Event Handling..."
+node -e "
+(async () => {
+  try {
+    const { createAgentDelegator } = await import('./dist/delegation/agent-delegator.js');
+    const { StrRayStateManager } = await import('./dist/state/state-manager.js');
+
+    const stateManager = new StrRayStateManager();
+    const delegator = createAgentDelegator(stateManager);
+
+    // Test file creation handling
+    await delegator.handleFileCreation('test-file.ts', 'console.log(\"test\");');
+
+    console.log('✅ File creation event handling operational');
+    console.log('   Test architect should have been consulted for .ts file');
+
+  } catch (error) {
+    console.log('❌ File creation event handling error:', error.message);
+  }
+})();
+" 2>/dev/null
+
+# Test 5: Memory Integration
+echo ""
+echo "5️⃣ Testing Memory System Integration..."
+node -e "
+(async () => {
+  try {
+    const { memoryMonitor } = await import('./dist/monitoring/memory-monitor.js');
+
+    const stats = memoryMonitor.getCurrentStats();
+    const summary = memoryMonitor.getSummary();
+
+    console.log('✅ Memory monitoring integrated');
+    console.log('   Current heap usage:', stats.heapUsed.toFixed(2), 'MB');
+    console.log('   Memory trend:', summary.trend);
+
+  } catch (error) {
+    console.log('❌ Memory system integration error:', error.message);
+  }
+})();
+" 2>/dev/null
+
+# Test 6: Framework Boot Integration
+echo ""
+echo "6️⃣ Testing Framework Boot Integration..."
+if [ -f ".opencode/logs/framework-activity.log" ]; then
+    if grep -q "agent-delegator" .opencode/logs/framework-activity.log; then
+        echo "✅ Agent delegator integrated with framework boot"
+    else
+        echo "❌ Agent delegator not found in framework logs"
+    fi
+
+    if grep -q "multi-agent" .opencode/logs/framework-activity.log; then
+        echo "✅ Multi-agent orchestration active in framework"
+    else
+        echo "❌ Multi-agent orchestration not active"
+    fi
+else
+    echo "❌ Framework activity log not found"
+fi
+
+echo ""
+echo "🎯 Multi-Agent Orchestration Validation Complete"
+echo "=================================================="
+echo ""
+echo "Summary:"
+echo "- Agent configurations: $([ ${#MISSING_AGENTS[@]} -eq 0 ] && echo "✅ Valid" || echo "❌ Issues found")"
+echo "- Multi-agent config: $(grep -q '"enabled": true' .opencode/oh-my-opencode.json && echo "✅ Enabled" || echo "❌ Disabled")"
+echo "- Delegation system: $(node -e "(async()=>{try{const{d}=await import('./dist/delegation/agent-delegator.js');const s=new(await import('./dist/state/state-manager.js')).StrRayStateManager();const d2=d.createAgentDelegator(s);await d2.analyzeDelegation({operation:'test',description:'test',context:{}});console.log('✅ Working')}catch(e){console.log('❌ Error')}})();" 2>/dev/null)"
+echo ""
+echo "Next steps:"
+echo "- Run 'npm run framework:init' to test full system integration"
+echo "- Monitor .opencode/logs/ for agent delegation activity"
+echo "- Use 'npm run memory:dashboard' to verify memory monitoring"

package/scripts/framework/validate-profiling.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+
+echo "🔍 StrRay Framework - Profiling System Validation"
+echo "==============================================="
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+validate_profiling() {
+    echo -e "\n📊 Checking profiling system components..."
+
+    # Check if profiling files exist
+    if [ -f "src/monitoring/advanced-profiler.ts" ]; then
+        echo -e "${GREEN}✅ Advanced profiler module exists${NC}"
+    else
+        echo -e "${RED}❌ Advanced profiler module missing${NC}"
+        return 1
+    fi
+
+    if [ -f "src/monitoring/enterprise-monitoring-system.ts" ]; then
+        echo -e "${GREEN}✅ Enterprise monitoring system exists${NC}"
+    else
+        echo -e "${RED}❌ Enterprise monitoring system missing${NC}"
+        return 1
+    fi
+
+    # Check TypeScript compilation
+    echo -e "\n🔧 Checking TypeScript compilation..."
+    if command -v npx &> /dev/null; then
+        if npx tsc --noEmit --skipLibCheck src/monitoring/advanced-profiler.ts 2>/dev/null; then
+            echo -e "${GREEN}✅ Profiler TypeScript compilation successful${NC}"
+        else
+            echo -e "${RED}❌ Profiler TypeScript compilation failed${NC}"
+            return 1
+        fi
+
+        if npx tsc --noEmit --skipLibCheck src/monitoring/enterprise-monitoring-system.ts 2>/dev/null; then
+            echo -e "${GREEN}✅ Monitoring system TypeScript compilation successful${NC}"
+        else
+            echo -e "${RED}❌ Monitoring system TypeScript compilation failed${NC}"
+            return 1
+        fi
+    else
+        echo -e "${YELLOW}⚠️  npx not available - skipping TypeScript validation${NC}"
+    fi
+
+    # Check profiling directory
+    if [ -d ".strray/profiles" ]; then
+        echo -e "${GREEN}✅ Profiling storage directory exists${NC}"
+        local report_count=$(find .strray/profiles -name "*.json" 2>/dev/null | wc -l)
+        echo -e "${GREEN}📊 Found $report_count performance reports${NC}"
+    else
+        echo -e "${YELLOW}⚠️  Profiling storage directory not yet created (will be created on first run)${NC}"
+    fi
+
+    echo -e "\n🎉 Profiling system validation completed!"
+    return 0
+}
+
+# Run validation
+validate_profiling

package/scripts/github-actions-monitor.cjs

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+
+/**
+ * GitHub Actions CI/CD Monitor
+ *
+ * Monitors GitHub Actions workflow status and integrates with StrRay monitoring
+ * Provides real-time feedback on CI/CD pipeline health and failures
+ */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+
+class GitHubActionsMonitor {
+  constructor() {
+    this.owner = process.env.GITHUB_REPOSITORY?.split('/')[0] || 'strray-framework';
+    this.repo = process.env.GITHUB_REPOSITORY?.split('/')[1] || 'stringray';
+    this.token = process.env.GITHUB_TOKEN;
+    this.baseUrl = 'https://api.github.com';
+  }
+
+  /**
+   * Get recent workflow runs
+   */
+  async getWorkflowRuns(workflowName = null, limit = 10) {
+    const endpoint = `/repos/${this.owner}/${this.repo}/actions/runs`;
+    const params = new URLSearchParams({
+      per_page: limit.toString(),
+      ...(workflowName && { event: workflowName })
+    });
+
+    const data = await this.makeRequest(`${endpoint}?${params}`);
+    return data.workflow_runs || [];
+  }
+
+  /**
+   * Get workflow run details
+   */
+  async getWorkflowRun(runId) {
+    const endpoint = `/repos/${this.owner}/${this.repo}/actions/runs/${runId}`;
+    return await this.makeRequest(endpoint);
+  }
+
+  /**
+   * Check workflow status and report issues
+   */
+  async checkWorkflowStatus() {
+    console.log('🔍 Checking GitHub Actions workflow status...');
+
+    // Check if we have required environment variables
+    if (!this.token) {
+      console.log('⚠️ No GITHUB_TOKEN provided - running in local mode');
+      return this.getLocalStatus();
+    }
+
+    try {
+      const runs = await this.getWorkflowRuns(null, 20);
+
+      if (runs.length === 0) {
+        console.log('⚠️ No workflow runs found');
+        return { status: 'no_runs', issues: [] };
+      }
+
+      const issues = [];
+      const status = { total: runs.length, success: 0, failure: 0, in_progress: 0 };
+
+      for (const run of runs.slice(0, 5)) { // Check last 5 runs
+        const runStatus = run.conclusion || run.status;
+
+        switch (runStatus) {
+          case 'success':
+            status.success++;
+            break;
+          case 'failure':
+          case 'timed_out':
+          case 'action_required':
+            status.failure++;
+            issues.push({
+              workflow: run.name,
+              run_id: run.id,
+              status: runStatus,
+              created_at: run.created_at,
+              html_url: run.html_url,
+              conclusion: run.conclusion
+            });
+            break;
+          case 'in_progress':
+          case 'queued':
+            status.in_progress++;
+            break;
+        }
+      }
+
+      const healthScore = status.total > 0 ?
+        Math.round((status.success / (status.total - status.in_progress)) * 100) : 0;
+
+      console.log(`📊 CI/CD Status: ${status.success}/${status.total - status.in_progress} successful (${healthScore}% health)`);
+
+      if (issues.length > 0) {
+        console.log('❌ Failed workflows:');
+        issues.forEach(issue => {
+          console.log(`  • ${issue.workflow}: ${issue.status} (${issue.html_url})`);
+        });
+      }
+
+      return {
+        status: healthScore > 80 ? 'healthy' : healthScore > 50 ? 'warning' : 'critical',
+        health_score: healthScore,
+        issues: issues,
+        summary: {
+          total_runs: status.total,
+          successful: status.success,
+          failed: status.failure,
+          in_progress: status.in_progress
+        }
+      };
+
+    } catch (error) {
+      console.error('❌ Failed to check GitHub Actions status:', error.message);
+      return {
+        status: 'error',
+        error: error.message,
+        issues: []
+      };
+    }
+  }
+
+  /**
+   * Get local status when GitHub API is unavailable
+   */
+  getLocalStatus() {
+    console.log('🏠 Running local CI/CD status check...');
+
+    // Check for local workflow files
+    const workflowDir = path.join(process.cwd(), '.github', 'workflows');
+    const workflowsExist = fs.existsSync(workflowDir);
+    let workflowFiles = [];
+
+    if (workflowsExist) {
+      workflowFiles = fs.readdirSync(workflowDir).filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
+      console.log(`✅ Found ${workflowFiles.length} workflow files locally`);
+      console.log(`📁 Workflows: ${workflowFiles.join(', ')}`);
+    } else {
+      console.log('⚠️ No local workflow files found');
+    }
+
+    // Check for recent build artifacts
+    const distExists = fs.existsSync(path.join(process.cwd(), 'dist'));
+    const lastBuild = distExists ?
+      fs.statSync(path.join(process.cwd(), 'dist')).mtime.toISOString() :
+      'Never';
+
+    console.log(`📦 Build status: ${distExists ? '✅ Available' : '❌ Missing'} (Last: ${lastBuild})`);
+
+    return {
+      status: workflowsExist ? 'configured' : 'no_workflows',
+      health_score: workflowsExist ? 100 : 0,
+      issues: [],
+      summary: {
+        local_workflows: workflowFiles.length,
+        build_available: distExists,
+        last_build: lastBuild
+      }
+    };
+  }
+
+  /**
+   * Make HTTP request to GitHub API
+   */
+  async makeRequest(endpoint) {
+    return new Promise((resolve, reject) => {
+      const url = `${this.baseUrl}${endpoint}`;
+      const options = {
+        headers: {
+          'User-Agent': 'StrRay-CI-Monitor/1.0.0',
+          'Accept': 'application/vnd.github.v3+json',
+          ...(this.token && { 'Authorization': `token ${this.token}` })
+        }
+      };
+
+      https.get(url, options, (res) => {
+        let data = '';
+
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+
+        res.on('end', () => {
+          try {
+            if (res.statusCode === 200) {
+              resolve(JSON.parse(data));
+            } else {
+              reject(new Error(`GitHub API error: ${res.statusCode} - ${data}`));
+            }
+          } catch (error) {
+            reject(error);
+          }
+        });
+      }).on('error', (error) => {
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * Generate monitoring report
+   */
+  async generateReport() {
+    const status = await this.checkWorkflowStatus();
+
+    const report = {
+      timestamp: new Date().toISOString(),
+      repository: `${this.owner}/${this.repo}`,
+      ci_status: status.status,
+      health_score: status.health_score || 0,
+      summary: status.summary || {},
+      issues: status.issues || [],
+      recommendations: this.generateRecommendations(status)
+    };
+
+    // Save report
+    const reportPath = path.join(process.cwd(), '.opencode', 'logs', 'ci-cd-monitor-report.json');
+    const reportDir = path.dirname(reportPath);
+
+    if (!fs.existsSync(reportDir)) {
+      fs.mkdirSync(reportDir, { recursive: true });
+    }
+
+    fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+    console.log(`📄 Report saved to: ${reportPath}`);
+
+    return report;
+  }
+
+  /**
+   * Generate recommendations based on status
+   */
+  generateRecommendations(status) {
+    const recommendations = [];
+
+    if (status.status === 'critical') {
+      recommendations.push('🚨 CRITICAL: CI/CD pipelines are failing - immediate attention required');
+      recommendations.push('🔍 Check failed workflow logs for error details');
+      recommendations.push('🛠️ Fix pipeline configuration or test failures');
+    } else if (status.status === 'warning') {
+      recommendations.push('⚠️ WARNING: CI/CD health degraded - monitor closely');
+      recommendations.push('🔧 Review recent workflow failures');
+      recommendations.push('📈 Consider optimizing slow jobs');
+    }
+
+    if ((status.issues || []).length > 0) {
+      recommendations.push('📋 Review failed workflow runs for patterns');
+    }
+
+    if (status.health_score < 80) {
+      recommendations.push('🎯 Aim for >90% CI/CD success rate');
+      recommendations.push('🔄 Consider adding retry logic for flaky tests');
+    }
+
+    return recommendations;
+  }
+}
+
+// CLI interface
+async function main() {
+  const monitor = new GitHubActionsMonitor();
+
+  if (process.argv.includes('--report')) {
+    const report = await monitor.generateReport();
+    console.log('\n📊 CI/CD Monitoring Report:');
+    console.log(`Status: ${report.ci_status.toUpperCase()}`);
+    console.log(`Health Score: ${report.health_score}%`);
+    console.log(`Issues: ${report.issues.length}`);
+
+    if (report.recommendations.length > 0) {
+      console.log('\n💡 Recommendations:');
+      report.recommendations.forEach(rec => console.log(`  • ${rec}`));
+    }
+  } else {
+    await monitor.checkWorkflowStatus();
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  main().catch(console.error);
+}
+
+module.exports = { GitHubActionsMonitor };

package/scripts/init.ts

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+
+/**
+ * StrRay Standalone Framework Initialization
+ *
+ * Converted from shell script to TypeScript for better integration
+ * and cross-platform compatibility.
+ */
+
+import { execSync, spawn } from "child_process";
+import { existsSync, copyFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { compare as compareVersions } from "semver";
+
+function log(message: string) {
+  console.log(message);
+}
+
+function error(message: string) {
+  console.error(`❌ Error: ${message}`);
+}
+
+function success(message: string) {
+  console.log(`✅ ${message}`);
+}
+
+async function main() {
+  log("🚀 StrRay Standalone Framework Initialization");
+  log("============================================");
+
+  // Check if we're in the right directory
+  if (!existsSync("src/codex-injector.ts")) {
+    error("Please run this script from the strray-standalone directory");
+    process.exit(1);
+  }
+
+  // Check if Node.js is installed
+  try {
+    execSync("node --version", { stdio: "pipe" });
+  } catch {
+    error("Node.js is not installed. Please install Node.js 18+ first.");
+    process.exit(1);
+  }
+
+  // Check Node.js version
+  const nodeVersionOutput = execSync("node --version", {
+    encoding: "utf8",
+  }).trim();
+  const nodeVersion = nodeVersionOutput.replace("v", "");
+  const requiredVersion = "18.0.0";
+
+  if (compareVersions(nodeVersion, requiredVersion) < 0) {
+    error(
+      `Node.js version ${nodeVersion} is too old. Please upgrade to Node.js 18+.`,
+    );
+    process.exit(1);
+  }
+
+  success(`Node.js ${nodeVersion} detected`);
+
+  // Install dependencies
+  log("📦 Installing dependencies...");
+  try {
+    // Check if bun is available
+    execSync("bun --version", { stdio: "pipe" });
+    log("🐰 Using Bun for faster installation...");
+    execSync("bun install", { stdio: "inherit" });
+  } catch {
+    // Fall back to npm
+    execSync("npm install", { stdio: "inherit" });
+  }
+
+  // Build the framework
+  log("🔨 Building framework...");
+  try {
+    execSync("npm run build", { stdio: "inherit" });
+  } catch {
+    error("Build failed. Please check TypeScript errors.");
+    process.exit(1);
+  }
+
+  // Validate codex
+  log("🔍 Validating codex...");
+  try {
+    execSync("node scripts/validate-codex.js", { stdio: "inherit" });
+  } catch {
+    error("Codex validation failed.");
+    process.exit(1);
+  }
+
+  // Create .opencode directory if it doesn't exist
+  const opencodeDir = ".opencode";
+  if (!existsSync(opencodeDir)) {
+    mkdirSync(opencodeDir, { recursive: true });
+    log("📁 Created .opencode directory");
+  }
+
+  // Copy necessary files to .opencode if they don't exist
+  const agentsTemplateSrc = "src/agents_template.md";
+  const agentsTemplateDest = join(opencodeDir, "agents_template.md");
+
+  if (existsSync(agentsTemplateSrc) && !existsSync(agentsTemplateDest)) {
+    copyFileSync(agentsTemplateSrc, agentsTemplateDest);
+    log("📋 Copied agents template to .opencode/");
+  }
+
+  log("");
+  success("Standalone framework ready for repository");
+  log("💡 Copy this folder to a new repository to create StrRay Framework");
+  log("");
+  log("📚 Next steps:");
+  log("   1. Copy this folder to your target repository");
+  log("   2. Run 'npm run init' in the target repository");
+  log("   3. Follow the framework documentation for setup");
+  log("");
+}
+
+main().catch((err) => {
+  error(`Unexpected error: ${err.message}`);
+  process.exit(1);
+});