stringray-ai 1.0.0

package/scripts/reporting/run-postprocessor.js

@@ -0,0 +1,59 @@
+import { PostProcessor } from "./dist/postprocessor/PostProcessor.js";
+import { createSessionCoordinator } from "./dist/delegation/session-coordinator.js";
+import { StrRayStateManager } from "./dist/state/state-manager.js";
+import { createSessionCleanupManager } from "./dist/session/session-cleanup-manager.js";
+import { createSessionMonitor } from "./dist/session/session-monitor.js";
+
+console.log(
+  "🚀 Running Post-Processor to trigger automated report generation...",
+);
+
+// Initialize components
+const stateManager = new StrRayStateManager();
+const sessionCoordinator = createSessionCoordinator(stateManager);
+const cleanupManager = createSessionCleanupManager(
+  stateManager,
+  {
+    defaultTtlMs: 86400000,
+    cleanupIntervalMs: 300000,
+  },
+  null,
+);
+const sessionMonitor = createSessionMonitor(
+  stateManager,
+  sessionCoordinator,
+  cleanupManager,
+  {},
+);
+
+// Create post-processor
+const postProcessor = new PostProcessor(
+  stateManager,
+  sessionCoordinator,
+  cleanupManager,
+  sessionMonitor,
+  {
+    reporting: {
+      enabled: true,
+      autoGenerate: true,
+      reportThreshold: 10, // Lower threshold for testing
+      reportDir: ".opencode/reports",
+      retentionDays: 30,
+    },
+  },
+);
+
+// Simulate a post-processor context
+const context = {
+  commitSha: "test-commit-" + Date.now(),
+  branch: "main",
+  files: ["src/session/session-manager.ts", "src/state/state-manager.ts"], // Simulate session management changes
+  timestamp: Date.now(),
+};
+
+console.log("📋 Running post-processor with session management context...");
+
+// Run post-processor - this should trigger automated report generation
+await postProcessor.executePostProcessorLoop(context);
+
+console.log("✅ Post-processor completed - checking for auto-generated report");

package/scripts/reporting/trigger-report.js

@@ -0,0 +1,15 @@
+import { StrRayOrchestrator } from "./dist/orchestrator.js";
+
+console.log(
+  "🚀 Starting StrRay Framework to trigger automated report generation...",
+);
+
+// Initialize orchestrator - this will trigger the post-processor on completion
+const orchestrator = new StrRayOrchestrator({
+  maxConcurrentTasks: 1,
+  taskTimeout: 30000,
+});
+
+console.log(
+  "✅ Framework initialized - post-processor will auto-generate report when operations complete",
+);

package/scripts/run-simulations.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+/**
+ * Run Codex Rule Simulations
+ * Validates all rule enforcements through comprehensive test cases
+ */
+
+// Path configuration for cross-environment compatibility
+const SIMULATION_PATH = process.env.STRRAY_SIMULATION_PATH || '../dist/simulation';
+
+async function main() {
+  console.log('🚀 Starting Codex Rule Simulations...\n');
+
+  try {
+    const { codexSimulationRunner } = await import(`${SIMULATION_PATH}/codex-rule-simulations.js`);
+    const results = await codexSimulationRunner.runAllSimulations();
+    codexSimulationRunner.generateReport(results);
+
+    // Exit with failure if any simulations failed
+    const totalFailed = results.reduce((sum, result) => sum + result.failed, 0);
+    process.exit(totalFailed > 0 ? 1 : 0);
+
+  } catch (error) {
+    console.error('❌ Simulation runner failed:', error);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/scenario-data-processor.py

@@ -0,0 +1,122 @@
+"""
+Advanced data processing service with async operations
+"""
+
+import asyncio
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+import json
+
+
+@dataclass
+class ProcessingJob:
+    id: str
+    data: List[Dict[str, Any]]
+    status: str
+    created_at: datetime
+    completed_at: Optional[datetime] = None
+    result: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+
+
+class DataProcessor:
+    def __init__(self):
+        self.jobs: Dict[str, ProcessingJob] = {}
+        self.max_concurrent_jobs = 10
+        self.semaphore = asyncio.Semaphore(self.max_concurrent_jobs)
+
+    async def submit_job(self, data: List[Dict[str, Any]]) -> str:
+        """Submit a new data processing job"""
+        job_id = f"job_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{hash(str(data))}"
+
+        job = ProcessingJob(
+            id=job_id, data=data, status="queued", created_at=datetime.now()
+        )
+
+        self.jobs[job_id] = job
+
+        # Start processing in background
+        asyncio.create_task(self._process_job(job_id))
+
+        return job_id
+
+    async def get_job_status(self, job_id: str) -> Optional[Dict[str, Any]]:
+        """Get the status of a processing job"""
+        job = self.jobs.get(job_id)
+        if not job:
+            return None
+
+        return {
+            "id": job.id,
+            "status": job.status,
+            "created_at": job.created_at.isoformat(),
+            "completed_at": job.completed_at.isoformat() if job.completed_at else None,
+            "result": job.result,
+            "error": job.error,
+        }
+
+    async def _process_job(self, job_id: str):
+        """Internal job processing"""
+        async with self.semaphore:
+            job = self.jobs[job_id]
+            job.status = "processing"
+
+            try:
+                # Simulate complex data processing
+                await asyncio.sleep(0.1)  # Simulate processing time
+
+                # Process the data
+                result = await self._analyze_data(job.data)
+
+                job.status = "completed"
+                job.completed_at = datetime.now()
+                job.result = result
+
+            except Exception as e:
+                job.status = "failed"
+                job.completed_at = datetime.now()
+                job.error = str(e)
+
+    async def _analyze_data(self, data: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Analyze the provided data"""
+        total_records = len(data)
+        fields = set()
+
+        for record in data:
+            fields.update(record.keys())
+
+        # Calculate statistics
+        numeric_fields = {}
+        for field in fields:
+            values = [
+                r.get(field) for r in data if isinstance(r.get(field), (int, float))
+            ]
+            if values:
+                numeric_fields[field] = {
+                    "count": len(values),
+                    "min": min(values),
+                    "max": max(values),
+                    "avg": sum(values) / len(values),
+                }
+
+        return {
+            "total_records": total_records,
+            "fields": list(fields),
+            "numeric_statistics": numeric_fields,
+            "processing_timestamp": datetime.now().isoformat(),
+        }
+
+    async def cleanup_old_jobs(self, max_age_hours: int = 24):
+        """Clean up old completed/failed jobs"""
+        cutoff = datetime.now() - timedelta(hours=max_age_hours)
+        to_remove = []
+
+        for job_id, job in self.jobs.items():
+            if job.completed_at and job.completed_at < cutoff:
+                to_remove.append(job_id)
+
+        for job_id in to_remove:
+            del self.jobs[job_id]
+
+        return len(to_remove)

package/scripts/scenarios/scenario-security-check.ts

@@ -0,0 +1,60 @@
+// SECURITY VULNERABILITIES FOR TESTING (DO NOT USE IN PRODUCTION)
+export class SecurityTestService {
+  private apiKeys = new Map<string, string>();
+
+  // Hardcoded credentials (CRITICAL VULNERABILITY)
+  private masterKey = "sk-1234567890abcdef";
+  private dbPassword = "admin123!@#";
+
+  constructor() {
+    // Initialize with test data
+    this.apiKeys.set("test-user", "pk_test_12345");
+    this.apiKeys.set("admin", "pk_admin_67890");
+  }
+
+  authenticate(apiKey: string): boolean {
+    // Timing attack vulnerability
+    for (const [user, key] of this.apiKeys.entries()) {
+      if (key === apiKey) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // SQL injection vulnerability
+  buildQuery(userId: string, filters: any): string {
+    let query = `SELECT * FROM users WHERE id = '${userId}'`;
+
+    if (filters.email) {
+      query += ` AND email = '${filters.email}'`; // VULNERABLE
+    }
+
+    if (filters.role) {
+      query += ` AND role = '${filters.role}'`; // VULNERABLE
+    }
+
+    return query;
+  }
+
+  // XSS vulnerability
+  generateUserHtml(user: any): string {
+    return `
+      <div class="user-card">
+        <h3>Welcome ${user.name}</h3>  <!-- XSS VULNERABLE -->
+        <p>Email: ${user.email}</p>   <!-- XSS VULNERABLE -->
+        <p>Role: ${user.role}</p>
+      </div>
+    `;
+  }
+
+  // Information disclosure
+  getDebugInfo(): any {
+    return {
+      masterKey: this.masterKey, // LEAKED
+      dbPassword: this.dbPassword, // LEAKED
+      apiKeys: Object.fromEntries(this.apiKeys), // LEAKED
+      environment: process.env, // POTENTIALLY LEAKED
+    };
+  }
+}

package/scripts/scenarios/scenario-user-management.ts

@@ -0,0 +1,123 @@
+// Complex user management service with authentication
+export interface UserProfile {
+  id: string;
+  email: string;
+  profile: {
+    name: string;
+    avatar?: string;
+    preferences: Record<string, any>;
+  };
+  security: {
+    passwordHash: string;
+    twoFactorEnabled: boolean;
+    lastLogin: Date;
+    failedAttempts: number;
+  };
+  permissions: string[];
+  metadata: {
+    createdAt: Date;
+    updatedAt: Date;
+    version: number;
+  };
+}
+
+export class UserManagementService {
+  private users = new Map<string, UserProfile>();
+  private sessions = new Map<string, { userId: string; expires: Date }>();
+
+  async createUser(
+    email: string,
+    password: string,
+    profile: any,
+  ): Promise<UserProfile> {
+    // Complex validation and creation logic
+    if (!this.validateEmail(email)) {
+      throw new Error("Invalid email format");
+    }
+
+    const existing = Array.from(this.users.values()).find(
+      (u) => u.email === email,
+    );
+    if (existing) {
+      throw new Error("User already exists");
+    }
+
+    const user: UserProfile = {
+      id: this.generateId(),
+      email,
+      profile: {
+        ...profile,
+        preferences: profile.preferences || {},
+      },
+      security: {
+        passwordHash: await this.hashPassword(password),
+        twoFactorEnabled: false,
+        lastLogin: new Date(),
+        failedAttempts: 0,
+      },
+      permissions: ["user"],
+      metadata: {
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        version: 1,
+      },
+    };
+
+    this.users.set(user.id, user);
+    return user;
+  }
+
+  async authenticateUser(
+    email: string,
+    password: string,
+  ): Promise<{ user: UserProfile; token: string } | null> {
+    const user = Array.from(this.users.values()).find((u) => u.email === email);
+    if (!user) return null;
+
+    const isValid = await this.verifyPassword(
+      password,
+      user.security.passwordHash,
+    );
+    if (!isValid) {
+      user.security.failedAttempts++;
+      return null;
+    }
+
+    // Reset failed attempts on successful login
+    user.security.failedAttempts = 0;
+    user.security.lastLogin = new Date();
+
+    const token = this.generateSessionToken();
+    this.sessions.set(token, {
+      userId: user.id,
+      expires: new Date(Date.now() + 24 * 60 * 60 * 1000),
+    });
+
+    return { user, token };
+  }
+
+  private validateEmail(email: string): boolean {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+  }
+
+  private generateId(): string {
+    return crypto.randomUUID();
+  }
+
+  private async hashPassword(password: string): Promise<string> {
+    // Simulate password hashing
+    return `hashed_${password}_salt`;
+  }
+
+  private async verifyPassword(
+    password: string,
+    hash: string,
+  ): Promise<boolean> {
+    return hash === `hashed_${password}_salt`;
+  }
+
+  private generateSessionToken(): string {
+    return crypto.randomUUID();
+  }
+}

package/scripts/setup.cjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+
+/**
+ * StrRay Plugin Setup Script
+ *
+ * Configures oh-my-opencode to use the StrRay plugin.
+ * Run this after installing the plugin.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function getOhMyOpenCodeConfigPath() {
+  // Try to find oh-my-opencode config in current project
+  const projectConfig = path.join(process.cwd(), '.opencode', 'oh-my-opencode.json');
+  if (fs.existsSync(projectConfig)) {
+    return projectConfig;
+  }
+
+  // Try to find global oh-my-opencode config
+  const homeDir = os.homedir();
+  const globalConfig = path.join(homeDir, '.config', 'opencode', 'opencode.json');
+  if (fs.existsSync(globalConfig)) {
+    return globalConfig;
+  }
+
+  // Create project-level config if neither exists
+  return projectConfig;
+}
+
+function loadConfig(configPath) {
+  try {
+    if (fs.existsSync(configPath)) {
+      const content = fs.readFileSync(configPath, 'utf-8');
+      return JSON.parse(content);
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not load config from ${configPath}:`, error.message);
+  }
+  return {};
+}
+
+function saveConfig(configPath, config) {
+  // Ensure directory exists
+  const dir = path.dirname(configPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+
+function configureStrRayPlugin() {
+  const configPath = getOhMyOpenCodeConfigPath();
+
+  console.log(`🔧 Configuring StrRay plugin for oh-my-opencode at: ${configPath}`);
+
+  let config = loadConfig(configPath);
+
+  // Only add valid opencode configuration keys
+  if (!config.model) {
+    config.model = "opencode/grok-code";
+  }
+
+  // Add plugin to the plugin array
+  if (!config.plugin) {
+    config.plugin = [];
+  }
+
+  const pluginPath = "strray/dist/plugin/strray-codex-injection.js";
+
+  if (!config.plugin.includes(pluginPath)) {
+    config.plugin.push(pluginPath);
+    console.log(`✅ Added StrRay plugin to configuration`);
+  } else {
+    console.log(`ℹ️ StrRay plugin already configured`);
+  }
+
+  // Add StrRay agent configurations (only valid opencode agent config)
+  if (!config.agent) {
+    config.agent = {};
+  }
+
+  const strrayAgents = {
+    "orchestrator": { "model": "opencode/grok-code" },
+    "enhanced-orchestrator": { "model": "opencode/grok-code" },
+    "enforcer": { "model": "opencode/grok-code" },
+    "architect": { "model": "opencode/grok-code" },
+    "test-architect": { "model": "opencode/grok-code" },
+    "bug-triage-specialist": { "model": "opencode/grok-code" },
+    "code-reviewer": { "model": "opencode/grok-code" },
+    "security-auditor": { "model": "opencode/grok-code" },
+    "refactorer": { "model": "opencode/grok-code" }
+  };
+
+  let agentsAdded = 0;
+  for (const [agentName, agentConfig] of Object.entries(strrayAgents)) {
+    if (!config.agent[agentName]) {
+      config.agent[agentName] = agentConfig;
+      agentsAdded++;
+    }
+  }
+
+  if (agentsAdded > 0) {
+    console.log(`✅ Added ${agentsAdded} StrRay agents to configuration`);
+  }
+
+  saveConfig(configPath, config);
+
+  console.log(`🎉 StrRay plugin setup complete!`);
+  console.log(`\n📋 Next Steps:`);
+  console.log(`1. Restart oh-my-opencode to load the plugin`);
+  console.log(`2. Run 'opencode agent list' to see StrRay agents`);
+  console.log(`3. Try '@enforcer analyze this code' to test the plugin`);
+  console.log(`\n📖 Documentation: https://github.com/strray-framework/strray-plugin`);
+}
+
+// Run the configuration
+try {
+  configureStrRayPlugin();
+} catch (error) {
+  console.error('❌ StrRay plugin setup failed:', error.message);
+  console.log('\n🔧 Manual Configuration:');
+  console.log('Add the following to your .opencode/oh-my-opencode.json:');
+  console.log(`"plugin": ["strray/dist/plugin/strray-codex-injection.js"]`);
+  process.exit(1);
+}

package/scripts/simulation/run-simulations.js

@@ -0,0 +1,84 @@
+import { runDistributedSessionSimulation } from "../../dist/simulation/distributed-session-simulation.js";
+import { runSessionPersistenceSimulation } from "../../dist/simulation/session-persistence-simulation.js";
+import { runSessionRecoverySimulation } from "../../dist/simulation/session-recovery-simulation.js";
+
+async function runAllSimulations() {
+  console.log("🚀 Running Complete Session Management Validation Suite...\n");
+
+  try {
+    // 1. Distributed Session Simulation
+    console.log("🧪 1. Running Distributed Session Simulation...");
+    const distributedResult = await runDistributedSessionSimulation();
+    console.log("✅ Distributed Simulation Results:");
+    console.log(`   Success: ${distributedResult.success}`);
+    console.log(`   Sessions: ${distributedResult.totalSessions}`);
+    console.log(`   Failed: ${distributedResult.failedSessions}`);
+    console.log(
+      `   Efficiency: ${(distributedResult.coordinationEfficiency * 100).toFixed(1)}%`,
+    );
+    console.log(
+      `   Network Overhead: ${distributedResult.networkOverhead} calls\n`,
+    );
+
+    // 2. Session Persistence Simulation
+    console.log("🧪 2. Running Session Persistence Simulation...");
+    const persistenceResult = await runSessionPersistenceSimulation();
+    console.log("✅ Persistence Simulation Results:");
+    console.log(`   Success: ${persistenceResult.success}`);
+    console.log(
+      `   Persisted: ${persistenceResult.persistedSessions}/${persistenceResult.totalSessions}`,
+    );
+    console.log(
+      `   Recovered: ${persistenceResult.recoveredSessions}/${persistenceResult.corruptedSessions}`,
+    );
+    console.log(
+      `   Data Loss: ${(persistenceResult.dataLoss * 100).toFixed(1)}%`,
+    );
+    console.log(
+      `   Recovery Time: ${persistenceResult.averageRecoveryTime}ms\n`,
+    );
+
+    // 3. Session Recovery Simulation
+    console.log("🧪 3. Running Session Recovery Simulation...");
+    const recoveryResult = await runSessionRecoverySimulation();
+    console.log("✅ Recovery Simulation Results:");
+    console.log(`   Success: ${recoveryResult.success}`);
+    console.log(`   Failed Sessions: ${recoveryResult.failedSessions}`);
+    console.log(
+      `   Recovered: ${recoveryResult.recoveredSessions}/${recoveryResult.failedSessions}`,
+    );
+    console.log(`   Cascade Failures: ${recoveryResult.cascadeFailures}`);
+    console.log(
+      `   Recovery Efficiency: ${(recoveryResult.recoveryEfficiency * 100).toFixed(1)}%`,
+    );
+    console.log(
+      `   Average Recovery Time: ${recoveryResult.averageRecoveryTime}ms\n`,
+    );
+
+    // Summary
+    const allSuccessful =
+      distributedResult.success &&
+      persistenceResult.success &&
+      recoveryResult.success;
+    console.log("🎯 SIMULATION SUITE SUMMARY:");
+    console.log(
+      `Overall Success: ${allSuccessful ? "✅ ALL PASSED" : "❌ ISSUES DETECTED"}`,
+    );
+    console.log("Session Management Validation: COMPLETE ✅");
+
+    const totalIssues =
+      distributedResult.issues.length +
+      persistenceResult.issues.length +
+      recoveryResult.issues.length;
+    if (totalIssues > 0) {
+      console.log(
+        `\n⚠️  Total Issues Detected: ${totalIssues} (expected in failure simulations)`,
+      );
+    }
+  } catch (error) {
+    console.error("❌ Simulation suite failed:", error);
+    process.exit(1);
+  }
+}
+
+runAllSimulations();