0xray 3.1.0 → 3.2.0

package/dist/postprocessor/PostProcessor.js

@@ -4,12 +4,11 @@
  * Automated CI/CD loop orchestration: commit → push → monitor → fix → redeploy → monitor
  * Provides systematic error prevention and deployment automation.
  *
- * @version 1.0.0
  * @since 2026-01-13
  */
 import * as path from "path";
 import { frameworkLogger } from "../core/framework-logger.js";
-import { resolveConfigPath } from "../core/config-paths.js";
+import { featuresConfigLoader } from "../core/features-config.js";
 import { GitHookTrigger } from "./triggers/GitHookTrigger.js";
 import { WebhookTrigger } from "./triggers/WebhookTrigger.js";
 import { APITrigger } from "./triggers/APITrigger.js";
@@ -205,14 +204,9 @@ export class PostProcessor {
      * FIX: Issue #2 - Make processor registration configurable
      */
     async loadProcessorConfig() {
-        const fs = await import("fs");
-        const path = await import("path");
         try {
-            const configPath = resolveConfigPath("features.json") ?? path.join(process.cwd(), ".opencode", "xray", "features.json");
-            if (fs.existsSync(configPath)) {
-                const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-                return config.processors || {};
-            }
+            const config = featuresConfigLoader.loadConfig();
+            return config.processors ?? {};
         }
         catch (error) {
             frameworkLogger.log("postprocessor", "processor-config-load-failed", "info", {
@@ -333,8 +327,8 @@ export class PostProcessor {
     }
     async checkSystemIntegrity(context) {
         // Check if all critical framework components are active
-        const stateManager = globalThis.strRayStateManager;
-        const postProcessor = globalThis.strRayPostProcessor;
+        const stateManager = globalThis.xrayStateManager;
+        const postProcessor = globalThis.xrayPostProcessor;
         if (!stateManager) {
             try {
                 const { XrayStateManager } = await import("../state/state-manager.js");
@@ -372,7 +366,7 @@ export class PostProcessor {
         // Check for path resolution issues in committed files
         // This would require reading the actual file contents from git
         // For now, we verify that the framework's path resolution is working
-        const pathResolver = globalThis.strRayPathResolver;
+        const pathResolver = globalThis.xrayPathResolver;
         if (!pathResolver) {
             return {
                 passed: true,
@@ -500,7 +494,7 @@ import { Config } from "./config/config.js";
 
 **Solution A: Environment Variables (Simple)**
 \`\`\`typescript
-const AGENTS_PATH = process.env.STRRAY_AGENTS_PATH || '../agents';
+const AGENTS_PATH = process.env.XRAY_AGENTS_PATH || '../agents';
 import { AgentConfig } from \`\${AGENTS_PATH}/code-reviewer.js\`;
 \`\`\`
 

package/dist/postprocessor/analysis/CodeChangeAnalyzer.js

@@ -0,0 +1,50 @@
+import { frameworkLogger } from "../../core/framework-logger.js";
+export class CodeChangeAnalyzer {
+    async analyzeCodeChanges(context) {
+        const fs = await import("fs");
+        const path = await import("path");
+        const newCode = new Map();
+        const existingCode = new Map();
+        const tests = [];
+        const dependencies = [];
+        try {
+            // Read new/changed files
+            for (const file of context.files || []) {
+                try {
+                    const fullPath = path.join(process.cwd(), file);
+                    if (fs.existsSync(fullPath)) {
+                        // Read new code
+                        const content = fs.readFileSync(fullPath, "utf-8");
+                        newCode.set(file, content);
+                        // Check for test files
+                        if (file.includes(".test.") || file.includes(".spec.")) {
+                            tests.push(file);
+                        }
+                        // Check for package.json or dependency files
+                        if (file.includes("package.json") || file.includes("requirements.txt") || file.includes("Cargo.toml")) {
+                            dependencies.push(file);
+                        }
+                    }
+                }
+                catch (error) {
+                    // Skip files that can't be read
+                    await frameworkLogger.log("-post-processor", "-code-analysis-file-error", "info", { message: `Could not analyze ${file}: ${error}` });
+                }
+            }
+            await frameworkLogger.log("-post-processor", "-code-analysis-complete", "info", {
+                message: `Analyzed ${newCode.size} files, ${tests.length} tests, ${dependencies.length} dependencies`,
+            });
+        }
+        catch (error) {
+            await frameworkLogger.log("-post-processor", "-code-analysis-failed", "error", { message: `Code analysis failed: ${error}` });
+        }
+        return {
+            operation: "commit",
+            files: context.files || [],
+            newCode,
+            existingCode,
+            tests,
+            dependencies,
+        };
+    }
+}

package/dist/postprocessor/config/ProcessorConfigLoader.js

@@ -0,0 +1,16 @@
+import { featuresConfigLoader } from "../../core/features-config.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+export class ProcessorConfigLoader {
+    async loadProcessorConfig() {
+        try {
+            const config = featuresConfigLoader.loadConfig();
+            return config.processors ?? {};
+        }
+        catch (error) {
+            frameworkLogger.log("postprocessor", "processor-config-load-failed", "info", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        return {};
+    }
+}

package/dist/postprocessor/integration.js

@@ -0,0 +1,194 @@
+/**
+ * 0xRay Integration Layer
+ *
+ * Provides generic connectors for integrating 0xRay's PostProcessor
+ * with external applications and frameworks.
+ *
+ * This is framework-agnostic - works with Express, Fastify, Koa, etc.
+ *
+ * @since 2026-03-08
+ */
+export { WebhookTrigger } from './triggers/WebhookTrigger.js';
+export { APITrigger } from './triggers/APITrigger.js';
+/**
+ * Generic 0xRay integration for any external application
+ *
+ * Provides:
+ * - Webhook receivers (GitHub, GitLab, Bitbucket, Stripe)
+ * - REST API triggers (manual trigger, retry, status)
+ * - Framework-agnostic (works with Express, Fastify, Koa, etc.)
+ *
+ * @example
+ * ```typescript
+ * import { createXrayIntegration } from '0xray/integration';
+ *
+ * const postProcessor = new PostProcessor(stateManager);
+ * const integration = createXrayIntegration(postProcessor);
+ *
+ * // Get Express app for mounting
+ * app.use('/webhooks', integration.getWebhookApp());
+ * app.use('/api/post-process', integration.getAPIApp());
+ *
+ * // Or get raw routers for Fastify/Koa
+ * const webhookRouter = integration.getWebhookRouter();
+ * const apiRouter = integration.getAPIRouter();
+ * ```
+ */
+export class XrayIntegration {
+    postProcessor;
+    webhookTrigger = null;
+    apiTrigger = null;
+    constructor(postProcessor) {
+        this.postProcessor = postProcessor;
+    }
+    /**
+     * Initialize all triggers with default configuration
+     *
+     * @param config - Optional configuration for triggers
+     */
+    async initialize(config) {
+        const { WebhookTrigger } = await import('./triggers/WebhookTrigger.js');
+        const { APITrigger } = await import('./triggers/APITrigger.js');
+        // Initialize webhook trigger with default GitHub config
+        this.webhookTrigger = new WebhookTrigger(this.postProcessor, {
+            provider: 'github',
+            events: ['push', 'pull_request'],
+            path: '/webhooks/github',
+            verifySignature: true,
+            ...config?.webhook
+        });
+        await this.webhookTrigger.initialize();
+        // Initialize API trigger with default config
+        this.apiTrigger = new APITrigger(this.postProcessor, {
+            enabled: true,
+            path: '/api/post-process',
+            ...config?.api
+        });
+        await this.apiTrigger.initialize();
+    }
+    /**
+     * Get webhook app for framework-specific mounting
+     *
+     * Returns an Express Application. For other frameworks,
+     * use getWebhookRouter() to get the router instance.
+     *
+     * @example
+     * ```typescript
+     * // Express
+     * app.use('/webhooks', integration.getWebhookApp());
+     *
+     * // Fastify
+     * await fastify.register(integration.getWebhookRouter(), { prefix: '/webhooks' });
+     *
+     * // Koa
+     * app.use(integration.getWebhookRouter().routes());
+     * ```
+     */
+    getWebhookApp() {
+        return this.webhookTrigger?.getApp() ?? null;
+    }
+    /**
+     * Get webhook router (raw Express router)
+     *
+     * Useful for frameworks that need the router instance directly
+     * rather than the full Express app.
+     */
+    getWebhookRouter() {
+        return this.webhookTrigger?.getApp() ?? null;
+    }
+    /**
+     * Get API trigger app for framework-specific mounting
+     *
+     * @example
+     * ```typescript
+     * // Express
+     * app.use('/api/post-process', integration.getAPIApp());
+     *
+     * // Fastify
+     * await fastify.register(integration.getAPIRouter(), { prefix: '/api/post-process' });
+     * ```
+     */
+    getAPIApp() {
+        return this.apiTrigger?.getApp() ?? null;
+    }
+    /**
+     * Get API trigger router (raw Express router)
+     *
+     * Useful for frameworks that need the router instance directly.
+     */
+    getAPIRouter() {
+        return this.apiTrigger?.getApp() ?? null;
+    }
+    /**
+     * Manually trigger PostProcessor via API
+     *
+     * Convenience method for programmatic triggering without
+     * going through the HTTP endpoint.
+     *
+     * @example
+     * ```typescript
+     * await integration.trigger({
+     *   tool: 'test',
+     *   operation: 'run',
+     *   reason: 'Manual test trigger'
+     * });
+     * ```
+     */
+    async trigger(options) {
+        const context = {
+            commitSha: `manual-${Date.now()}`,
+            repository: '',
+            branch: '',
+            author: 'manual',
+            files: [],
+            trigger: 'manual',
+            tool: options.tool,
+            operation: options.operation,
+            ...(options.filePath !== undefined ? { filePath: options.filePath } : {}),
+            ...(options.directory !== undefined ? { directory: options.directory } : {}),
+        };
+        await this.postProcessor.executePostProcessorLoop(context);
+    }
+    /**
+     * Shutdown all triggers
+     */
+    async shutdown() {
+        if (this.webhookTrigger) {
+            this.webhookTrigger.shutdown();
+        }
+        if (this.apiTrigger) {
+            this.apiTrigger.shutdown();
+        }
+    }
+}
+/**
+ * Factory function for easy integration setup
+ *
+ * @example
+ * ```typescript
+ * import { createXrayIntegration } from '0xray/integration';
+ *
+ * // With default configuration
+ * const integration = createXrayIntegration(postProcessor);
+ * await integration.initialize();
+ *
+ * // With custom configuration
+ * const integration = createXrayIntegration(postProcessor);
+ * await integration.initialize({
+ *   webhook: {
+ *     provider: 'gitlab',
+ *     secret: process.env.GITLAB_WEBHOOK_SECRET,
+ *     events: ['push', 'merge_request'],
+ *     path: '/webhooks/gitlab'
+ *   },
+ *   api: {
+ *     path: '/api/stray-trigger',
+ *     apiKey: process.env.API_KEY
+ *   }
+ * });
+ * ```
+ */
+export function createXrayIntegration(postProcessor) {
+    return new XrayIntegration(postProcessor);
+}
+// Backward compat aliases