stringray-ai 1.0.0

package/scripts/analyze-imports.mjs

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+/**
+ * Import Consistency Fixer
+ * Scans codebase and fixes import inconsistencies that cause module resolution issues
+ */
+
+import { readFileSync, writeFileSync, readdirSync, statSync } from 'fs';
+import { join, extname } from 'path';
+
+const SRC_DIR = './src';
+
+function scanDirectory(dir, results = []) {
+  try {
+    const files = readdirSync(dir);
+
+    for (const file of files) {
+      const filePath = join(dir, file);
+      const stat = statSync(filePath);
+
+      if (stat.isDirectory() && !file.startsWith('.') && file !== 'node_modules') {
+        scanDirectory(filePath, results);
+      } else if (stat.isFile() && extname(file) === '.ts') {
+        results.push(filePath);
+      }
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not scan directory ${dir}:`, error.message);
+  }
+
+  return results;
+}
+
+function analyzeImports(filePath) {
+  const content = readFileSync(filePath, 'utf8');
+  const lines = content.split('\n');
+  const issues = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+
+    if (line.startsWith('import') && line.includes('from')) {
+      // Check for problematic patterns
+      if (line.includes("from '../src/") || line.includes("from './src/")) {
+        issues.push({
+          line: i + 1,
+          type: 'src-directory-import',
+          message: 'Import from src/ directory detected',
+          lineContent: line
+        });
+      }
+
+      if (line.includes("from './dist/") || line.includes("from '../dist/")) {
+        issues.push({
+          line: i + 1,
+          type: 'dist-import-in-source',
+          message: 'Import from dist/ directory in source file',
+          lineContent: line
+        });
+      }
+    }
+  }
+
+  return issues;
+}
+
+function generateReport(allIssues) {
+  console.log('🔍 IMPORT CONSISTENCY ANALYSIS REPORT');
+  console.log('='.repeat(50));
+
+  let totalFiles = 0;
+  let filesWithIssues = 0;
+  let totalIssues = 0;
+
+  for (const [filePath, issues] of Object.entries(allIssues)) {
+    totalFiles++;
+    if (issues.length > 0) {
+      filesWithIssues++;
+      totalIssues += issues.length;
+    }
+  }
+
+  console.log(`📊 Summary:`);
+  console.log(`   Total TypeScript files: ${totalFiles}`);
+  console.log(`   Files with import issues: ${filesWithIssues}`);
+  console.log(`   Total import issues: ${totalIssues}`);
+  console.log('');
+
+  if (filesWithIssues > 0) {
+    console.log('🚨 FILES WITH IMPORT ISSUES:');
+    console.log('');
+
+    for (const [filePath, issues] of Object.entries(allIssues)) {
+      if (issues.length > 0) {
+        console.log(`📁 ${filePath}:`);
+        issues.forEach(issue => {
+          console.log(`   Line ${issue.line}: ${issue.message}`);
+          console.log(`   → ${issue.lineContent}`);
+        });
+        console.log('');
+      }
+    }
+
+    console.log('💡 RECOMMENDED FIXES:');
+    console.log('1. Replace src/ imports with relative paths (../)');
+    console.log('2. Remove dist/ imports from source files');
+    console.log('3. Use .js extensions for ESM imports');
+    console.log('4. Consider index.ts files for cleaner imports');
+  } else {
+    console.log('✅ NO IMPORT ISSUES FOUND!');
+  }
+
+  console.log('='.repeat(50));
+  return { totalFiles, filesWithIssues, totalIssues };
+}
+
+async function main() {
+  console.log('🔧 Scanning codebase for import consistency issues...\n');
+
+  const tsFiles = scanDirectory(SRC_DIR);
+  console.log(`Found ${tsFiles.length} TypeScript files`);
+  const allIssues = {};
+
+  for (const filePath of tsFiles) {
+    const issues = analyzeImports(filePath);
+    if (issues.length > 0) {
+      allIssues[filePath] = issues;
+    }
+  }
+
+  const report = generateReport(allIssues);
+
+  console.log('\n🎯 IMPORT CONSISTENCY RULE ENFORCEMENT:');
+  if (report.filesWithIssues > 0) {
+    console.log('❌ FAIL: Import consistency violations detected');
+    console.log('💡 Enable the "import-consistency" rule in rule-enforcer.ts to block these at write-time');
+  } else {
+    console.log('✅ PASS: All imports are consistent');
+  }
+
+  process.exit(report.filesWithIssues > 0 ? 1 : 0);
+}
+
+main().catch(error => {
+  console.error('❌ Analysis failed:', error.message);
+  process.exit(1);
+});

package/scripts/basic-security-audit.cjs

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+
+/**
+ * StrRay Framework Basic Security Audit
+ *
+ * Performs basic security checks on the framework codebase.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class BasicSecurityAuditor {
+  constructor() {
+    this.issues = [];
+    this.dangerousPatterns = [
+      // Only flag JavaScript eval/Function, not Redis eval
+      { pattern: /\b(eval|Function)\s*\(/g, severity: 'critical', category: 'code-injection',
+        exclude: (line) => line.includes('redis.eval') || line.includes('this.redis.eval') },
+      { pattern: /child_process\.exec/g, severity: 'high', category: 'command-injection' },
+      // Only flag non-empty hardcoded secrets, not empty config placeholders
+      { pattern: /password\s*[:=]\s*['"][^'"]+['"]/gi, severity: 'high', category: 'hardcoded-secrets' },
+      { pattern: /api[_-]?key\s*[:=]\s*['"][^'"]+['"]/gi, severity: 'high', category: 'hardcoded-secrets' },
+      // Flag Math.random() but allow benign usage
+      { pattern: /Math\.random\s*\(\)/g, severity: 'medium', category: 'weak-cryptography',
+        exclude: (line) => this.isBenignMathRandomUsage(line) },
+      { pattern: /console\.log\s*\([^)]*password[^)]*\)/gi, severity: 'medium', category: 'information-disclosure' }
+    ];
+  }
+
+  isBenignMathRandomUsage(line) {
+    // Allow Math.random() in these contexts:
+    // - ID generation (toString(36))
+    // - Mock/test data generation
+    // - Timeouts and delays
+    // - Random selections for non-security purposes
+    return line.includes('toString(36)') || // ID generation
+           line.includes('Math.random() *') && (
+             line.includes('setTimeout') ||
+             line.includes('Date.now()') ||
+             line.includes('Math.floor') ||
+             line.includes('alert_') ||
+             line.includes('conn_') ||
+             line.includes('dash_') ||
+             line.includes('strray-')
+           ) ||
+           line.includes('test') ||
+           line.includes('benchmark') ||
+           line.includes('mock') ||
+           line.includes('placeholder');
+  }
+
+  auditProject(projectPath = '.') {
+    console.log('🔒 StrRay Framework Basic Security Audit');
+    console.log('=========================================\n');
+
+    const files = this.getAllFiles(projectPath);
+    console.log(`📊 Scanning ${files.length} files...\n`);
+
+    for (const file of files) {
+      if (this.shouldAuditFile(file)) {
+        this.auditFile(file);
+      }
+    }
+
+    this.auditPackageJson(projectPath);
+    this.generateReport();
+  }
+
+  getAllFiles(dirPath) {
+    const files = [];
+
+    function traverse(currentPath) {
+      try {
+        const items = fs.readdirSync(currentPath);
+
+        for (const item of items) {
+          const fullPath = path.join(currentPath, item);
+
+          try {
+            const stat = fs.statSync(fullPath);
+
+            if (stat.isDirectory() && !['node_modules', '.git', 'dist'].includes(item)) {
+              traverse(fullPath);
+            } else if (stat.isFile()) {
+              files.push(fullPath);
+            }
+          } catch (error) {
+            // Skip files we can't access
+          }
+        }
+      } catch (error) {
+        // Skip directories we can't access
+      }
+    }
+
+    traverse(dirPath);
+    return files;
+  }
+
+  shouldAuditFile(filePath) {
+    const auditExtensions = ['.ts', '.tsx', '.js', '.jsx', '.json'];
+    const excludePatterns = [
+      /__tests__/,
+      /test\./,
+      /spec\./,
+      /codex-parser\.ts$/,
+      /security-auditor\.ts$/,
+      /\.test\./,
+      /\.spec\./
+    ];
+
+    // Skip test files and security validation files
+    if (excludePatterns.some(pattern => pattern.test(filePath))) {
+      return false;
+    }
+
+    return auditExtensions.some(ext => filePath.endsWith(ext));
+  }
+
+  auditFile(filePath) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const lines = content.split('\n');
+
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNumber = i + 1;
+
+        for (const { pattern, severity, category, exclude, excludeInTests } of this.dangerousPatterns) {
+          let matches;
+          while ((matches = pattern.exec(line)) !== null) {
+            // Skip if in test/benchmark context and excludeInTests is true
+            if (excludeInTests && (filePath.includes('test') || filePath.includes('benchmark'))) {
+              continue;
+            }
+
+            // Skip if exclude function returns true
+            if (exclude && exclude(line)) {
+              continue;
+        }
+
+            this.issues.push({
+              severity,
+              category,
+              file: filePath,
+              line: lineNumber,
+              description: `Potentially dangerous pattern detected: ${matches[0]}`,
+              recommendation: this.getRecommendation(category)
+            });
+          }
+        }
+      }
+    } catch (error) {
+      // Skip files we can't read
+    }
+  }
+
+  auditPackageJson(projectPath) {
+    try {
+      const packagePath = path.join(projectPath, 'package.json');
+      const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+
+      // Check for insecure dependency versions
+      const allDeps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+      for (const [dep, version] of Object.entries(allDeps || {})) {
+        if (typeof version === 'string' && (version.includes('*') || version.includes('latest'))) {
+          this.issues.push({
+            severity: 'medium',
+            category: 'dependency-management',
+            file: packagePath,
+            description: `Insecure version constraint for ${dep}: ${version}`,
+            recommendation: 'Use specific version ranges to avoid vulnerable versions'
+          });
+        }
+      }
+
+      // Check for missing security scripts
+      const scripts = packageJson.scripts || {};
+      if (!scripts['audit'] && !scripts['security-audit']) {
+        this.issues.push({
+          severity: 'low',
+          category: 'security-practices',
+          file: packagePath,
+          description: 'Missing security audit scripts',
+          recommendation: 'Add npm audit and security audit scripts'
+        });
+      }
+
+    } catch (error) {
+      // Skip if package.json doesn't exist or is invalid
+    }
+  }
+
+  getRecommendation(category) {
+    const recommendations = {
+      'code-injection': 'Use static code analysis and avoid dynamic code execution',
+      'command-injection': 'Validate and sanitize all user inputs, use parameterized commands',
+      'hardcoded-secrets': 'Move secrets to environment variables or secure vault',
+      'weak-cryptography': 'Use cryptographically secure random number generators',
+      'information-disclosure': 'Avoid logging sensitive information',
+      'dependency-management': 'Use lockfiles and specific version constraints'
+    };
+    return recommendations[category] || 'Review and implement appropriate security measures';
+  }
+
+  generateReport() {
+    const summary = {
+      critical: 0,
+      high: 0,
+      medium: 0,
+      low: 0
+    };
+
+    for (const issue of this.issues) {
+      summary[issue.severity]++;
+    }
+
+    const totalIssues = this.issues.length;
+    const score = Math.max(0, 100 - (summary.critical * 20 + summary.high * 10 + summary.medium * 5 + summary.low * 2));
+
+    console.log(`📊 Audit Results:`);
+    console.log(`   Security Score: ${score}/100`);
+    console.log(`   Total Issues: ${totalIssues}`);
+    console.log(`   - Critical: ${summary.critical}`);
+    console.log(`   - High: ${summary.high}`);
+    console.log(`   - Medium: ${summary.medium}`);
+    console.log(`   - Low: ${summary.low}\n`);
+
+    if (totalIssues > 0) {
+      console.log('🚨 Top Security Issues:');
+
+      // Sort by severity
+      const sortedIssues = this.issues.sort((a, b) => {
+        const severityOrder = { critical: 4, high: 3, medium: 2, low: 1 };
+        return severityOrder[b.severity] - severityOrder[a.severity];
+      });
+
+      for (const issue of sortedIssues.slice(0, 10)) {
+        console.log(`   ${issue.severity.toUpperCase()}: ${issue.category}`);
+        console.log(`      ${issue.description}`);
+        console.log(`      File: ${issue.file}${issue.line ? `:${issue.line}` : ''}`);
+        console.log(`      💡 ${issue.recommendation}\n`);
+      }
+    } else {
+      console.log('✅ No security issues found!');
+    }
+
+    console.log('\n🛡️ Security Recommendations:');
+    console.log('1. Address all Critical and High severity issues immediately');
+    console.log('2. Implement automated security scanning in CI/CD pipeline');
+    console.log('3. Regular security audits and dependency updates');
+    console.log('4. Use security headers and secure coding practices');
+
+    // Exit with appropriate code
+    process.exit(score >= 80 ? 0 : 1);
+  }
+}
+
+// Run the audit
+const auditor = new BasicSecurityAuditor();
+auditor.auditProject(process.cwd());

package/scripts/boot-check.cjs

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+
+/**
+ * StrRay Framework Boot Health Check
+ *
+ * Validates that the framework can boot successfully with proper logging.
+ * This script performs end-to-end boot validation and reports results.
+ *
+ * @version 1.0.0
+ * @since 2026-01-06
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+// Import framework (adjust path as needed)
+let initializeStrRay;
+try {
+  const frameworkPath = path.join(__dirname, "..", "dist", "index.js");
+  if (fs.existsSync(frameworkPath)) {
+    initializeStrRay = require(frameworkPath).initializeStrRay;
+  } else {
+    process.exit(1);
+  }
+} catch (error) {
+  process.exit(1);
+}
+
+class BootChecker {
+  constructor() {
+    this.startTime = Date.now();
+    this.checks = [];
+    this.errors = [];
+  }
+
+  log(message, type = "info") {
+    const timestamp = new Date().toISOString();
+    const prefix = type === "error" ? "❌" : type === "success" ? "✅" : "ℹ️";
+  }
+
+  async runCheck(name, checkFn) {
+    try {
+      this.log(`Running check: ${name}`);
+      const result = await checkFn();
+      this.checks.push({ name, success: true, result });
+      this.log(`Check passed: ${name}`, "success");
+      return result;
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      this.errors.push({ name, error: errorMessage });
+      this.checks.push({ name, success: false, error: errorMessage });
+      this.log(`Check failed: ${name} - ${errorMessage}`, "error");
+      return null;
+    }
+  }
+
+  async checkEnvironment() {
+    // Check Node.js version
+    const nodeVersion = process.version;
+    if (!nodeVersion.startsWith("v18") && !nodeVersion.startsWith("v20")) {
+      throw new Error(
+        `Unsupported Node.js version: ${nodeVersion}. Requires v18+`,
+      );
+    }
+
+    // Check for required directories
+    const requiredDirs = ["src", "dist"];
+    for (const dir of requiredDirs) {
+      if (!fs.existsSync(dir)) {
+        throw new Error(`Required directory missing: ${dir}`);
+      }
+    }
+
+    // Check for codex files
+    const codexFiles = ["src/agents_template.md", "AGENTS.md"];
+    let hasCodex = false;
+    for (const file of codexFiles) {
+      if (fs.existsSync(file)) {
+        hasCodex = true;
+        break;
+      }
+    }
+    if (!hasCodex) {
+      throw new Error(
+        "No codex files found. Expected src/agents_template.md or AGENTS.md",
+      );
+    }
+
+    return { nodeVersion, hasCodex: true };
+  }
+
+  async checkFrameworkBoot() {
+    const config = {
+      codexVersion: "1.2.20",
+      contextPath: "src",
+      enableLogging: false, // Disable for testing
+      timeoutMs: 10000,
+    };
+
+    const result = await initializeStrRay(config);
+
+    if (!result.success) {
+      throw new Error(`Boot failed: ${result.message}`);
+    }
+
+    if (!result.codex) {
+      throw new Error("Boot succeeded but no codex returned");
+    }
+
+    if (!result.context) {
+      throw new Error("Boot succeeded but no context returned");
+    }
+
+    return result;
+  }
+
+  async checkLogging() {
+    // Check if log directory was created during boot
+    const logDir = ".strray/logs";
+    if (!fs.existsSync(logDir)) {
+      // This is OK if logging was disabled
+      return { logFiles: 0, loggingDisabled: true };
+    }
+
+    // Check for recent log files
+    const files = fs.readdirSync(logDir);
+    const logFiles = files.filter(
+      (f) => f.startsWith("strray-") && f.endsWith(".log"),
+    );
+
+    if (logFiles.length === 0) {
+      return { logFiles: 0, loggingDisabled: false };
+    }
+
+    // Check most recent log file
+    const latestLog = logFiles.sort().reverse()[0];
+    const logPath = path.join(logDir, latestLog);
+    const logContent = fs.readFileSync(logPath, "utf-8");
+
+    // Check for boot completion log
+    if (!logContent.includes("Boot process completed successfully")) {
+      throw new Error("Boot completion not logged");
+    }
+
+    return { logFiles: logFiles.length, latestLog };
+  }
+
+  async run() {
+    try {
+      // Run all checks
+      const envResult = await this.runCheck("Environment Setup", () =>
+        this.checkEnvironment(),
+      );
+      const bootResult = await this.runCheck("Framework Boot", () =>
+        this.checkFrameworkBoot(),
+      );
+      const logResult = await this.runCheck("Logging System", () =>
+        this.checkLogging(),
+      );
+
+      // Calculate duration
+      const duration = Date.now() - this.startTime;
+
+      // Report results
+
+      const passedChecks = this.checks.filter((c) => c.success).length;
+      const totalChecks = this.checks.length;
+
+      if (bootResult) {
+      }
+
+      if (this.errors.length === 0) {
+        process.exit(0);
+      } else {
+        process.exit(1);
+      }
+    } catch (error) {
+      process.exit(1);
+    }
+  }
+}
+
+// Run the health check
+const checker = new BootChecker();
+checker.run().catch((error) => {
+  process.exit(1);
+});

package/scripts/build/check-syntax.sh

@@ -0,0 +1 @@
+node -c src/plugins/strray-codex-injection.ts 2>&1 || echo "Syntax check failed"

package/scripts/build/check-tsc.sh

@@ -0,0 +1 @@
+npx tsc --version && echo "TypeScript version OK"

package/scripts/build/check-types.sh

@@ -0,0 +1 @@
+npx tsc --project tsconfig.plugin.json --noEmit

package/scripts/build/compile-single.sh

@@ -0,0 +1 @@
+npx tsc src/plugins/strray-codex-injection.ts --outDir dist/plugin --target ES2022 --module ES2022 --moduleResolution bundler --declaration --strict --skipLibCheck 2>&1

package/scripts/build/copy-plugin.sh

@@ -0,0 +1 @@
+cp .opencode/plugin/strray-codex-injection.ts src/plugins/strray-codex-injection.ts

package/scripts/build/manual-build.sh

@@ -0,0 +1 @@
+mkdir -p dist/plugin && npx tsc src/plugins/strray-codex-injection.ts --outDir dist/plugin --target ES2022 --module ES2022 --moduleResolution bundler --esModuleInterop --allowSyntheticDefaultImports --strict --skipLibCheck --declaration 2>&1

package/scripts/build/run-build-after-copy.sh

@@ -0,0 +1 @@
+npm run build:plugin 2>&1 | tail -10

package/scripts/build/run-build-attempt.sh

@@ -0,0 +1 @@
+npm run build:plugin 2>&1

package/scripts/build/run-build-errors-grep.sh

@@ -0,0 +1 @@
+npm run build:plugin 2>&1 | grep -A5 -B5 "error"

package/scripts/build/run-build-errors.sh

@@ -0,0 +1 @@
+npm run build:plugin 2>&1 | tail -20

package/scripts/build/run-build-limited.sh

@@ -0,0 +1 @@
+npm run build:plugin 2>&1 | head -20

package/scripts/build/run-build-list.sh

@@ -0,0 +1 @@
+npx tsc --project tsconfig.plugin.json --listFiles 2>&1 | head -20

package/scripts/build/run-build.sh

@@ -0,0 +1 @@
+npm run build:plugin

package/scripts/build/run-limited.sh

@@ -0,0 +1 @@
+bash test-deployment.sh 2>&1 | head -100

package/scripts/build/run-tsc-direct.sh

@@ -0,0 +1 @@
+npx tsc --project tsconfig.plugin.json 2>&1 | head -50

package/scripts/build/run-type-check.sh

@@ -0,0 +1 @@
+npx tsc --project tsconfig.plugin.json --noEmit 2>&1 | head -50

package/scripts/build/run-typecheck.sh

@@ -0,0 +1 @@
+npx tsc --project tsconfig.plugin.json --noEmit 2>&1 | head -30

package/scripts/build/test-build.sh

@@ -0,0 +1 @@
+npm run build:plugin