0xray 2.0.0 → 2.0.1

package/dist/core/codex-injector.d.ts

@@ -0,0 +1,74 @@
+/**
+ * 0xRay Codex Context Injector Hook
+ *
+ * Injects Universal Development Codex v1.2.0 context into agent operations.
+ * Follows production-tested pattern from rules-injector.
+ *
+ * @version 1.0.0
+ * @since 2026-01-06
+ */
+/**
+ * Create strray-codex-injector hook
+ *
+ * This hook injects codex context into tool outputs and displays
+ * a welcome message on agent startup, following the production-tested
+ * pattern from OpenCode's rules-injector.
+ */
+export declare function createStringRayCodexInjectorHook(): {
+    name: "strray-codex-injector";
+    hooks: {
+        "agent.start": (sessionId: string) => Promise<void>;
+        "tool.execute.before": (input: {
+            tool: string;
+            args?: Record<string, unknown>;
+        }, sessionId: string) => Promise<void>;
+        "tool.execute.after": (input: {
+            tool: string;
+            args?: Record<string, unknown>;
+        }, output: {
+            output?: string;
+            [key: string]: unknown;
+        }, sessionId: string) => Promise<{
+            [key: string]: unknown;
+            output?: string;
+        } | {
+            output: string;
+        }>;
+    };
+};
+/**
+ * Get codex statistics for debugging
+ */
+export declare function getCodexStats(sessionId: string): {
+    loaded: boolean;
+    fileCount: number;
+    totalTerms: number;
+    version: string;
+};
+/**
+ * Clear codex cache (useful for testing or forced reload)
+ */
+export declare function clearCodexCache(sessionId?: string): void;
+/**
+ * CodexInjector class for plugin compatibility
+ */
+export declare class CodexInjector {
+    injectCodexRules(context: Record<string, unknown>, options: {
+        priority?: string;
+        mergeStrategy?: string;
+    }): Record<string, unknown>;
+    getCodexStats(): {
+        loaded: boolean;
+        fileCount: number;
+        totalTerms: number;
+        version: string;
+    };
+    /**
+     * Permissive comment validation - recognizes that comments are beneficial
+     * Only flags truly problematic patterns, provides guidance not requirements
+     */
+    validateCommentsPermissively(content: string): {
+        guidance: string[];
+        concerns: string[];
+    };
+}

package/dist/core/config-loader.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Configuration Loader
+ *
+ * Loads and validates 0xRay-specific configuration from opencode.json
+ *
+ * @version 1.0.0
+ * @since 2026-01-09
+ */
+export interface MultiAgentOrchestrationConfig {
+    enabled: boolean;
+    coordination_model: "async-multi-agent" | "sync-multi-agent";
+    max_concurrent_agents: number;
+    task_distribution_strategy: "capability-based" | "load-balanced" | "round-robin";
+    conflict_resolution: "expert-priority" | "majority-vote" | "consensus";
+    progress_tracking: boolean;
+    session_persistence: boolean;
+}
+export interface AutonomousReportingConfig {
+    enabled: boolean;
+    interval_minutes: number;
+    auto_schedule: boolean;
+    include_health_assessment: boolean;
+    include_agent_activities: boolean;
+    include_pipeline_operations: boolean;
+    include_critical_issues: boolean;
+    include_recommendations: boolean;
+    report_retention_days: number;
+    notification_channels: string[];
+}
+export interface StringRayConfig {
+    multi_agent_orchestration: MultiAgentOrchestrationConfig;
+    autonomous_reporting: AutonomousReportingConfig;
+    disabled_agents: string[];
+}
+export declare class StringRayConfigLoader {
+    private configPath;
+    private cachedConfig;
+    private cacheExpiry;
+    private lastLoadTime;
+    constructor(configPath?: string);
+    /**
+     * Load 0xRay configuration from the resolved config directory
+     */
+    loadConfig(): StringRayConfig;
+    /**
+     * Parse configuration data with validation
+     */
+    private parseConfig;
+    /**
+     * Parse multi-agent orchestration configuration
+     */
+    private parseMultiAgentConfig;
+    /**
+     * Parse autonomous reporting configuration
+     */
+    private parseAutonomousReportingConfig;
+    /**
+     * Get default configuration
+     */
+    private getDefaultConfig;
+    /**
+     * Validate enum values
+     */
+    private validateEnum;
+    /**
+     * Clear configuration cache
+     */
+    clearCache(): void;
+}
+export declare const strRayConfigLoader: StringRayConfigLoader;

package/dist/core/config-paths.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Config Path Resolver
+ *
+ * Centralizes all 0xRay config file path resolution.
+ * Supports STRRAY_CONFIG_DIR env var for custom config roots,
+ * making .opencode/ completely optional for environments like Hermes Agent.
+ *
+ * Resolution order (per file type):
+ *   1. STRRAY_CONFIG_DIR/<relative_path>     (if env var set)
+ *   2. .strray/<relative_path>                (preferred lightweight root)
+ *   3. .opencode/strray/<relative_path>       (legacy OpenCode root)
+ *   4. null                                   (callers fall back to built-in defaults)
+ *
+ * For state/data directories, uses:
+ *   1. STRRAY_CONFIG_DIR/state                 (if env var set)
+ *   2. .strray/state
+ *   3. .opencode/state                         (legacy)
+ *   4. .strray/state                           (default — always writable)
+ */
+/** Environment variable name for custom config root */
+export declare const STRRAY_CONFIG_DIR_ENV = "STRRAY_CONFIG_DIR";
+/**
+ * Detect the best available config directory.
+ * Scans in priority order and caches the first one that exists (or the first default).
+ */
+export declare function getConfigDir(projectRoot?: string): string;
+/**
+ * Resolve a specific config file path using the standard priority chain.
+ * Returns null if no suitable path is found (caller should use defaults).
+ *
+ * @param relativePath - Path relative to config dir (e.g., "features.json")
+ * @param projectRoot  - Optional project root override
+ */
+export declare function resolveConfigPath(relativePath: string, projectRoot?: string): string | null;
+/**
+ * Get the state persistence directory (the parent directory for state.json).
+ * Similar logic to resolveConfigPath but for the state/ subdirectory.
+ */
+export declare function resolveStateDir(projectRoot?: string): string;
+/**
+ * Get the state persistence FILE path (e.g. .opencode/state/state.json).
+ * Prefer this over resolveStateDir when you need a file path for fs.writeFileSync.
+ */
+export declare function resolveStateFilePath(projectRoot?: string): string;
+/**
+ * Get the profiles storage directory.
+ */
+export declare function resolveProfilesDir(projectRoot?: string): string;
+/**
+ * Resolve codex.json path.
+ * Has additional fallback locations beyond the standard config dir.
+ */
+export declare function resolveCodexPath(projectRoot?: string): string[];
+/**
+ * Get the logs directory for framework logging.
+ */
+export declare function resolveLogDir(projectRoot?: string): string;
+/**
+ * Reset the cached config dir (useful for testing).
+ */
+export declare function resetConfigDirCache(): void;

package/dist/core/context-loader.d.ts

@@ -0,0 +1,121 @@
+/**
+ * 0xRay Context Loader
+ *
+ * Loads Universal Development Codex v1.2.0 context for agent initialization.
+ * Provides structured access to 30+ codex terms, interweaves, lenses, and anti-patterns.
+ *
+ * @version 1.0.0
+ * @since 2026-01-06
+ */
+/**
+ * Codex term structure
+ */
+export interface CodexTerm {
+    number: number;
+    description: string;
+    category: "core" | "extended" | "architecture" | "advanced";
+    zeroTolerance?: boolean;
+    enforcementLevel?: "low" | "medium" | "high" | "blocking";
+}
+/**
+ * Parsed codex context
+ */
+export interface CodexContext {
+    version: string;
+    lastUpdated: string;
+    terms: Map<number, CodexTerm>;
+    interweaves: string[];
+    lenses: string[];
+    principles: string[];
+    antiPatterns: string[];
+    validationCriteria: Record<string, boolean>;
+    frameworkAlignment: Record<string, string>;
+    errorPreventionTarget: number;
+}
+/**
+ * Context loading result
+ */
+export interface ContextLoadResult {
+    success: boolean;
+    context?: CodexContext;
+    error?: string;
+    warnings: string[];
+}
+/**
+ * 0xRay Context Loader
+ *
+ * Loads and parses the Universal Development Codex v1.2.0 from codex.json
+ */
+export declare class StringRayContextLoader {
+    private static instance;
+    private cachedContext;
+    private codexFilePaths;
+    private constructor();
+    /**
+     * Get singleton instance
+     */
+    static getInstance(): StringRayContextLoader;
+    /**
+     * Load codex context
+     *
+     * Attempts to load the Universal Development Codex from multiple possible locations.
+     * Returns cached context if available and not expired.
+     */
+    loadCodexContext(projectRoot: string): Promise<ContextLoadResult>;
+    /**
+     * Parse codex content from JSON or Markdown
+     *
+     * Extracts all 30+ codex terms, interweaves, lenses, and principles from content.
+     * Supports both JSON and Markdown formats with explicit format detection.
+     */
+    private parseCodexContent;
+    private inferTermCategory;
+    /**
+     * Get specific codex term by number
+     */
+    getTerm(context: CodexContext, termNumber: number): CodexTerm | undefined;
+    /**
+     * Get all core terms (1-10)
+     */
+    getCoreTerms(context: CodexContext): CodexTerm[];
+    /**
+     * Get zero-tolerance terms that require immediate blocking
+     */
+    getZeroToleranceTerms(context: CodexContext): CodexTerm[];
+    /**
+     * Validate action against codex
+     *
+     * Checks if an action complies with relevant codex terms.
+     * Returns validation result with violations and recommendations.
+     */
+    validateAgainstCodex(context: CodexContext, action: string, actionDetails: Record<string, unknown>): {
+        compliant: boolean;
+        violations: Array<{
+            term: CodexTerm;
+            reason: string;
+            severity: "low" | "medium" | "high" | "blocking";
+        }>;
+        recommendations: string[];
+    };
+    /**
+     * Clear cached context (useful for testing or forced reload)
+     */
+    clearCache(): void;
+    /**
+     * Check if context is loaded and valid
+     */
+    isContextLoaded(): boolean;
+    /**
+     * Get context statistics
+     */
+    getContextStats(): {
+        loaded: boolean;
+        termCount: number;
+        categoryBreakdown: Record<string, number>;
+        zeroToleranceCount: number;
+    };
+}
+/**
+ * Export singleton instance
+ */
+export declare const strRayContextLoader: StringRayContextLoader;

package/dist/core/context-validator.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 0xRay Context Size Validator
+ *
+ * Prevents system prompt bloat by validating and rejecting context-injection attempts
+ * that would exceed token budgets.
+ *
+ * @version 1.0.0
+ * @since 2026-03-03
+ */
+/**
+ * Context size configuration
+ */
+export interface ContextSizeConfig {
+    maxSystemPromptLength: number;
+    maxCodexContextLength: number;
+    maxTotalPromptLength: number;
+    enableCompression: boolean;
+    preventDuplicateContent: boolean;
+}
+/**
+ * Context validation result
+ */
+export interface ValidationResult {
+    isValid: boolean;
+    sizeInTokens: number;
+    exceedsBudget: boolean;
+    warnings: string[];
+    compressionApplied: boolean;
+    optimizedContent?: string;
+}
+/**
+ * Validate context size and detect bloat
+ */
+export declare function validateContext(context: string, config?: Partial<ContextSizeConfig>): ValidationResult;
+/**
+ * Validate context collection (multiple contexts combined)
+ */
+export declare function validateContextCollection(contexts: string[], config?: Partial<ContextSizeConfig>): ValidationResult;
+/**
+ * Prevent system prompt bloat middleware
+ */
+export declare function preventSystemPromptBloat(context: string, onWarning?: (warning: string) => void): string;
+/**
+ * Utility function to check if a prompt is likely to cause overflow
+ */
+export declare function isPromptLikelyToOverflow(prompt: string): boolean;
+/**
+ * Generate a safe system prompt template
+ */
+export declare function generateSafeSystemPrompt(baseTemplate: string, additionalContext: string, maxTokens?: number): {
+    prompt: string;
+    safe: boolean;
+};