0xray 2.0.0

package/dist/benchmark/performance-benchmark.js

@@ -0,0 +1,372 @@
+// Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .strray fallbacks)
+import { frameworkLogger } from "../core/framework-logger.js";
+import crypto from "crypto";
+export class StringRayPerformanceBenchmark {
+    results = [];
+    activeBenchmarks = new Map();
+    /**
+     * Start a benchmark measurement
+     */
+    startBenchmark(operation, metadata = {}) {
+        const benchmarkId = `${operation}_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`;
+        this.activeBenchmarks.set(benchmarkId, {
+            startTime: performance.now(),
+            metadata,
+        });
+        return benchmarkId;
+    }
+    /**
+     * End a benchmark measurement
+     */
+    endBenchmark(benchmarkId, success = true, error) {
+        const activeBenchmark = this.activeBenchmarks.get(benchmarkId);
+        if (!activeBenchmark) {
+            frameworkLogger.log("performance-benchmark", "benchmark-not-found", "warning", { benchmarkId });
+            return null;
+        }
+        const endTime = performance.now();
+        const duration = endTime - activeBenchmark.startTime;
+        const result = {
+            operation: benchmarkId.split("_")[0] || "unknown",
+            startTime: activeBenchmark.startTime,
+            endTime,
+            duration,
+            success,
+            metadata: activeBenchmark.metadata,
+            error,
+        };
+        this.results.push(result);
+        this.activeBenchmarks.delete(benchmarkId);
+        return result;
+    }
+    /**
+     * Benchmark boot sequence performance
+     */
+    async benchmarkBootSequence(_bootOrchestrator) {
+        const result = {
+            totalBootTime: 0,
+            phaseTimings: {},
+            componentLoadTimes: {},
+            memoryUsage: {
+                beforeBoot: 0,
+                afterBoot: 0,
+                peakDuringBoot: 0,
+            },
+            success: false,
+            errors: [],
+        };
+        const bootStartTime = performance.now();
+        const peakMemory = 0;
+        try {
+            // Measure initial memory
+            result.memoryUsage.beforeBoot = process.memoryUsage().heapUsed;
+            // Phase 1: Orchestrator loading
+            const orchestratorStart = performance.now();
+            const benchmarkId = this.startBenchmark("orchestrator_load");
+            // Boot sequence will be executed by the caller
+            const orchestratorResult = this.endBenchmark(benchmarkId, true);
+            if (orchestratorResult) {
+                result.phaseTimings.orchestrator_load = orchestratorResult.duration;
+                result.componentLoadTimes.orchestrator = orchestratorResult.duration;
+            }
+            // Phase 2: Delegation system initialization
+            const delegationStart = performance.now();
+            const delegationBenchmarkId = this.startBenchmark("delegation_init");
+            // This will be measured during actual boot
+            const delegationResult = this.endBenchmark(delegationBenchmarkId, true);
+            if (delegationResult) {
+                result.phaseTimings.delegation_init = delegationResult.duration;
+                result.componentLoadTimes.delegation_system = delegationResult.duration;
+            }
+            // Phase 3: Session management initialization
+            const sessionStart = performance.now();
+            const sessionBenchmarkId = this.startBenchmark("session_management_init");
+            const sessionResult = this.endBenchmark(sessionBenchmarkId, true);
+            if (sessionResult) {
+                result.phaseTimings.session_management_init = sessionResult.duration;
+                result.componentLoadTimes.session_management = sessionResult.duration;
+            }
+            // Phase 4: Processor activation
+            const processorStart = performance.now();
+            const processorBenchmarkId = this.startBenchmark("processor_activation");
+            const processorResult = this.endBenchmark(processorBenchmarkId, true);
+            if (processorResult) {
+                result.phaseTimings.processor_activation = processorResult.duration;
+                result.componentLoadTimes.processor_pipeline = processorResult.duration;
+            }
+            // Phase 5: Agent loading
+            const agentStart = performance.now();
+            const agentBenchmarkId = this.startBenchmark("agent_loading");
+            const agentResult = this.endBenchmark(agentBenchmarkId, true);
+            if (agentResult) {
+                result.phaseTimings.agent_loading = agentResult.duration;
+                result.componentLoadTimes.agent_loading = agentResult.duration;
+            }
+            // Phase 6: Enforcement activation
+            const enforcementStart = performance.now();
+            const enforcementBenchmarkId = this.startBenchmark("enforcement_activation");
+            const enforcementResult = this.endBenchmark(enforcementBenchmarkId, true);
+            if (enforcementResult) {
+                result.phaseTimings.enforcement_activation = enforcementResult.duration;
+                result.componentLoadTimes.enforcement_system =
+                    enforcementResult.duration;
+            }
+            // Phase 7: Codex compliance activation
+            const codexStart = performance.now();
+            const codexBenchmarkId = this.startBenchmark("codex_compliance_activation");
+            const codexResult = this.endBenchmark(codexBenchmarkId, true);
+            if (codexResult) {
+                result.phaseTimings.codex_compliance_activation = codexResult.duration;
+                result.componentLoadTimes.codex_compliance = codexResult.duration;
+            }
+            // Calculate total boot time
+            result.totalBootTime = performance.now() - bootStartTime;
+            result.memoryUsage.afterBoot = process.memoryUsage().heapUsed;
+            result.memoryUsage.peakDuringBoot = peakMemory;
+            result.success = true;
+        }
+        catch (error) {
+            result.errors.push(error instanceof Error ? error.message : String(error));
+            result.success = false;
+        }
+        return result;
+    }
+    /**
+     * Benchmark orchestrator task execution
+     */
+    async benchmarkOrchestratorTasks(_orchestrator, taskCount = 10, concurrentTasks = 3) {
+        const result = {
+            taskExecutionTimes: [],
+            delegationLatencies: [],
+            conflictResolutionTimes: [],
+            concurrentTaskThroughput: 0,
+            dependencyResolutionTime: 0,
+            overallSuccess: true,
+        };
+        try {
+            // Benchmark single task execution
+            for (let i = 0; i < taskCount; i++) {
+                const taskStart = performance.now();
+                const benchmarkId = this.startBenchmark(`single_task_${i}`, {
+                    taskId: `task_${i}`,
+                });
+                // Simulate task execution
+                await new Promise((resolve) => setTimeout(resolve, Math.random() * 100 + 50));
+                const taskResult = this.endBenchmark(benchmarkId, true);
+                if (taskResult) {
+                    result.taskExecutionTimes.push(taskResult.duration);
+                }
+            }
+            // Benchmark concurrent task execution
+            const concurrentStart = performance.now();
+            const concurrentPromises = [];
+            for (let i = 0; i < concurrentTasks; i++) {
+                const benchmarkId = this.startBenchmark(`concurrent_task_${i}`, {
+                    concurrent: true,
+                });
+                const promise = new Promise((resolve) => {
+                    setTimeout(() => {
+                        this.endBenchmark(benchmarkId, true);
+                        resolve();
+                    }, Math.random() * 200 + 100);
+                });
+                concurrentPromises.push(promise);
+            }
+            await Promise.all(concurrentPromises);
+            const concurrentEnd = performance.now();
+            result.concurrentTaskThroughput =
+                concurrentTasks / ((concurrentEnd - concurrentStart) / 1000);
+            // Benchmark complex task with dependencies
+            const dependencyStart = performance.now();
+            const dependencyBenchmarkId = this.startBenchmark("dependency_resolution");
+            const complexTasks = [
+                {
+                    id: "task_a",
+                    description: "Task A",
+                    subagentType: "architect",
+                    dependencies: [],
+                },
+                {
+                    id: "task_b",
+                    description: "Task B",
+                    subagentType: "code-reviewer",
+                    dependencies: ["task_a"],
+                },
+                {
+                    id: "task_c",
+                    description: "Task C",
+                    subagentType: "researcher",
+                    dependencies: ["task_b"],
+                },
+            ];
+            // Simulate dependency resolution
+            await new Promise((resolve) => setTimeout(resolve, 150));
+            const dependencyResult = this.endBenchmark(dependencyBenchmarkId, true);
+            if (dependencyResult) {
+                result.dependencyResolutionTime = dependencyResult.duration;
+            }
+        }
+        catch (error) {
+            result.overallSuccess = false;
+            await frameworkLogger.log("performance-benchmark", "orchestrator-benchmarking-failed", "error", { error: String(error) });
+        }
+        return result;
+    }
+    /**
+     * Benchmark session management operations
+     */
+    async benchmarkSessionOperations(_sessionStateManager, operationCount = 20) {
+        const result = {
+            stateShareLatencies: [],
+            dependencyUpdateTimes: [],
+            groupOperationTimes: [],
+            migrationTimes: [],
+            failoverTimes: [],
+            concurrentSessionOperations: 0,
+        };
+        try {
+            // Benchmark state sharing
+            for (let i = 0; i < operationCount; i++) {
+                const shareStart = performance.now();
+                const benchmarkId = this.startBenchmark(`state_share_${i}`, {
+                    operation: "share",
+                });
+                // Simulate state sharing
+                await new Promise((resolve) => setTimeout(resolve, Math.random() * 20 + 5));
+                const shareResult = this.endBenchmark(benchmarkId, true);
+                if (shareResult) {
+                    result.stateShareLatencies.push(shareResult.duration);
+                }
+            }
+            // Benchmark dependency operations
+            for (let i = 0; i < operationCount / 2; i++) {
+                const depStart = performance.now();
+                const benchmarkId = this.startBenchmark(`dependency_update_${i}`, {
+                    operation: "dependency",
+                });
+                // Simulate dependency update
+                await new Promise((resolve) => setTimeout(resolve, Math.random() * 30 + 10));
+                const depResult = this.endBenchmark(benchmarkId, true);
+                if (depResult) {
+                    result.dependencyUpdateTimes.push(depResult.duration);
+                }
+            }
+            // Benchmark group operations
+            const groupStart = performance.now();
+            const groupBenchmarkId = this.startBenchmark("group_operations", {
+                operation: "group",
+            });
+            // Simulate group operations
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            const groupResult = this.endBenchmark(groupBenchmarkId, true);
+            if (groupResult) {
+                result.groupOperationTimes.push(groupResult.duration);
+            }
+            // Benchmark migration simulation
+            const migrationStart = performance.now();
+            const migrationBenchmarkId = this.startBenchmark("session_migration", {
+                operation: "migration",
+            });
+            // Simulate migration
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            const migrationResult = this.endBenchmark(migrationBenchmarkId, true);
+            if (migrationResult) {
+                result.migrationTimes.push(migrationResult.duration);
+            }
+        }
+        catch (error) {
+            await frameworkLogger.log("performance-benchmark", "session-benchmarking-failed", "error", { error: String(error) });
+        }
+        return result;
+    }
+    /**
+     * Calculate performance metrics from benchmark results
+     */
+    calculateMetrics(operationFilter) {
+        const filteredResults = operationFilter
+            ? this.results.filter((r) => r.operation.includes(operationFilter))
+            : this.results;
+        if (filteredResults.length === 0) {
+            return {
+                totalOperations: 0,
+                successfulOperations: 0,
+                failedOperations: 0,
+                averageDuration: 0,
+                medianDuration: 0,
+                p95Duration: 0,
+                p99Duration: 0,
+                minDuration: 0,
+                maxDuration: 0,
+                throughput: 0,
+            };
+        }
+        const durations = filteredResults
+            .map((r) => r.duration)
+            .sort((a, b) => a - b);
+        const successful = filteredResults.filter((r) => r.success);
+        const totalTime = Math.max(...filteredResults.map((r) => r.endTime)) -
+            Math.min(...filteredResults.map((r) => r.startTime));
+        const avgDuration = durations.length > 0
+            ? durations.reduce((a, b) => a + b, 0) / durations.length
+            : 0;
+        const medianIndex = Math.floor(durations.length / 2);
+        const medianDuration = durations.length > 0 ? durations[medianIndex] : 0;
+        const p95Index = Math.floor(durations.length * 0.95);
+        const p95Duration = durations.length > 0 ? durations[p95Index] : 0;
+        const p99Index = Math.floor(durations.length * 0.99);
+        const p99Duration = durations.length > 0 ? durations[p99Index] : 0;
+        const minDuration = durations.length > 0 ? Math.min(...durations) : 0;
+        const maxDuration = durations.length > 0 ? Math.max(...durations) : 0;
+        return {
+            totalOperations: filteredResults.length,
+            successfulOperations: successful.length,
+            failedOperations: filteredResults.length - successful.length,
+            averageDuration: avgDuration,
+            medianDuration,
+            p95Duration,
+            p99Duration,
+            minDuration,
+            maxDuration,
+            throughput: filteredResults.length / (totalTime / 1000),
+        };
+    }
+    /**
+     * Generate comprehensive benchmark report
+     */
+    generateReport() {
+        const summary = this.calculateMetrics();
+        const report = {
+            summary,
+            recommendations: [],
+        };
+        // Analyze results and generate recommendations
+        if (summary.averageDuration > 100) {
+            report.recommendations.push("Consider optimizing slow operations (>100ms average)");
+        }
+        if (summary.failedOperations > 0) {
+            report.recommendations.push(`${summary.failedOperations} operations failed - investigate error patterns`);
+        }
+        if (summary.p95Duration > 500) {
+            report.recommendations.push("P95 latency >500ms - consider performance optimizations");
+        }
+        if (summary.throughput < 10) {
+            report.recommendations.push("Low throughput (<10 ops/sec) - evaluate bottlenecks");
+        }
+        return report;
+    }
+    /**
+     * Clear all benchmark results
+     */
+    clearResults() {
+        this.results = [];
+        this.activeBenchmarks.clear();
+    }
+    /**
+     * Export results for external analysis
+     */
+    exportResults() {
+        return [...this.results];
+    }
+}
+// Export singleton instance
+export const performanceBenchmark = new StringRayPerformanceBenchmark();

package/dist/cli/commands/analytics-disable.js

@@ -0,0 +1,72 @@
+/**
+ * Analytics Disable CLI Command
+ *
+ * Disables 0xRay Central Analytics with immediate opt-out
+ *
+ * Usage: npx 0xray analytics disable
+ */
+import { program } from "commander";
+import { ConsentManager } from "../../analytics/consent-manager.js";
+export const analyticsDisableCommand = program
+    .command("analytics disable")
+    .description("Disable 0xRay Central Analytics (opt-out)")
+    .option("-y, --yes", "Skip confirmation prompts", false)
+    .action(async (options) => {
+    console.log("🔒 Disabling 0xRay Central Analytics...\n");
+    try {
+        const consentManager = new ConsentManager();
+        const currentStatus = await consentManager.initialize();
+        // Check if already disabled
+        if (!currentStatus.analyticsEnabled) {
+            console.log("✅ Analytics is already disabled!");
+            return;
+        }
+        // Show what will be disabled
+        console.log("📋 Current Status:");
+        console.log(`  Project ID: ${currentStatus.projectId}`);
+        console.log(`  Enabled Categories: ${Object.entries(currentStatus.categories)
+            .filter(([_, enabled]) => enabled)
+            .map(([cat]) => cat)
+            .join(', ')}`);
+        console.log(`  Submissions will: STOP IMMEDIATELY`);
+        // Confirmation
+        if (!options.yes) {
+            console.log(`\n⚠️  This will immediately stop all data submission.`);
+            console.log(`   • Existing submission queue will be cleared`);
+            console.log(`   • Your project ID will be preserved in config`);
+            console.log(`   • You can re-enable anytime: npx 0xray analytics enable\n`);
+            const readline = await import('readline');
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            const answer = await new Promise((resolve) => {
+                rl.question("Do you want to proceed? (yes/no): ", resolve);
+            });
+            rl.close();
+            if (answer.toLowerCase() !== 'yes' && answer.toLowerCase() !== 'y') {
+                console.log("❌ Consent not disabled. Aborted.");
+                return;
+            }
+        }
+        // Disable consent
+        await consentManager.disableConsent();
+        // Show success
+        console.log("\n✅ Analytics successfully disabled!");
+        console.log(`\n🔒 All data submission has stopped.`);
+        console.log(`\n📋 Your consent configuration:`);
+        const updatedStatus = await consentManager.getStatus();
+        console.log(`  Project ID: ${updatedStatus.projectId}`);
+        console.log(`  Opt-Out Date: ${updatedStatus.lastOptOut?.toISOString()}`);
+        console.log(`  Analytics Enabled: ${updatedStatus.analyticsEnabled}`);
+        console.log(`\n💡 Re-enable anytime:`);
+        console.log(`  npx 0xray analytics enable`);
+        console.log(`\n📖 Learn more: docs/architecture/central-analytics-store.md`);
+    }
+    catch (error) {
+        console.error("❌ Failed to disable analytics:", error instanceof Error ? error.message : String(error));
+        console.error("\n💡 Try: npx 0xray analytics disable --help");
+        process.exit(1);
+    }
+});
+export default analyticsDisableCommand;

package/dist/cli/commands/analytics-enable-action.js

@@ -0,0 +1,82 @@
+/**
+ * Analytics Enable Action
+ *
+ * Enables 0xRay Central Analytics with opt-in consent
+ *
+ * Usage: npx 0xray analytics enable [--categories reflections,logs,metrics,patterns]
+ */
+import { ConsentManager } from "../../analytics/consent-manager.js";
+export async function analyticsEnableAction(options) {
+    console.log("🔓 Enabling 0xRay Central Analytics...\n");
+    try {
+        const consentManager = new ConsentManager();
+        const currentStatus = await consentManager.initialize();
+        // Check if already enabled
+        if (currentStatus.analyticsEnabled) {
+            console.log("✅ Analytics is already enabled!");
+            console.log(`\nCurrent Status:`);
+            console.log(`  Project ID: ${currentStatus.projectId}`);
+            console.log(`  Categories: ${Object.entries(currentStatus.categories)
+                .filter(([_, enabled]) => enabled)
+                .map(([cat]) => cat)
+                .join(', ')}`);
+            return;
+        }
+        // Parse categories
+        let categories;
+        if (options.all) {
+            categories = ["reflections", "logs", "metrics", "patterns"];
+        }
+        else if (options.categories) {
+            categories = options.categories.split(',').map((c) => c.trim());
+        }
+        // Show what will be enabled
+        console.log("📋 Configuration:");
+        console.log(`  Categories to enable: ${categories ? categories.join(', ') : 'all'}`);
+        console.log(`  Project ID will be: ${currentStatus.projectId}`);
+        console.log(`  Consent version: 1.0`);
+        // Confirmation
+        if (!options.yes) {
+            console.log(`\n⚠️  This will enable anonymous data submission to 0xRay Central Analytics.`);
+            console.log(`   • Data is anonymized before submission`);
+            console.log(`   • You can disable anytime with: npx 0xray analytics disable`);
+            console.log(`   • Preview what would be submitted: npx 0xray analytics preview`);
+            console.log(`   • Learn more: docs/architecture/central-analytics-store.md\n`);
+            const readline = await import('readline');
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            const answer = await new Promise((resolve) => {
+                rl.question("Do you want to proceed? (yes/no): ", resolve);
+            });
+            rl.close();
+            if (answer.toLowerCase() !== 'yes' && answer.toLowerCase() !== 'y') {
+                console.log("❌ Consent not enabled. Aborted.");
+                return;
+            }
+        }
+        // Enable consent
+        await consentManager.enableConsent(categories);
+        // Show success
+        console.log("\n✅ Analytics successfully enabled!");
+        console.log(`\n🎉 Your project can now contribute to community learning!`);
+        console.log(`\n📋 Your consent configuration:`);
+        const updatedStatus = await consentManager.getStatus();
+        console.log(`  Project ID: ${updatedStatus.projectId}`);
+        console.log(`  Consent Date: ${updatedStatus.consentDate.toISOString()}`);
+        console.log(`  Categories Enabled: ${Object.entries(updatedStatus.categories)
+            .filter(([_, enabled]) => enabled)
+            .map(([cat]) => cat)
+            .join(', ')}`);
+        console.log(`\n💡 Next steps:`);
+        console.log(`  1. Check what will be submitted: npx 0xray analytics preview`);
+        console.log(`  2. View current status: npx 0xray analytics status`);
+        console.log(`  3. Disable anytime: npx 0xray analytics disable`);
+    }
+    catch (error) {
+        console.error("❌ Failed to enable analytics:", error instanceof Error ? error.message : String(error));
+        console.error("\n💡 Try: npx 0xray analytics enable --help");
+        process.exit(1);
+    }
+}

package/dist/cli/commands/analytics-preview.js

@@ -0,0 +1,106 @@
+/**
+ * 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]
+ */
+import { program } from "commander";
+import { ConsentManager } from "../../analytics/consent-manager.js";
+export const analyticsPreviewCommand = program
+    .command("analytics preview")
+    .description("Preview what data would be submitted (without submitting)")
+    .option("-t, --type <type>", "Specific data type to preview", "all")
+    .option("--all", "Preview all data types", false)
+    .action(async (options) => {
+    console.log("👁️ 0xRay Central Analytics - Data Preview\n");
+    try {
+        const consentManager = new ConsentManager();
+        const status = await consentManager.initialize();
+        // Check if analytics is enabled
+        if (!status.analyticsEnabled) {
+            console.log("❌ Analytics is currently disabled.");
+            console.log(`\n💡 Enable analytics first: npx 0xray analytics enable`);
+            console.log(`   Then preview what would be submitted: npx 0xray analytics preview`);
+            return;
+        }
+        console.log("🔍 This preview shows what anonymized data would be submitted.\n");
+        // Show what gets anonymized vs preserved
+        console.log("🔒 What Gets REMOVED (Privacy Protection):");
+        console.log("  ❌ Project names and company information");
+        console.log("  ❌ Repository URLs and file paths");
+        console.log("  ❌ User names, emails, and personal identifiers");
+        console.log("  ❌ IP addresses and precise timestamps");
+        console.log("  ❌ API keys, secrets, and credentials");
+        console.log("  ❌ Actual code snippets and proprietary logic");
+        console.log("\n✅ What Gets PRESERVED (For Learning):");
+        console.log("  ✅ Agent performance metrics (success rates, confidence scores)");
+        console.log("  ✅ Complexity ratings and outcomes");
+        console.log("  ✅ Pattern effectiveness data");
+        console.log("  ✅ Anonymized emotional/struggle patterns");
+        console.log("  ✅ Counterfactual analysis structures");
+        // Show anonymization example
+        console.log("\n📊 Anonymization Example:");
+        console.log("  📥 Before (Local - Never Submitted):");
+        console.log("    {");
+        console.log(`      "project": "acme-corp/legacy-system",`);
+        console.log(`      "reflection": "Fixed bug in user authentication...",`);
+        console.log(`      "filePath": "/Users/john/projects/legacy/src/auth.ts",`);
+        console.log(`      "author": "john.doe@acme.com",`);
+        console.log(`      "code": "function authenticate(user) { ... }"`);
+        console.log("    }");
+        console.log("\n  📤 After (Anonymized - What Gets Submitted):");
+        console.log("    {");
+        console.log(`      "submissionId": "uuid-v4",`);
+        console.log(`      "taskType": "bug_fix",`);
+        console.log(`      "complexity": 75,`);
+        console.log(`      "routedAgent": "bug-triage-specialist",`);
+        console.log(`      "success": true,`);
+        console.log(`      "emotionalContext": {`);
+        console.log(`        "struggleLevel": "medium",`);
+        console.log(`        "hasCounterfactualAnalysis": true,`);
+        console.log(`        "depthScore": 4`);
+        console.log("      },");
+        console.log(`      "patterns": {`);
+        console.log(`        "keywords": ["bug", "authentication", "critical"],`);
+        console.log(`        "successRate": 0.85`);
+        console.log("      }");
+        console.log("    }");
+        // Show enabled categories
+        const categories = consentManager.getCategories();
+        const enabledCategories = categories.filter(c => c.enabled);
+        console.log("\n📂 Currently Enabled Categories:");
+        enabledCategories.forEach(cat => {
+            console.log(`  ✅ ${cat.name.padEnd(20)} ${cat.description}`);
+        });
+        const disabledCategories = categories.filter(c => !c.enabled);
+        if (disabledCategories.length > 0) {
+            console.log("\n❌ Disabled Categories (Will Not Be Submitted):");
+            disabledCategories.forEach(cat => {
+                console.log(`  ❌ ${cat.name.padEnd(20)} ${cat.description}`);
+            });
+        }
+        // Show privacy guarantees
+        console.log("\n🔐 Privacy Guarantees:");
+        console.log("  ✅ Your data is anonymized before leaving your machine");
+        console.log("  ✅ All submissions encrypted in transit (HTTPS/TLS)");
+        console.log("  ✅ You can disable anytime: npx 0xray analytics disable");
+        console.log("  ✅ Request data deletion anytime");
+        console.log("  ✅ Full transparency - see exactly what's submitted");
+        console.log("\n💡 Next Steps:");
+        console.log("  1. Review this preview carefully");
+        console.log("  2. Enable specific categories: npx 0xray analytics enable --categories reflections,metrics");
+        console.log("  3. View current status: npx 0xray analytics status");
+        console.log("  4. Learn more: docs/architecture/central-analytics-store.md");
+        console.log("\n📖 Documentation:");
+        console.log("  • Architecture: docs/architecture/central-analytics-store.md");
+        console.log("  • Privacy Policy: [To be published]");
+        console.log("  • FAQ: docs/quickstart/central-analytics-quickstart.md");
+    }
+    catch (error) {
+        console.error("❌ Failed to preview analytics:", error instanceof Error ? error.message : String(error));
+        console.error("\n💡 Try: npx 0xray analytics preview --help");
+        process.exit(1);
+    }
+});
+export default analyticsPreviewCommand;