strray-ai 1.22.68 → 1.22.69

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

@@ -0,0 +1,112 @@
+/**
+ * Version Compliance Processor
+ *
+ * Pre-processor that enforces version compliance rules before allowing
+ * commits or publishes. Integrates with 0xRay's processor pipeline.
+ *
+ * Rules Enforced:
+ * 1. Universal Version Manager MUST be 1 ahead of NPM published version
+ * 2. package.json SHOULD match UVM (warning if not)
+ * 3. Source files MUST be synchronized to UVM version
+ * 4. README SHOULD reference current version
+ *
+ * @processor_type pre
+ * @priority 25 (high - runs early, after preValidate, before errorBoundary)
+ * @blocking true (blocks on violations)
+ *
+ * @version 1.0.0
+ * @framework 0xRay 1.3.5
+ */
+export interface VersionComplianceResult {
+    compliant: boolean;
+    npmVersion: string;
+    uvmVersion: string;
+    pkgVersion: string;
+    errors: string[];
+    warnings: string[];
+    fixes?: VersionFix[];
+}
+export interface VersionFix {
+    type: "update-uvm" | "sync-source" | "update-readme";
+    description: string;
+    command: string;
+    autoFixable: boolean;
+}
+export interface VersionInfo {
+    major: number;
+    minor: number;
+    patch: number;
+    raw: string;
+}
+export declare class VersionComplianceProcessor {
+    private projectRoot;
+    private errors;
+    private warnings;
+    private fixes;
+    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?: VersionComplianceResult;
+    }>;
+    /**
+     * Validate all version compliance rules
+     */
+    validateVersionCompliance(): Promise<VersionComplianceResult>;
+    /**
+     * Get NPM published version
+     */
+    private getNpmVersion;
+    /**
+     * Get Universal Version Manager version
+     */
+    private getUvmVersion;
+    /**
+     * Get package.json version
+     */
+    private getPackageVersion;
+    /**
+     * Get version from source files
+     */
+    private getSourceVersion;
+    /**
+     * Get version from README
+     */
+    private getReadmeVersion;
+    /**
+     * Parse version string into components
+     */
+    private parseVersion;
+    /**
+     * Format version components back to string
+     */
+    private formatVersion;
+    /**
+     * Increment patch version
+     */
+    private incrementPatch;
+    /**
+     * Auto-fix version compliance issues
+     */
+    autoFix(): Promise<{
+        success: boolean;
+        fixed: string[];
+        failed: string[];
+    }>;
+    /**
+     * Generate compliance report
+     */
+    generateReport(result: VersionComplianceResult): string;
+}
+export declare const versionComplianceProcessor: VersionComplianceProcessor;

package/dist/processors/processor-interfaces.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Processor Interface and Base Classes
+ *
+ * Defines the contract for all processors in the 0xRay framework.
+ * Replaces the switch statement anti-pattern in ProcessorManager with
+ * polymorphic processor classes.
+ *
+ * @module processors/interfaces
+ * @version 1.0.0
+ */
+import { ProcessorContext, ProcessorResult, LogProtectionProcessorResult, TestExecutionResult, CodexComplianceProcessorResult, VersionComplianceProcessorResult, TestAutoCreationResult, CoverageAnalysisResult } from "./processor-types.js";
+/**
+ * Union of all known processor result types for type safety
+ */
+export type ProcessorResultData = LogProtectionProcessorResult | TestExecutionResult | CodexComplianceProcessorResult | VersionComplianceProcessorResult | TestAutoCreationResult | CoverageAnalysisResult;
+/**
+ * Processor interface - all processors must implement this
+ */
+export interface IProcessor {
+    /** Unique processor identifier */
+    readonly name: string;
+    /** Processor type: pre or post */
+    readonly type: "pre" | "post";
+    /** Execution priority (lower = earlier) */
+    readonly priority: number;
+    /** Whether processor is enabled */
+    enabled: boolean;
+    /**
+     * Execute the processor
+     * @param context Processor execution context
+     * @returns Processor result
+     */
+    execute(context: ProcessorContext): Promise<ProcessorResult>;
+}
+/**
+ * Base processor class with common functionality
+ */
+export type ProcessorDependency = "stateManager" | "config" | "logger";
+export interface ProcessorDependencies {
+    stateManager?: unknown;
+    config?: unknown;
+    logger?: unknown;
+}
+export declare abstract class BaseProcessor implements IProcessor {
+    abstract readonly name: string;
+    abstract readonly type: "pre" | "post";
+    abstract readonly priority: number;
+    enabled: boolean;
+    static readonly dependencies?: ProcessorDependency[];
+    /**
+     * Execute the processor with error handling and metrics
+     * @param context Processor execution context
+     * @returns Processor result
+     */
+    execute(context: ProcessorContext): Promise<ProcessorResult>;
+    /**
+     * Override this method in subclasses to implement processor logic
+     * @param context Processor execution context
+     * @returns Processor data
+     */
+    protected abstract run(context: ProcessorContext): Promise<unknown>;
+    /**
+     * Safely extract file path from context
+     */
+    protected getFilePath(context: ProcessorContext): string | undefined;
+    /**
+     * Safely extract content from context
+     */
+    protected getContent(context: ProcessorContext): string | undefined;
+}
+/**
+ * Pre-processor base class
+ */
+export declare abstract class PreProcessor extends BaseProcessor {
+    readonly type: "pre";
+}
+/**
+ * Post-processor base class
+ */
+export declare abstract class PostProcessor extends BaseProcessor {
+    readonly type: "post";
+}
+/**
+ * Processor registry for managing processor instances
+ */
+export declare class ProcessorRegistry {
+    private processors;
+    /**
+     * Register a processor
+     * @param processor Processor instance
+     */
+    register(processor: IProcessor): void;
+    /**
+     * Unregister a processor
+     * @param name Processor name
+     */
+    unregister(name: string): void;
+    /**
+     * Get a processor by name
+     * @param name Processor name
+     * @returns Processor instance or undefined
+     */
+    get(name: string): IProcessor | undefined;
+    /**
+     * Get all registered processors
+     * @returns Array of processors
+     */
+    getAll(): IProcessor[];
+    /**
+     * Get processors by type
+     * @param type Processor type
+     * @returns Array of processors
+     */
+    getByType(type: "pre" | "post"): IProcessor[];
+    /**
+     * Check if processor exists
+     * @param name Processor name
+     * @returns True if processor exists
+     */
+    has(name: string): boolean;
+    /**
+     * Clear all processors
+     */
+    clear(): void;
+}
+export type { ProcessorContext, ProcessorResult } from "./processor-types.js";
+export declare const processorRegistry: ProcessorRegistry;

package/dist/processors/processor-manager.d.ts

@@ -0,0 +1,80 @@
+import { StringRayStateManager } from "../state/state-manager.js";
+import { ProcessorRegistration, ProcessorHook } from "./processor-types.js";
+import { IProcessor } from "./processor-interfaces.js";
+export interface StaggerPolicy {
+    minIntervalMs: number;
+}
+export interface ProcessorConfig {
+    name: string;
+    type: "pre" | "post";
+    priority: number;
+    enabled: boolean;
+    timeout?: number;
+    retryAttempts?: number;
+    hook?: ProcessorHook;
+    stagger?: StaggerPolicy;
+}
+export interface ProcessorResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+    duration: number;
+    processorName: string;
+}
+export interface ProcessorHealth {
+    name: string;
+    status: "healthy" | "degraded" | "failed";
+    lastExecution: number;
+    successRate: number;
+    averageDuration: number;
+    errorCount: number;
+}
+export interface ProcessorMetrics {
+    totalExecutions: number;
+    successfulExecutions: number;
+    failedExecutions: number;
+    averageDuration: number;
+    lastExecutionTime: number;
+    healthStatus: ProcessorHealth["status"];
+}
+type ProcessorFactory = {
+    execute: (context: Record<string, unknown>) => Promise<unknown>;
+    init?: () => Promise<void>;
+};
+export declare class ProcessorManager {
+    private processors;
+    private metrics;
+    private stateManager;
+    private activeProcessors;
+    private factories;
+    private lastExecutionTime;
+    constructor(stateManager: StringRayStateManager);
+    registerProcessorInstance(processor: IProcessor): boolean;
+    discoverProcessors(directory?: string): Promise<string[]>;
+    private instantiateWithDeps;
+    private registerBuiltInFactories;
+    registerFactory(name: string, factory: ProcessorFactory): void;
+    registerProcessorWithHook(registration: ProcessorRegistration): void;
+    registerProcessor(config: ProcessorConfig): void;
+    unregisterProcessor(name: string): void;
+    getProcessors(): Map<string, ProcessorConfig>;
+    initializeProcessors(): Promise<boolean>;
+    private initializeProcessor;
+    executePreProcessors(input: {
+        tool: string;
+        args?: Record<string, unknown>;
+        context?: Record<string, unknown>;
+    }): Promise<{
+        success: boolean;
+        results: ProcessorResult[];
+    }>;
+    executePostProcessors(operation: string, data: any, preResults: ProcessorResult[]): Promise<ProcessorResult[]>;
+    private executeProcessor;
+    private updateMetrics;
+    getProcessorHealth(): ProcessorHealth[];
+    private validateProcessorContext;
+    resolveProcessorConflicts(conflicts: ProcessorResult[]): ProcessorResult;
+    cleanupProcessors(): Promise<void>;
+    private cleanupProcessor;
+}
+export {};

package/dist/processors/processor-types.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Processor Types
+ *
+ * Type definitions for the processor activation system.
+ * Replaces `any` types with proper interfaces for type safety.
+ * This file is the central source of truth for shared processor types
+ * to avoid circular dependencies.
+ *
+ * @version 1.2.0
+ * @since 2026-01-07
+ */
+/**
+ * Tool argument structure passed to processors
+ */
+export interface ToolInputArgs {
+    filePath?: string;
+    content?: string;
+    operation?: string;
+    directory?: string;
+    args?: Record<string, string>;
+}
+/**
+ * Tool input containing execution details
+ */
+export interface ToolInput {
+    tool?: string;
+    args?: ToolInputArgs;
+}
+/**
+ * Processor execution context - used by processors to understand their environment
+ */
+export interface ProcessorContext {
+    /** Tool input (for pre-processors) */
+    toolInput?: ToolInput;
+    /** File path being processed */
+    filePath?: string;
+    /** Operation being performed */
+    operation?: string;
+    /** Content being processed */
+    content?: string;
+    /** Working directory */
+    directory?: string;
+    /** Tool being executed */
+    tool?: string;
+    /** Additional context - string, numeric, boolean, or object values */
+    [key: string]: ToolInput | ToolInputArgs | string | number | boolean | object | undefined;
+}
+/**
+ * Standard result returned by all processors
+ * Uses unknown for data to handle any processor-specific return type
+ */
+export interface ProcessorResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+    duration: number;
+    processorName: string;
+}
+export interface PreValidateContext {
+    operation: string;
+    data?: string;
+    syntaxCheck?: boolean;
+    codexCompliance?: boolean;
+    agentName?: string;
+    filesChanged?: string[];
+    riskLevel?: "low" | "medium" | "high" | "critical";
+    tool?: string;
+    directory?: string;
+    args?: ToolInputArgs;
+    config?: Record<string, unknown>;
+}
+export interface PostValidateContext {
+    operation: string;
+    data?: string;
+    preResults: ProcessorExecutionResult[];
+    testResults?: TestResults;
+    regressionResults?: RegressionResults;
+    stateValidation?: boolean;
+    tool?: string;
+    directory?: string;
+    args?: ToolInputArgs;
+}
+export interface ProcessorHook {
+    name: string;
+    execute: (context: PreValidateContext | PostValidateContext) => Promise<ProcessorExecutionResult>;
+    priority: number;
+    enabled: boolean;
+    before?: (context: PreValidateContext | PostValidateContext) => Promise<void>;
+    after?: (result: ProcessorExecutionResult) => Promise<void>;
+    onError?: (error: Error) => Promise<void>;
+}
+export interface ProcessorRegistration {
+    name: string;
+    type: "pre" | "post";
+    hook: ProcessorHook;
+}
+export interface ProcessorExecutionResult {
+    success: boolean;
+    result?: unknown;
+    error?: string;
+    duration: number;
+    processorName: string;
+    data?: unknown;
+}
+export interface ProcessorHealthCheck {
+    name: string;
+    status: "healthy" | "degraded" | "failed";
+    lastRun: number;
+    successRate: number;
+    averageExecutionTime: number;
+    totalRuns: number;
+    failedRuns: number;
+}
+export interface TestResults {
+    passed: number;
+    failed: number;
+    total: number;
+    duration: number;
+}
+export interface RegressionResults {
+    issues: string[];
+    passed: boolean;
+}
+export interface VersionComplianceProcessorResult {
+    success: boolean;
+    errors: string[];
+    warnings: string[];
+    checkedAt: string;
+}
+export interface CodexComplianceProcessorResult {
+    compliant: boolean;
+    violations: string[];
+    warnings: string[];
+    termsChecked: number;
+    operation: string;
+    timestamp: string;
+    error?: boolean;
+}
+export interface ErrorBoundaryResult {
+    boundaries: string;
+}
+export interface LogProtectionProcessorResult {
+    allowed: boolean;
+    reason?: string;
+}
+export interface AgentsMdValidationProcessorResult {
+    success: boolean;
+    blocked: boolean;
+    message?: string;
+    errors: string[];
+    warnings: string[];
+    checkedAt: string;
+}
+export interface TestExecutionResult {
+    testsExecuted: number;
+    passed: number;
+    failed: number;
+    exitCode?: number;
+    output?: string;
+    success: boolean;
+    error?: string;
+}
+export interface RegressionTestingResult {
+    regressions: string;
+    issues: string[];
+}
+export interface StateValidationResult {
+    stateValid: boolean;
+}
+export interface RefactoringLoggingResult {
+    logged: boolean;
+    success: boolean;
+    message: string;
+    error?: string;
+}
+export interface TestAutoCreationResult {
+    success: boolean;
+    message?: string;
+    data?: string[];
+    error?: string;
+}
+export interface CoverageAnalysisResult {
+    success: boolean;
+    message: string;
+    coverage: number;
+}
+export interface RuleViolationEntry {
+    rule: string;
+    message: string;
+}

package/dist/reporting/framework-reporting-system.d.ts

@@ -0,0 +1,19 @@
+import { type ReportConfig, type ScheduleConfig, type RealtimeStatus, type CustomReportTemplate } from "./types.js";
+export type { ReportConfig, ReportData, OrchestrationMetrics, ParsedLogEntry, RealtimeStatus, ScheduleConfig, CustomReportTemplate } from "./types.js";
+export declare class FrameworkReportingSystem {
+    private logRetentionHours;
+    private reportCache;
+    generateReport(config: ReportConfig): Promise<string>;
+    scheduleAutomatedReports(schedule: ScheduleConfig): void;
+    getRealtimeStatus(): Promise<RealtimeStatus>;
+    createCustomReport(template: CustomReportTemplate): string;
+    private generateReportId;
+    private getCachedReport;
+    private isCacheValid;
+    private cacheReport;
+    private collectReportData;
+    private saveReportToFile;
+    private cleanupOldReports;
+    private getIntervalMs;
+}
+export declare const frameworkReportingSystem: FrameworkReportingSystem;

package/dist/reporting/log-parser.d.ts

@@ -0,0 +1,10 @@
+import { type ParsedLogEntry, type ReportConfig } from "./types.js";
+export declare function levelToStatus(level: string): string;
+export declare function inferAgent(component: string): string;
+export declare function parseLogLine(line: string): ParsedLogEntry | null;
+export declare function frameworkLogToParsedEntry(entry: import("../core/framework-logger.js").FrameworkLogEntry): ParsedLogEntry;
+export declare function readCurrentLogFile(timeRange?: ReportConfig["timeRange"]): Promise<ParsedLogEntry[]>;
+export declare function parseCompressedLogFile(filePath: string, startTime: number, endTime: number): Promise<ParsedLogEntry[]>;
+export declare function readRotatedLogFiles(timeRange?: ReportConfig["timeRange"]): Promise<ParsedLogEntry[]>;
+export declare function getComprehensiveLogs(config: ReportConfig): Promise<ParsedLogEntry[]>;
+export declare function filterLogsByConfig(logs: ParsedLogEntry[], config: ReportConfig): ParsedLogEntry[];

package/dist/reporting/metrics.d.ts

@@ -0,0 +1,15 @@
+import type { ParsedLogEntry, OrchestrationMetrics, ReportConfig } from "./types.js";
+export declare function calculateTimeRange(logs: ParsedLogEntry[], timeRange?: ReportConfig["timeRange"]): {
+    start: Date;
+    end: Date;
+};
+export declare function calculateMetrics(logs: ParsedLogEntry[]): OrchestrationMetrics;
+export declare function calculatePeakActivity(logs: ParsedLogEntry[]): {
+    timestamp: Date;
+    eventsPerMinute: number;
+};
+export declare function calculateHealthScore(logs: ParsedLogEntry[]): number;
+export declare function generateInsights(logs: ParsedLogEntry[], metrics: OrchestrationMetrics): string[];
+export declare function generateRecommendations(metrics: OrchestrationMetrics): string[];
+export declare function generateAlerts(logs: ParsedLogEntry[]): string[];
+export declare function getHighFrequencyComponents(logs: ParsedLogEntry[]): string[];

package/dist/reporting/report-formatter.d.ts

@@ -0,0 +1,5 @@
+import type { ReportData } from "./types.js";
+import type { ReportConfig } from "./types.js";
+export declare function formatReport(data: ReportData, format: ReportConfig["outputFormat"]): string;
+export declare function formatAsMarkdown(data: ReportData): string;
+export declare function formatAsHtml(data: ReportData): string;

package/dist/reporting/types.d.ts

@@ -0,0 +1,102 @@
+export interface ParsedLogEntry {
+    timestamp: number;
+    component: string;
+    action: string;
+    message: string;
+    level: string;
+    status: string;
+    agent: string;
+    jobId: string | null;
+    sessionId?: string | undefined;
+    details?: Record<string, unknown> | undefined;
+}
+export interface ReportConfig {
+    type: "orchestration" | "agent-usage" | "context-awareness" | "performance" | "full-analysis";
+    sessionId?: string;
+    jobId?: string;
+    timeRange?: {
+        start?: Date;
+        end?: Date;
+        lastHours?: number;
+    };
+    outputFormat: "markdown" | "json" | "html";
+    outputPath?: string;
+    includeCharts?: boolean;
+    detailedMetrics?: boolean;
+}
+export interface OrchestrationMetrics {
+    totalDelegations: number;
+    agentUsage: Map<string, number>;
+    complexityDistribution: Map<string, number>;
+    successRate: number;
+    averageResponseTime: number;
+    contextOperations: number;
+    enhancementSuccessRate: number;
+    commandUsage: Map<string, number>;
+    toolExecutionStats: {
+        totalCommands: number;
+        uniqueTools: number;
+        mostUsedTool: string;
+        toolSuccessRate: Map<string, {
+            success: number;
+            total: number;
+            rate: number;
+        }>;
+    };
+    systemOperationDetails: {
+        fileOperations: number;
+        searchOperations: number;
+        terminalOperations: number;
+        analysisOperations: number;
+        orchestrationOperations: number;
+    };
+}
+export interface ReportData {
+    generatedAt: Date;
+    timeRange: {
+        start: Date;
+        end: Date;
+    };
+    metrics: OrchestrationMetrics;
+    chronologicalEvents: ParsedLogEntry[];
+    insights: string[];
+    recommendations: string[];
+    summary: {
+        totalEvents: number;
+        activeComponents: string[];
+        peakActivity: {
+            timestamp: Date;
+            eventsPerMinute: number;
+        };
+        healthScore: number;
+    };
+}
+export interface RealtimeStatus {
+    activeComponents: string[];
+    recentActivity: ParsedLogEntry[];
+    healthScore: number;
+    alerts: string[];
+}
+export interface ScheduleConfig {
+    frequency: "hourly" | "daily" | "weekly";
+    types: ReportConfig["type"][];
+    outputDir: string;
+    retentionDays: number;
+}
+export interface CustomReportTemplate {
+    name: string;
+    filters: {
+        components?: string[];
+        actions?: string[];
+        status?: string[];
+        timeRange?: {
+            start: Date;
+            end: Date;
+        };
+    };
+    aggregations: {
+        groupBy: "component" | "action" | "status" | "hour";
+        metrics: ("count" | "avgResponseTime" | "successRate")[];
+    };
+    visualizations: ("timeline" | "pie-chart" | "bar-chart")[];
+}

package/dist/scripts/activate-kernel-pipeline.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Kernel Pipeline Activation Script
+ *
+ * Triggers real delegations that should activate kernel patterns.
+ * Observes the full pipeline in action.
+ */
+export {};