0xray 2.0.0 → 2.1.0

package/dist/postprocessor/types.d.ts

@@ -0,0 +1,227 @@
+/**
+ * Post-Processor Type Definitions
+ */
+export interface PostProcessorConfig {
+    triggers: {
+        gitHooks: boolean;
+        webhooks: boolean;
+        api: boolean;
+    };
+    monitoring: {
+        enabled: boolean;
+        interval: number;
+        timeout: number;
+    };
+    autoFix: {
+        enabled: boolean;
+        confidenceThreshold: number;
+        maxAttempts: number;
+    };
+    maxAttempts: number;
+    retryDelay: number;
+    escalation: {
+        manualInterventionThreshold: number;
+        rollbackThreshold: number;
+        emergencyThreshold: number;
+    };
+    redeploy: {
+        maxRetries: number;
+        retryDelay: number;
+        backoffStrategy: "linear" | "exponential";
+        canaryEnabled: boolean;
+        canaryPhases: number;
+        canaryTrafficIncrement: number;
+        healthCheckTimeout: number;
+        rollbackOnFailure: boolean;
+    };
+    success: {
+        successConfirmation: boolean;
+        cleanupEnabled: boolean;
+        notificationEnabled: boolean;
+        metricsCollection: boolean;
+    };
+    reporting: {
+        enabled: boolean;
+        autoGenerate: boolean;
+        reportThreshold: number;
+        reportDir: string;
+        retentionDays: number;
+    };
+}
+export interface PostProcessorContext {
+    commitSha: string;
+    repository: string;
+    branch: string;
+    author: string;
+    files: string[];
+    trigger: "git-hook" | "webhook" | "api" | "manual";
+    tool?: string | undefined;
+    operation?: string | undefined;
+    testResults?: {
+        unit?: {
+            passed: boolean;
+            coverage: number;
+        };
+        integration?: {
+            passed: boolean;
+            coverage: number;
+        };
+        e2e?: {
+            passed: boolean;
+            coverage: number;
+        };
+        performance?: {
+            passed: boolean;
+            coverage: number;
+        };
+    };
+    directory?: string;
+    filePath?: string;
+    args?: Record<string, unknown>;
+}
+export interface PostProcessorResult {
+    success: boolean;
+    commitSha: string;
+    sessionId: string;
+    attempts: number;
+    monitoringResults?: MonitoringResult[];
+    fixesApplied?: AppliedFix[];
+    error?: string;
+    duration?: number;
+}
+export interface MonitoringResult {
+    commitSha: string;
+    overallStatus: "success" | "failure" | "running";
+    timestamp: Date;
+    ciStatus?: CIStatus;
+    performanceStatus?: PerformanceStatus;
+    securityStatus?: SecurityStatus;
+    failedJobs?: string[];
+    duration: number;
+}
+export interface AppliedFix {
+    type: string;
+    files: string[];
+    description: string;
+    timestamp: Date;
+    rollbackData?: unknown;
+}
+export interface FixResult {
+    success: boolean;
+    appliedFixes: AppliedFix[];
+    requiresManualIntervention: boolean;
+    confidence: number;
+    rollbackAvailable: boolean;
+}
+export interface CIStatus {
+    status: "success" | "failure" | "running";
+    failedJobs: string[];
+    totalJobs: number;
+    duration: number;
+}
+export interface PerformanceStatus {
+    status: "passed" | "failed" | "warning";
+    score: number;
+    regressions: string[];
+    duration: number;
+}
+export interface SecurityStatus {
+    status: "passed" | "failed" | "warning";
+    vulnerabilities: number;
+    criticalVulnerabilities: number;
+    scanDuration: number;
+}
+export interface FailureAnalysis {
+    category: string;
+    severity: "low" | "medium" | "high" | "critical";
+    confidence: number;
+    rootCause: string;
+    recommendedActions: string[];
+    suggestedFixes: SuggestedFix[];
+}
+export interface SuggestedFix {
+    type: "dependency-update" | "code-fix" | "config-change" | "test-regeneration";
+    confidence: number;
+    description: string;
+    files: string[];
+    changes: (Record<string, unknown> | string)[];
+}
+export interface FixResult {
+    success: boolean;
+    appliedFixes: AppliedFix[];
+    requiresManualIntervention: boolean;
+    confidence: number;
+    rollbackAvailable: boolean;
+}
+export interface EscalationResult {
+    level: "manual-intervention" | "rollback" | "emergency";
+    reason: string;
+    recommendations: string[];
+    incidentReport: IncidentReport;
+}
+export interface IncidentReport {
+    id: string;
+    commitSha: string;
+    timestamp: Date;
+    severity: string;
+    affectedSystems: string[];
+    rootCause: string;
+    impact: string;
+    resolution: string;
+    timeline: EventTimeline[];
+}
+export interface EventTimeline {
+    timestamp: Date;
+    event: string;
+    details: string;
+}
+export interface RedeployResult {
+    success: boolean;
+    deploymentId: string;
+    commitSha: string;
+    environment: string;
+    duration: number;
+    error?: string;
+    rollbackPerformed?: boolean;
+    canaryResults?: CanaryResult[];
+}
+export interface CanaryResult {
+    phase: number;
+    trafficPercentage: number;
+    success: boolean;
+    metrics: {
+        responseTime: number;
+        errorRate: number;
+        throughput: number;
+    };
+    duration: number;
+}
+export type PostProcessorEvent = {
+    type: "initialized";
+    config: PostProcessorConfig;
+} | {
+    type: "loop-started";
+    context: PostProcessorContext;
+} | {
+    type: "monitoring-completed";
+    result: MonitoringResult;
+} | {
+    type: "failure-detected";
+    analysis: FailureAnalysis;
+} | {
+    type: "fix-applied";
+    result: FixResult;
+} | {
+    type: "redeployment-initiated";
+    commitSha: string;
+} | {
+    type: "loop-completed";
+    result: PostProcessorResult;
+} | {
+    type: "escalation-triggered";
+    result: EscalationResult;
+} | {
+    type: "error";
+    error: Error;
+    context: PostProcessorContext;
+};

package/dist/processors/doc-write-guard.d.ts

@@ -0,0 +1,6 @@
+export declare class DocWriteGuard {
+    static append(filePath: string, content: string): Promise<void>;
+    static createIfMissing(filePath: string, content: string): Promise<void>;
+    static isDocFile(filePath: string): boolean;
+    static isDocPath(filePath: string): boolean;
+}

package/dist/processors/implementations/agents-md-validation-processor.d.ts

@@ -0,0 +1,63 @@
+/**
+ * AGENTS.md Validation Processor
+ *
+ * Pre-processor that validates AGENTS.md exists and is up-to-date before
+ * allowing commits. Integrates with 0xRay's processor pipeline.
+ *
+ * @processor_type pre
+ * @priority 90 (high - runs early)
+ * @blocking true (blocks commit if AGENTS.md is invalid)
+ *
+ * @version 1.0.0
+ * @framework 0xRay 1.3.5
+ */
+export interface AgentsMdValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    fixes?: string[];
+}
+export declare class AgentsMdValidationProcessor {
+    private projectRoot;
+    private agentsPath;
+    private readonly REQUIRED_SECTIONS;
+    private readonly REQUIRED_AGENTS;
+    private readonly RECOMMENDED_SECTIONS;
+    constructor(projectRoot?: string);
+    /**
+     * Main execution method - called by ProcessorManager
+     */
+    execute(context: {
+        tool: string;
+        args?: {
+            filePath?: string;
+            content?: string;
+        };
+        operation: string;
+    }): Promise<{
+        success: boolean;
+        blocked: boolean;
+        message: string;
+        result?: AgentsMdValidationResult;
+    }>;
+    /**
+     * Determine if the change is agent-related
+     */
+    private isAgentRelatedChange;
+    /**
+     * Validate AGENTS.md file
+     */
+    private validateAgentsMd;
+    /**
+     * Calculate days since date
+     */
+    private calculateDaysOld;
+    private getPackageVersion;
+    private getSectionTemplate;
+    appendMissing(): Promise<{
+        success: boolean;
+        message: string;
+        added: string[];
+    }>;
+}
+export declare const agentsMdValidationProcessor: AgentsMdValidationProcessor;

package/dist/processors/implementations/agents-md-validation-processor.js

@@ -212,7 +212,7 @@ export class AgentsMdValidationProcessor {
                 "",
                 "## Available Skills",
                 "",
-                "StringRay ships with 30 framework skills and provides a registry of 10 curated community sources.",
+                "Xray ships with 30 framework skills and provides a registry of 10 curated community sources.",
                 "",
                 "```bash",
                 "npx 0xray skill:install              # Show starter packs + available sources",
@@ -225,7 +225,7 @@ export class AgentsMdValidationProcessor {
                 "",
                 "## Codex",
                 "",
-                `StringRay enforces Universal Development Codex (60 terms) for systematic error prevention.`,
+                `Xray enforces Universal Development Codex (60 terms) for systematic error prevention.`,
                 "",
             ].join("\n"),
             "## CLI Commands": [

package/dist/processors/implementations/async-pattern-processor.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Async Pattern Processor
+ *
+ * Enforces codex term #31: Async Pattern Detection.
+ * Detects anti-patterns in async code: callback patterns, long promise chains,
+ * missing await inside async functions, and mixed callback/promise styles.
+ *
+ * @version 1.0.0
+ * @since 2026-03-28
+ */
+import type { PreValidateContext, ProcessorExecutionResult } from "../processor-types.js";
+export type AsyncViolationType = "callbackPattern" | "longPromiseChain" | "missingAwait" | "mixedCallbackAsync";
+export interface AsyncViolation {
+    type: AsyncViolationType;
+    line?: number;
+    message: string;
+    snippet?: string;
+}
+export declare class AsyncPatternProcessor {
+    /**
+     * Run all async-pattern checks against `content`.
+     */
+    checkCode(content: string): AsyncViolation[];
+    /**
+     * Detect node-style callbacks: `function(err, ` or inline function callbacks.
+     */
+    hasCallbackPattern(content: string): boolean;
+    /**
+     * Detect promise chains with more than 3 .then() calls.
+     */
+    hasLongPromiseChain(content: string): boolean;
+    /**
+     * Detect async functions that contain .then() or `new Promise` without an
+     * accompanying await in the same scope.
+     */
+    hasMissingAwait(content: string): boolean;
+    /**
+     * Detect callbacks used inside async functions.
+     */
+    hasMixedCallbackAsync(content: string): boolean;
+    private countPromiseChains;
+    /**
+     * Within an async function body, check if .then() or new Promise is used
+     * without await. If so, return a marker string; otherwise return original.
+     */
+    private _checkAsyncBodyForMissingAwait;
+}
+export declare function runAsyncPatternCheck(context: PreValidateContext): Promise<ProcessorExecutionResult>;

package/dist/processors/implementations/codex-compliance-processor.d.ts

@@ -0,0 +1,7 @@
+import { PreProcessor } from "../processor-interfaces.js";
+import type { ProcessorContext } from "../processor-types.js";
+export declare class CodexComplianceProcessor extends PreProcessor {
+    readonly name = "codexCompliance";
+    readonly priority = 2;
+    protected run(context: ProcessorContext): Promise<Record<string, unknown>>;
+}

package/dist/processors/implementations/commit-batcher-processor.d.ts

@@ -0,0 +1,13 @@
+import { PostProcessor } from "../processor-interfaces.js";
+import type { ProcessorContext, ProcessorResult } from "../processor-types.js";
+import { IntelligentCommitBatcher } from "../../orchestrator/intelligent-commit-batcher.js";
+export declare class CommitBatcherProcessor extends PostProcessor {
+    readonly name = "commitBatcher";
+    readonly priority = 85;
+    private trackedCount;
+    private batcher;
+    constructor(batcher?: IntelligentCommitBatcher);
+    protected run(context: ProcessorContext): Promise<Record<string, unknown>>;
+    private inferChangeType;
+}
+export declare function executeCommitBatcherProcessor(context: ProcessorContext): Promise<ProcessorResult>;

package/dist/processors/implementations/console-log-guard-processor.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Console Log Guard Processor
+ *
+ * Enforces codex term #33: Console Log Guard.
+ * Scans code for forbidden console.log/warn/error/info/debug usage,
+ * ensuring all logging goes through frameworkLogger instead.
+ *
+ * @version 1.0.0
+ * @since 2026-03-28
+ */
+import type { PreValidateContext, ProcessorExecutionResult } from "../processor-types.js";
+export interface ConsoleLogViolation {
+    line: number;
+    type: "log" | "warn" | "error" | "info" | "debug";
+    matched: string;
+}
+export declare class ConsoleLogGuardProcessor {
+    /**
+     * Scan code content for forbidden console method calls.
+     * Returns violations with line numbers.
+     */
+    checkCode(content: string, filePath?: string): ConsoleLogViolation[];
+    /**
+     * Determine if a file path points to a test file.
+     */
+    isTestFile(filePath: string): boolean;
+    /**
+     * Remove single-line (//) and multi-line comments from source code.
+     * Preserves line structure so line numbers remain valid.
+     */
+    stripComments(content: string): string;
+}
+export declare function runConsoleLogGuard(context: PreValidateContext): Promise<ProcessorExecutionResult>;

package/dist/processors/implementations/coverage-analysis-processor.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Coverage Analysis Processor
+ *
+ * Analyzes test coverage for modified files and reports coverage gaps.
+ *
+ * @module processors/implementations
+ * @version 1.0.0
+ */
+import { PostProcessor } from "../processor-interfaces.js";
+import { ProcessorContext } from "../processor-types.js";
+export declare class CoverageAnalysisProcessor extends PostProcessor {
+    readonly name = "coverageAnalysis";
+    readonly priority = 45;
+    protected run(context: ProcessorContext): Promise<unknown>;
+    private analyzeCoverage;
+    private findRelatedTestFiles;
+    private countSourceLines;
+    private countTestLines;
+}
+export declare const coverageAnalysisProcessor: CoverageAnalysisProcessor;

package/dist/processors/implementations/error-boundary-processor.d.ts

@@ -0,0 +1,7 @@
+import { PreProcessor } from "../processor-interfaces.js";
+import type { ProcessorContext, ProcessorResult } from "../processor-types.js";
+export declare class ErrorBoundaryProcessor extends PreProcessor {
+    readonly name = "errorBoundary";
+    readonly priority = 5;
+    protected run(context: ProcessorContext): Promise<ProcessorResult>;
+}

package/dist/processors/implementations/inference-improvement-processor.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Inference Improvement Coordinator
+ *
+ * Lightweight processor that coordinates the agent-based inference workflow.
+ * The actual analysis is done by collaborating agents (researcher, code-analyzer,
+ * architect, code-reviewer, enforcer) - this processor prepares context and triggers.
+ *
+ * @module processors/implementations
+ */
+import { PostProcessor } from "../processor-interfaces.js";
+export declare class InferenceImprovementProcessor extends PostProcessor {
+    readonly name = "inferenceImprovement";
+    readonly priority = 5;
+    private readonly reflectionsDir;
+    private readonly logsDir;
+    private readonly reportsDir;
+    private readonly workflowDir;
+    private readonly inferenceEnabled;
+    private readonly patternMatchingEnabled;
+    private readonly patternMatchingThreshold;
+    constructor();
+    private loadInferenceConfig;
+    protected run(context: unknown): Promise<unknown>;
+    private prepareWorkflowContext;
+    private findReflections;
+    private findLogs;
+    private findReports;
+    private saveWorkflowContext;
+    private generateAgentPrompts;
+    private generateResearcherPrompt;
+    private generateCodeAnalyzerPrompt;
+    private generateArchitectPrompt;
+    private generateCodeReviewerPrompt;
+    private generateEnforcerPrompt;
+    private triggerAgentWorkflow;
+}

package/dist/processors/implementations/inference-improvement-processor.js

@@ -38,8 +38,8 @@ export class InferenceImprovementProcessor extends PostProcessor {
     loadInferenceConfig() {
         try {
             const configPaths = [
-                path.join(process.cwd(), ".strray", "features.json"),
-                path.join(process.cwd(), ".opencode", "strray", "features.json"),
+                path.join(process.cwd(), ".xray", "features.json"),
+                path.join(process.cwd(), ".opencode", "xray", "features.json"),
             ];
             for (const configPath of configPaths) {
                 if (fs.existsSync(configPath)) {

package/dist/processors/implementations/log-protection-processor.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Log Protection Processor
+ *
+ * Prevents deletion of critical inference log files that are essential
+ * for the tuning engines and pattern learning system.
+ *
+ * Protected files:
+ * - routing-outcomes.json (routing analytics - NEVER delete)
+ * - activity.log (framework activity - NEVER delete)
+ * - xray-plugin-*.log (plugin logs)
+ *
+ * Archival flow is ALLOWED:
+ * - framework-activity-*.log.gz (archived/compressed logs)
+ * - Copy operations to create new archive files
+ *
+ * @module processors/implementations
+ * @version 1.1.0
+ */
+import { PreProcessor } from "../processor-interfaces.js";
+import { ProcessorContext } from "../processor-types.js";
+export declare class LogProtectionProcessor extends PreProcessor {
+    readonly name = "logProtection";
+    readonly priority = 10;
+    protected run(context: ProcessorContext): Promise<unknown>;
+    private isDeleteOperation;
+    private isArchiveCleanup;
+    private getActiveLogFile;
+    private getOperation;
+}
+export declare const logProtectionProcessor: LogProtectionProcessor;

package/dist/processors/implementations/log-protection-processor.js

@@ -7,7 +7,7 @@
  * Protected files:
  * - routing-outcomes.json (routing analytics - NEVER delete)
  * - activity.log (framework activity - NEVER delete)
- * - strray-plugin-*.log (plugin logs)
+ * - xray-plugin-*.log (plugin logs)
  *
  * Archival flow is ALLOWED:
  * - framework-activity-*.log.gz (archived/compressed logs)
@@ -31,7 +31,7 @@ const ACTIVE_LOG_PATTERNS = [
  */
 const ARCHIVE_PATTERNS = [
     /framework-activity-.+\.log\.gz$/,
-    /strray-plugin-.+\.log\.gz$/,
+    /xray-plugin-.+\.log\.gz$/,
 ];
 /**
  * Directories/files that are protected

package/dist/processors/implementations/nudge-processor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Nudge Processor - Integrates Nudge Watchdog with processor system
+ *
+ * Post-processor that monitors agent actions and triggers nudges
+ * when stuck patterns are detected.
+ *
+ * @module processors/implementations
+ * @version 1.0.0
+ */
+import { PostProcessor } from "../processor-interfaces.js";
+import { ProcessorContext, ProcessorResult } from "../processor-types.js";
+export declare class NudgeProcessor extends PostProcessor {
+    readonly name = "nudge";
+    readonly priority = 100;
+    private nudgeEnabled;
+    constructor();
+    private loadConfig;
+    protected run(context: ProcessorContext): Promise<unknown>;
+    private detectMostUrgentNudge;
+}
+export declare const nudgeProcessor: NudgeProcessor;
+export declare function executeNudgeProcessor(context: ProcessorContext): Promise<ProcessorResult>;

package/dist/processors/implementations/performance-budget-processor.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Performance Budget Processor
+ *
+ * Enforces codex term #28: Performance Budgets.
+ * Checks code content against configurable size, function-length, nesting-depth,
+ * and parameter-count budgets. Returns structured violation lists.
+ *
+ * @version 1.0.0
+ * @since 2026-03-28
+ */
+import type { PreValidateContext, ProcessorExecutionResult } from "../processor-types.js";
+export type PerformanceViolationType = "fileTooLarge" | "functionTooLong" | "nestingTooDeep" | "tooManyParameters";
+export interface PerformanceViolation {
+    type: PerformanceViolationType;
+    filePath: string;
+    line?: number;
+    message: string;
+    actual: number;
+    limit: number;
+}
+export interface PerformanceBudgetConfig {
+    maxFileSizeBytes: number;
+    maxFunctionLines: number;
+    maxNestingDepth: number;
+    maxParameters: number;
+}
+export declare const DEFAULT_PERFORMANCE_BUDGET: PerformanceBudgetConfig;
+export declare class PerformanceBudgetProcessor {
+    private readonly config;
+    constructor(config?: Partial<PerformanceBudgetConfig>);
+    /**
+     * Check a file against all budget rules.
+     */
+    checkFile(filePath: string, content: string): PerformanceViolation[];
+    /**
+     * Analyse every function body in `content` and check complexity budgets.
+     */
+    checkFunctionComplexity(content: string): PerformanceViolation[];
+    /**
+     * Regex-based extraction of named functions / methods / arrow functions.
+     * Does NOT require a full AST – keeps the processor zero-dependency.
+     */
+    private extractFunctions;
+    /**
+     * Measure the maximum nesting depth by tracking control-flow keywords
+     * (if / for / while / switch / try) inside the function body.
+     */
+    private measureMaxNesting;
+}
+export declare function runPerformanceBudgetCheck(context: PreValidateContext): Promise<ProcessorExecutionResult>;

package/dist/processors/implementations/postprocessor-chain-validator.d.ts

@@ -0,0 +1,46 @@
+/**
+ * PostProcessor Chain Validator
+ *
+ * Validates postprocessor execution chain integrity.
+ * Checks that all registered postprocessors executed without errors,
+ * validates priority ordering, and detects skipped or crashed processors.
+ *
+ * @version 1.0.0
+ * @since 2026-03-28
+ */
+import type { PostValidateContext, ProcessorExecutionResult } from "../processor-types.js";
+export interface ChainValidationResult {
+    valid: boolean;
+    issues: ChainIssue[];
+}
+export interface ChainIssue {
+    severity: "error" | "warning";
+    processorName: string;
+    message: string;
+}
+export interface ChainReport {
+    totalProcessors: number;
+    successful: number;
+    failed: number;
+    skipped: number;
+    issues: ChainIssue[];
+    averageDuration: number;
+    executedInPriorityOrder: boolean;
+}
+export declare class PostProcessorChainValidator {
+    private chainReport;
+    /**
+     * Validate the postprocessor execution chain.
+     */
+    validateChain(results: Array<{
+        name: string;
+        success: boolean;
+        duration: number;
+        priority?: number;
+    }>): ChainValidationResult;
+    /**
+     * Get the chain report from the most recent validation.
+     */
+    getChainReport(): ChainReport;
+}
+export declare function runPostProcessorChainValidation(context: PostValidateContext): Promise<ProcessorExecutionResult>;

package/dist/processors/implementations/pre-validate-processor.d.ts

@@ -0,0 +1,7 @@
+import { PreProcessor } from "../processor-interfaces.js";
+import type { ProcessorContext } from "../processor-types.js";
+export declare class PreValidateProcessor extends PreProcessor {
+    readonly name = "preValidate";
+    readonly priority = 1;
+    protected run(context: ProcessorContext): Promise<Record<string, unknown>>;
+}