0xray 3.4.2 → 3.4.4

package/dist/architect/architect-tools.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Architect Tools - Integration layer between architect agent and contextual analysis system
+ * Provides tools for codebase intelligence, architectural assessment, and design planning
+ */
+import { CodebaseStructure } from "../delegation/codebase-context-analyzer.js";
+import { DependencyNode } from "../delegation/dependency-graph-builder.js";
+export interface CodebaseComplexityInfo {
+    averageComplexity: number;
+    highComplexityFiles: string[];
+    complexityDistribution: "low" | "medium" | "high" | "critical";
+    recommendations: string[];
+}
+export interface ContextAnalysisResult {
+    codebaseStructure: CodebaseStructure;
+    architecturalPatterns: string[];
+    dependencyIssues: string[];
+    scalabilityAssessment: {
+        score: number;
+        recommendations: string[];
+    };
+    maintainabilityIndex: number;
+    complexityAnalysis: CodebaseComplexityInfo;
+}
+export interface ArchitectureAssessment {
+    overallHealth: "excellent" | "good" | "fair" | "poor" | "critical";
+    scores: {
+        modularity: number;
+        coupling: number;
+        cohesion: number;
+        testability: number;
+        scalability: number;
+    };
+    issues: Array<{
+        type: "critical" | "major" | "minor";
+        description: string;
+        impact: string;
+        recommendation: string;
+    }>;
+    recommendations: string[];
+}
+export interface DependencyAnalysis {
+    graph: Map<string, DependencyNode>;
+    circularDependencies: string[];
+    tightlyCoupledModules: string[];
+    orphanModules: string[];
+    healthScore: number;
+    recommendations: string[];
+}
+/**
+ * Context Analysis Tool - Comprehensive codebase intelligence gathering
+ */
+export declare function contextAnalysis(projectRoot: string, files?: string[], depth?: "overview" | "detailed" | "comprehensive"): Promise<ContextAnalysisResult>;
+/**
+ * Codebase Structure Tool - File organization and module analysis
+ */
+export declare function codebaseStructure(projectRoot: string, includeMetrics?: boolean): Promise<any>;
+/**
+ * Dependency Analysis Tool - Component relationship and coupling analysis
+ */
+export declare function dependencyAnalysis(projectRoot: string, focusAreas?: string[]): Promise<DependencyAnalysis>;
+/**
+ * Architecture Assessment Tool - Overall architectural health evaluation
+ */
+export declare function architectureAssessment(projectRoot: string, assessmentType?: "quick" | "comprehensive"): Promise<ArchitectureAssessment>;
+export declare const architectTools: {
+    contextAnalysis: typeof contextAnalysis;
+    codebaseStructure: typeof codebaseStructure;
+    dependencyAnalysis: typeof dependencyAnalysis;
+    architectureAssessment: typeof architectureAssessment;
+};

package/dist/architect/architectural-integrity.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ARCHITECTURAL INTEGRITY ENFORCEMENT
+ *
+ * This module ensures that critical framework components are always active
+ * and integrated, preventing the staged initialization issues that broke
+ * the post-processor and rules engine enforcement.
+ */
+/**
+ * Verify all critical components are active and integrated
+ */
+export declare function verifyArchitecturalIntegrity(): Promise<{
+    allActive: boolean;
+    issues: string[];
+    recommendations: string[];
+}>;
+/**
+ * Force activation of critical components if missing
+ * This prevents staged initialization from breaking the framework
+ */
+export declare function ensureCriticalComponents(): Promise<void>;

package/dist/benchmark/performance-benchmark.d.ts

@@ -0,0 +1,103 @@
+export interface BenchmarkResult {
+    operation: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    success: boolean;
+    metadata: Record<string, any>;
+    error?: string | undefined;
+}
+export interface PerformanceMetrics {
+    totalOperations: number;
+    successfulOperations: number;
+    failedOperations: number;
+    averageDuration: number;
+    medianDuration: number;
+    p95Duration: number;
+    p99Duration: number;
+    minDuration: number;
+    maxDuration: number;
+    throughput: number;
+}
+export interface BootBenchmarkResult {
+    totalBootTime: number;
+    phaseTimings: Record<string, number>;
+    componentLoadTimes: Record<string, number>;
+    memoryUsage: {
+        beforeBoot: number;
+        afterBoot: number;
+        peakDuringBoot: number;
+    };
+    success: boolean;
+    errors: string[];
+    orchestratorLoadTime?: number;
+    delegationInitTime?: number;
+    sessionManagementInitTime?: number;
+    processorActivationTime?: number;
+    agentLoadingTime?: number;
+    enforcementActivationTime?: number;
+    codexComplianceActivationTime?: number;
+}
+export interface OrchestratorBenchmarkResult {
+    taskExecutionTimes: number[];
+    delegationLatencies: number[];
+    conflictResolutionTimes: number[];
+    concurrentTaskThroughput: number;
+    dependencyResolutionTime: number;
+    overallSuccess: boolean;
+}
+export interface SessionBenchmarkResult {
+    stateShareLatencies: number[];
+    dependencyUpdateTimes: number[];
+    groupOperationTimes: number[];
+    migrationTimes: number[];
+    failoverTimes: number[];
+    concurrentSessionOperations: number;
+}
+export declare class XrayPerformanceBenchmark {
+    private results;
+    private activeBenchmarks;
+    /**
+     * Start a benchmark measurement
+     */
+    startBenchmark(operation: string, metadata?: Record<string, any>): string;
+    /**
+     * End a benchmark measurement
+     */
+    endBenchmark(benchmarkId: string, success?: boolean, error?: string): BenchmarkResult | null;
+    /**
+     * Benchmark boot sequence performance
+     */
+    benchmarkBootSequence(_bootOrchestrator: unknown): Promise<BootBenchmarkResult>;
+    /**
+     * Benchmark orchestrator task execution
+     */
+    benchmarkOrchestratorTasks(_orchestrator: unknown, taskCount?: number, concurrentTasks?: number): Promise<OrchestratorBenchmarkResult>;
+    /**
+     * Benchmark session management operations
+     */
+    benchmarkSessionOperations(_sessionStateManager: unknown, operationCount?: number): Promise<SessionBenchmarkResult>;
+    /**
+     * Calculate performance metrics from benchmark results
+     */
+    calculateMetrics(operationFilter?: string): PerformanceMetrics;
+    /**
+     * Generate comprehensive benchmark report
+     */
+    generateReport(): {
+        summary: PerformanceMetrics;
+        bootBenchmark?: BootBenchmarkResult;
+        orchestratorBenchmark?: OrchestratorBenchmarkResult;
+        sessionBenchmark?: SessionBenchmarkResult;
+        recommendations: string[];
+    };
+    /**
+     * Clear all benchmark results
+     */
+    clearResults(): void;
+    /**
+     * Export results for external analysis
+     */
+    exportResults(): BenchmarkResult[];
+}
+export declare const performanceBenchmark: XrayPerformanceBenchmark;

package/dist/cli/commands/analytics-disable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Analytics Disable CLI Command
+ *
+ * Disables 0xRay Central Analytics with immediate opt-out
+ *
+ * Usage: npx 0xray analytics disable
+ */
+export declare const analyticsDisableCommand: import("commander").Command;
+export default analyticsDisableCommand;

package/dist/cli/commands/analytics-enable-action.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Analytics Enable Action
+ *
+ * Enables 0xRay Central Analytics with opt-in consent
+ *
+ * Usage: npx 0xray analytics enable [--categories reflections,logs,metrics,patterns]
+ */
+export declare function analyticsEnableAction(options: any): Promise<void>;

package/dist/cli/commands/analytics-preview.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Analytics Preview CLI Command
+ *
+ * Shows what data would be submitted without actually submitting it
+ *
+ * Usage: npx 0xray analytics preview [--type reflections|logs|metrics|patterns] [--all]
+ */
+export declare const analyticsPreviewCommand: import("commander").Command;
+export default analyticsPreviewCommand;

package/dist/cli/commands/analytics-status.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Analytics Status CLI Command
+ *
+ * Shows current consent and analytics status
+ *
+ * Usage: npx 0xray analytics status
+ */
+export declare const analyticsStatusCommand: import("commander").Command;
+export default analyticsStatusCommand;

package/dist/cli/commands/antigravity-status.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Antigravity Status CLI Command
+ *
+ * Shows status of all installed skills.
+ *
+ * Usage: npx 0xray antigravity status
+ */
+export declare function antigravityStatusCommand(): Promise<void>;
+export default antigravityStatusCommand;

package/dist/cli/commands/archive-logs.d.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * Standalone Log Archive CLI
+ *
+ * Archives log files without requiring framework boot.
+ * Used by git hooks to prevent log truncation.
+ *
+ */
+interface ArchiveResult {
+    archived: number;
+    errors: string[];
+}
+interface LogArchiveConfig {
+    maxFileSizeMB: number;
+    rotationIntervalHours: number;
+    compressionEnabled: boolean;
+    maxArchives: number;
+}
+/**
+ * Archive log files without framework dependencies
+ */
+export declare function archiveLogFiles(config?: LogArchiveConfig, jobId?: string): Promise<ArchiveResult>;
+export {};

package/dist/cli/commands/credible-init.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Credible Init CLI Command
+ *
+ * Initializes a Credible Pod - a self-contained agent environment.
+ *
+ * Usage: npx 0xray credible init [options]
+ *
+ * Status: PLANNED - Not yet implemented
+ */
+export declare function credibleInitCommand(): Promise<void>;
+export default credibleInitCommand;

package/dist/cli/commands/enforce.d.ts

@@ -0,0 +1,12 @@
+interface EnforceOptions {
+    phase: string;
+    tool?: string;
+    args?: string;
+    result?: string;
+    error?: string;
+    files?: string;
+    code?: string;
+    focusAreas?: string;
+}
+export declare function enforceCommand(options: EnforceOptions): Promise<void>;
+export {};

package/dist/cli/commands/govern.d.ts

@@ -0,0 +1,29 @@
+/**
+ * xray govern — the primary CLI command for the v3 nucleus
+ *
+ * Usage:
+ *   xray govern [options]
+ *
+ * All existing direct commands still work (backward compat with deprecation notice).
+ */
+interface GovernOptions {
+    status?: boolean;
+    audit?: boolean;
+    mcp?: string;
+    pluginInstall?: string;
+    proposals?: string;
+    skillInstall?: string;
+    skillRegistry?: string;
+    storyteller?: string;
+    mcpList?: boolean;
+    mcpStatus?: boolean;
+    mcpInstall?: string;
+    mcpRemove?: string;
+    publishAgent?: boolean;
+    archiveLogs?: boolean;
+    credibleInit?: string;
+    antigravityStatus?: boolean;
+    [key: string]: unknown;
+}
+export declare function governCommand(options: GovernOptions): Promise<void>;
+export {};

package/dist/cli/commands/grok-install.d.ts

@@ -0,0 +1,7 @@
+/**
+ * CLI command: 0xray grok install
+ *
+ * Helps users register 0xRay MCP servers with the Grok CLI.
+ */
+import { Command } from 'commander';
+export declare function registerGrokCommands(grokCmd: Command): void;

package/dist/cli/commands/hermes-install.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerHermesCommands(hermesCmd: Command): void;

package/dist/cli/commands/mcp-install.d.ts

@@ -0,0 +1,4 @@
+export declare function listMCPsCommand(): void;
+export declare function showMCPStatusCommand(): void;
+export declare function installMCPCommand(name: string): Promise<void>;
+export declare function removeMCPCommand(name: string): void;

package/dist/cli/commands/openclaw-install.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerOpenClawCommands(openclawCmd: Command): void;

package/dist/cli/commands/opencode-install.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerOpencodeCommands(opencodeCmd: Command): void;

package/dist/cli/commands/plugin-commands.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Plugin CLI Commands
+ *
+ * CLI commands for plugin management:
+ * - plugin list
+ * - plugin install (from npm or local)
+ * - plugin enable
+ * - plugin disable
+ * - plugin status
+ * - plugin uninstall
+ *
+ */
+export declare function pluginListCommand(): Promise<void>;
+export declare function pluginInstallCommand(pluginName: string): Promise<void>;
+export declare function pluginEnableCommand(pluginName: string): Promise<void>;
+export declare function pluginDisableCommand(pluginName: string): Promise<void>;
+export declare function pluginStatusCommand(pluginName: string): Promise<void>;
+export declare function pluginUninstallCommand(pluginName: string): Promise<void>;

package/dist/cli/commands/publish-agent.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Publish Agent CLI Command
+ *
+ * Packages and publishes agents to AgentStore for sharing.
+ *
+ * Usage: npx 0xray publish-agent [options]
+ * Options:
+ *   --agent <name>    Agent name to publish (required)
+ *   --version <ver>   Version (optional, auto-detected)
+ *   --dry-run         Preview package without publishing
+ *
+ * Example: npx 0xray publish-agent --agent orchestrator --dry-run
+ */
+export declare function publishAgentCommand(): Promise<void>;
+export default publishAgentCommand;

package/dist/cli/commands/security-audit.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Security Audit CLI Command
+ *
+ * Comprehensive security audit with vulnerability scanning,
+ * compliance checking, and weighted voting for architectural decisions.
+ *
+ * Usage:
+ *   npx 0xray security-audit           # Quick audit
+ *   npx 0xray security-audit --deep    # Deep audit with all standards
+ *   npx 0xray security-audit --output ./reports/security.md
+ *   npx 0xray security-audit --no-remediation
+ *   npx 0xray security-audit --no-voting
+ *
+ * Options:
+ *   --deep           Deep scan with all compliance standards (OWASP, CWE, NIST, ISO, PCI)
+ *   --output <path>  Output report to file (JSON or Markdown)
+ *   --format <fmt>   Output format: json, markdown (default: markdown)
+ *   --no-remediation Skip automated remediation analysis
+ *   --no-voting      Disable weighted voting for architectural decisions
+ *   --project <path> Project path to audit (default: current directory)
+ */
+export declare function securityAuditCommand(args?: string[]): Promise<void>;
+export default securityAuditCommand;

package/dist/cli/commands/skill-install.d.ts

@@ -0,0 +1,6 @@
+export declare function skillInstallCommand(sourceArg?: string, options?: {
+    force?: boolean;
+    path?: string;
+}): Promise<void>;
+export declare function skillRegistryCommand(action?: string, args?: Record<string, string>): Promise<void>;
+export declare function syncBuiltinSkills(targetSkillsDir: string, packageRoot?: string): number;

package/dist/cli/commands/status.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Status CLI Command
+ *
+ * Shows comprehensive framework status including:
+ * - OpenCode installation status
+ * - Installed skills
+ * - Configured agents
+ * - Health metrics
+ * - Inference engine status
+ *
+ * Usage: npx 0xray status
+ */
+interface StatusReport {
+    opencode: {
+        installed: boolean;
+        configFound: boolean;
+    };
+    skills: {
+        count: number;
+        names: string[];
+    };
+    agents: {
+        count: number;
+        names: string[];
+    };
+    health: {
+        logPath: string;
+        logExists: boolean;
+        recentEntries: number;
+    };
+    inference: {
+        active: boolean;
+        lastTuning: string | null;
+        outcomesCount: number;
+        patternsCount: number;
+    };
+}
+export declare function getStatusReport(cwd?: string): StatusReport;
+export declare function printStatus(report: StatusReport): void;
+export declare function statusCommand(): Promise<void>;
+export default statusCommand;

package/dist/cli/commands/storyteller.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Storyteller CLI Command
+ *
+ * Invokes the storyteller skill to write reflections, sagas, journeys, or narratives.
+ * Automatically determines story type based on context if not specified.
+ *
+ * Usage:
+ *   npx 0xray storyteller reflection
+ *   npx 0xray storyteller saga "v1.18.0 Release Journey"
+ *   npx 0xray storyteller journey --title "API Migration"
+ *   npx 0xray storyteller narrative --framework hero_journey
+ */
+export declare function storytellerCommand(storyType?: string, options?: {
+    title?: string;
+    framework?: string;
+    output?: string;
+    dryRun?: boolean;
+}): Promise<void>;
+export default storytellerCommand;

package/dist/cli/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * xray CLI - Command Line Interface
+ *
+ * Provides commands for installing and managing xray framework
+ */
+export {};

package/dist/cli/server.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/config/default-agents.d.ts

@@ -0,0 +1,12 @@
+export interface DefaultAgentConfig {
+    name: string;
+    capabilities: string[];
+    status: "active" | "inactive";
+    expertise: string;
+    capacity: number;
+    performance: number;
+    specialties: string[];
+}
+export declare const DEFAULT_AGENTS: DefaultAgentConfig[];
+export declare function getDefaultAgents(): DefaultAgentConfig[];
+export declare function getDefaultAgentByName(name: string): DefaultAgentConfig | undefined;

package/dist/config/routing-mappings.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Routing Mappings — Shared keyword→agent+skill lookup table.
+ *
+ * Extracted from enforcer-tools.ts to be queryable at runtime
+ * by the main AI delegation decision tools.
+ */
+export interface RoutingMappingEntry {
+    keywords: string[];
+    skill: string;
+    agent: string;
+    confidence: number;
+}
+export declare const ROUTING_MAPPINGS: RoutingMappingEntry[];
+export interface RoutingMatch {
+    agent: string;
+    skill: string;
+    confidence: number;
+    matchedKeywords: string[];
+}
+export declare function queryRoutingMappings(keywords: string[]): RoutingMatch[];
+export declare function getAllRoutingMappings(): RoutingMappingEntry[];
+/**
+ * Validate that all agent names in routing mappings exist in the SSOT.
+ * Call at boot to detect drift.
+ */
+export declare function validateRoutingMappings(validAgents: string[]): string[];

package/dist/core/activity-logger.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Activity Logger
+ *
+ * Comprehensive logging for all 0xRay activities including:
+ * - Framework operations
+ * - Development sessions
+ * - Script executions
+ * - File operations
+ * - Test results
+ *
+ * Enable/Disable via:
+ *   XRAY_ACTIVITY_LOGGING=true  (enable)
+ *   XRAY_ACTIVITY_LOGGING=false (disable, default)
+ *
+ * @module core/activity-logger
+ */
+export type ActivityCategory = "framework" | "development" | "script" | "file" | "test" | "commit" | "session" | "agent" | "processor" | "config";
+export type ActivityLevel = "debug" | "info" | "warn" | "error" | "success";
+export interface ActivityRecord {
+    timestamp: string;
+    id: string;
+    category: ActivityCategory;
+    level: ActivityLevel;
+    action: string;
+    message: string;
+    details?: Record<string, unknown>;
+    sessionId?: string;
+    jobId?: string;
+}
+/**
+ * Initialize activity logger with config from features.json
+ * Called by boot-orchestrator during initialization
+ */
+export declare function initializeActivityLogger(config?: {
+    enabled?: boolean;
+    log_path?: string;
+}): void;
+/**
+ * Check if activity logging is enabled
+ */
+export declare function isActivityLoggingEnabled(): boolean;
+/**
+ * Enable or disable activity logging
+ */
+export declare function setActivityLoggingEnabled(enabled: boolean): void;
+/**
+ * Get current session ID
+ */
+export declare function getSessionId(): string;
+/**
+ * Log an activity
+ */
+export declare function logActivity(category: ActivityCategory, level: ActivityLevel, action: string, message: string, details?: Record<string, unknown>, options?: {
+    sessionId?: string;
+    jobId?: string;
+}): void;
+export declare const activity: {
+    framework: (action: string, message: string, details?: Record<string, unknown>) => void;
+    development: (action: string, message: string, details?: Record<string, unknown>) => void;
+    script: (action: string, message: string, details?: Record<string, unknown>) => void;
+    file: (action: string, message: string, details?: Record<string, unknown>) => void;
+    test: (action: string, message: string, details?: Record<string, unknown>) => void;
+    commit: (action: string, message: string, details?: Record<string, unknown>) => void;
+    session: (action: string, message: string, details?: Record<string, unknown>) => void;
+    agent: (action: string, message: string, details?: Record<string, unknown>) => void;
+    processor: (action: string, message: string, details?: Record<string, unknown>) => void;
+    config: (action: string, message: string, details?: Record<string, unknown>) => void;
+    success: (category: ActivityCategory, action: string, message: string, details?: Record<string, unknown>) => void;
+    error: (category: ActivityCategory, action: string, message: string, details?: Record<string, unknown>) => void;
+    warn: (category: ActivityCategory, action: string, message: string, details?: Record<string, unknown>) => void;
+};