0xray 2.0.0

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

@@ -0,0 +1,68 @@
+/**
+ * Analytics Status CLI Command
+ *
+ * Shows current consent and analytics status
+ *
+ * Usage: npx 0xray analytics status
+ */
+import { program } from "commander";
+import { ConsentManager } from "../../analytics/consent-manager.js";
+import { getConfigDir } from "../../core/config-paths.js";
+export const analyticsStatusCommand = program
+    .command("analytics status")
+    .description("Show current analytics consent status")
+    .option("-v, --verbose", "Show detailed information", false)
+    .action(async (options) => {
+    console.log("📊 0xRay Central Analytics Status\n");
+    try {
+        const consentManager = new ConsentManager();
+        const status = await consentManager.getStatus();
+        // Show main status
+        const enabledEmoji = status.analyticsEnabled ? "✅ ENABLED" : "❌ DISABLED";
+        console.log(`🎯 Status: ${enabledEmoji}\n`);
+        // Show project ID
+        console.log(`📋 Project Information:`);
+        console.log(`  Project ID: ${status.projectId}`);
+        console.log(`  Consent Version: ${status.consentVersion}`);
+        console.log(`  Consent Date: ${status.consentDate.toISOString()}`);
+        if (status.lastOptOut) {
+            console.log(`  Last Opt-Out: ${status.lastOptOut.toISOString()}`);
+        }
+        // Show category status
+        console.log(`\n📂 Categories Status:`);
+        const categories = consentManager.getCategories();
+        categories.forEach(cat => {
+            const emoji = cat.enabled ? "✅" : "❌";
+            console.log(`  ${emoji} ${cat.name.padEnd(15)} ${cat.description}`);
+        });
+        if (options.verbose) {
+            // Show configuration file location
+            const configDir = getConfigDir();
+            console.log(`\n📁 Configuration Files:`);
+            console.log(`  Consent Config: ${configDir}/consent.json`);
+            console.log(`  Submission Queue: ${configDir}/analytics/submission-queue.json`);
+            // Show detailed information
+            console.log(`\n📊 Detailed Information:`);
+            const enabledCats = categories.filter(c => c.enabled);
+            console.log(`  Enabled Categories: ${enabledCats.length}/${categories.length}`);
+            console.log(`  Analytics Active: ${status.analyticsEnabled}`);
+            if (status.analyticsEnabled) {
+                console.log(`\n💡 Your project is contributing to community learning!`);
+                console.log(`   • View what's being submitted: npx 0xray analytics preview`);
+                console.log(`   • Get community insights: npx 0xray analytics recommendations`);
+                console.log(`   • Check performance: npx 0xray analytics`);
+            }
+            else {
+                console.log(`\n💡 Analytics is currently disabled.`);
+                console.log(`   • Enable anytime: npx 0xray analytics enable`);
+                console.log(`   • Learn more: docs/architecture/central-analytics-store.md`);
+            }
+        }
+    }
+    catch (error) {
+        console.error("❌ Failed to get analytics status:", error instanceof Error ? error.message : String(error));
+        console.error("\n💡 Try: npx 0xray analytics status --help");
+        process.exit(1);
+    }
+});
+export default analyticsStatusCommand;

package/dist/cli/commands/antigravity-status.js

@@ -0,0 +1,106 @@
+/**
+ * Antigravity Status CLI Command
+ *
+ * Shows status of all installed skills.
+ *
+ * Usage: npx 0xray antigravity status
+ */
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { getConfigDir } from "../../core/config-paths.js";
+function getSkillsFromSkills(cwd) {
+    const skills = [];
+    const skillsPath = join(getConfigDir(cwd), "skills");
+    if (!existsSync(skillsPath)) {
+        return skills;
+    }
+    const dirs = readdirSync(skillsPath).filter((f) => {
+        const skillPath = join(skillsPath, f, "SKILL.md");
+        return existsSync(skillPath);
+    });
+    for (const dir of dirs) {
+        const skillPath = join(skillsPath, dir, "SKILL.md");
+        const content = readFileSync(skillPath, "utf-8");
+        const sourceMatch = content.match(/^source:\s*(.+)/m);
+        const sourceNameMatch = content.match(/^source_name:\s*(.+)/m);
+        const licenseMatch = content.match(/License:\s*(.+)/m);
+        const rawName = dir.includes("--") ? dir.split("--").slice(1).join("--") : dir;
+        const communitySource = sourceNameMatch ? sourceNameMatch[1].trim() : null;
+        skills.push({
+            name: rawName,
+            source: sourceMatch && sourceMatch[1] ? sourceMatch[1].trim() : "custom",
+            communitySource,
+            license: licenseMatch ? licenseMatch[1].trim() : "unknown",
+            category: extractCategory(content),
+            path: skillPath,
+        });
+    }
+    return skills;
+}
+function extractCategory(content) {
+    const categoryMatch = content.match(/category:\s*(.+)/i);
+    if (categoryMatch && categoryMatch[1]) {
+        return categoryMatch[1].trim();
+    }
+    if (content.includes("typescript") || content.includes("python")) {
+        return "language";
+    }
+    if (content.includes("security") || content.includes("audit")) {
+        return "security";
+    }
+    if (content.includes("design") || content.includes("ui") || content.includes("frontend")) {
+        return "design";
+    }
+    if (content.includes("memory") || content.includes("context")) {
+        return "memory";
+    }
+    return "general";
+}
+export async function antigravityStatusCommand() {
+    const cwd = process.cwd();
+    const skills = getSkillsFromSkills(cwd);
+    const frameworkSkills = skills.filter((s) => s.source === "framework");
+    const communitySkills = skills.filter((s) => s.source === "community");
+    const communityBySource = communitySkills.reduce((acc, skill) => {
+        const key = skill.communitySource || "unknown";
+        if (!acc[key])
+            acc[key] = [];
+        acc[key].push(skill);
+        return acc;
+    }, {});
+    console.log("");
+    console.log("╔══════════════════════════════════════════════════╗");
+    console.log("║              Installed Skills Status            ║");
+    console.log("╚══════════════════════════════════════════════════╝");
+    console.log("");
+    console.log(`Framework Skills: ${frameworkSkills.length}`);
+    console.log(`Community Skills: ${communitySkills.length} (from ${Object.keys(communityBySource).length} sources)`);
+    console.log(`Total: ${skills.length}`);
+    console.log("");
+    console.log("── Framework Skills ──");
+    console.log("");
+    frameworkSkills
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .forEach((skill) => {
+        console.log(`  ${skill.name}`);
+    });
+    console.log("");
+    if (Object.keys(communityBySource).length > 0) {
+        console.log("── Community Skills (by source) ──");
+        console.log("");
+        Object.entries(communityBySource)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .forEach(([source, sourceSkills]) => {
+            console.log(`  ${source} (${sourceSkills.length})`);
+            sourceSkills
+                .sort((a, b) => a.name.localeCompare(b.name))
+                .forEach((skill) => {
+                const licenseBadge = skill.license.toUpperCase().substring(0, 3);
+                console.log(`    - ${skill.name} [${licenseBadge}]`);
+            });
+            console.log("");
+        });
+    }
+    console.log("-".repeat(50));
+}
+export default antigravityStatusCommand;

package/dist/cli/commands/archive-logs.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+/**
+ * Standalone Log Archive CLI
+ *
+ * Archives log files without requiring framework boot.
+ * Used by git hooks to prevent log truncation.
+ *
+ * @version 1.0.0
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { createReadStream, createWriteStream } from "fs";
+import { pipeline } from "stream/promises";
+import { createGzip } from "zlib";
+const DEFAULT_CONFIG = {
+    maxFileSizeMB: 10,
+    rotationIntervalHours: 24,
+    compressionEnabled: true,
+    maxArchives: 10,
+};
+/**
+ * Archive log files without framework dependencies
+ */
+export async function archiveLogFiles(config = DEFAULT_CONFIG, jobId = `archive-${Date.now()}`) {
+    const result = { archived: 0, errors: [] };
+    const cwd = process.cwd();
+    // Archive activity.log
+    const activityLogPath = path.join(cwd, "logs", "framework", "activity.log");
+    if (fs.existsSync(activityLogPath)) {
+        const stats = fs.statSync(activityLogPath);
+        const shouldArchive = stats.size > config.maxFileSizeMB * 1024 * 1024 ||
+            Date.now() - stats.mtime.getTime() > config.rotationIntervalHours * 60 * 60 * 1000;
+        if (shouldArchive) {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+            const archiveName = `framework-activity-${timestamp}.log`;
+            const archivePath = path.join(cwd, "logs", "framework", archiveName);
+            let archiveSuccess = false;
+            try {
+                // Copy current log to archive
+                fs.copyFileSync(activityLogPath, archivePath);
+                // Compress if enabled
+                if (config.compressionEnabled) {
+                    const compressedPath = `${archivePath}.gz`;
+                    const gzip = createGzip();
+                    const input = createReadStream(archivePath);
+                    const output = createWriteStream(compressedPath);
+                    await pipeline(input, gzip, output);
+                    // Verify compression succeeded
+                    if (fs.existsSync(compressedPath)) {
+                        const compressedStats = fs.statSync(compressedPath);
+                        if (compressedStats.size > 0) {
+                            fs.unlinkSync(archivePath);
+                            archiveSuccess = true;
+                            console.log(`[${jobId}] Archived activity.log → ${compressedPath}`);
+                        }
+                    }
+                }
+                else {
+                    archiveSuccess = true;
+                    console.log(`[${jobId}] Archived activity.log → ${archivePath}`);
+                }
+                // ONLY reset if archive was successful
+                if (archiveSuccess) {
+                    const header = `# Log rotated on ${new Date().toISOString()}\n`;
+                    fs.writeFileSync(activityLogPath, header);
+                    result.archived++;
+                }
+                else {
+                    result.errors.push("Archive creation failed - log left intact");
+                    console.error(`[${jobId}] Archive failed - log not modified`);
+                }
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                result.errors.push(`Archive failed: ${errorMsg}`);
+                console.error(`[${jobId}] Archive error: ${errorMsg}`);
+                // Cleanup partial files
+                if (fs.existsSync(archivePath)) {
+                    try {
+                        fs.unlinkSync(archivePath);
+                    }
+                    catch { /* ignore */ }
+                }
+                const compressedPath = `${archivePath}.gz`;
+                if (fs.existsSync(compressedPath)) {
+                    try {
+                        fs.unlinkSync(compressedPath);
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+        }
+        else {
+            console.log(`[${jobId}] activity.log does not need archiving (${(stats.size / 1024).toFixed(1)}KB)`);
+        }
+    }
+    // Cleanup old archives
+    cleanupOldArchives(config.maxArchives);
+    return result;
+}
+/**
+ * Keep only the most recent N archives
+ */
+function cleanupOldArchives(maxArchives) {
+    const cwd = process.cwd();
+    const frameworkDir = path.join(cwd, "logs", "framework");
+    if (!fs.existsSync(frameworkDir))
+        return;
+    const archives = fs
+        .readdirSync(frameworkDir)
+        .filter((f) => f.startsWith("framework-activity-") && f.endsWith(".log.gz"))
+        .map((f) => ({
+        name: f,
+        path: path.join(frameworkDir, f),
+        mtime: fs.statSync(path.join(frameworkDir, f)).mtime,
+    }))
+        .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    if (archives.length > maxArchives) {
+        const toDelete = archives.slice(maxArchives);
+        for (const archive of toDelete) {
+            try {
+                fs.unlinkSync(archive.path);
+                console.log(`[cleanup] Removed old archive: ${archive.name}`);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+}
+/**
+ * Main entry point
+ */
+async function main() {
+    const args = process.argv.slice(2);
+    const dryRun = args.includes("--dry-run");
+    const verbose = args.includes("--verbose");
+    console.log("📦 0xRay Log Archive");
+    console.log("========================");
+    if (dryRun) {
+        console.log("(Dry run mode - no changes will be made)");
+    }
+    const config = dryRun
+        ? { ...DEFAULT_CONFIG, maxFileSizeMB: 0.001 } // Force archive in dry-run
+        : DEFAULT_CONFIG;
+    const result = await archiveLogFiles(config);
+    console.log("\n📊 Results:");
+    console.log(`  Archived: ${result.archived} files`);
+    if (result.errors.length > 0) {
+        console.log(`  Errors: ${result.errors.length}`);
+        result.errors.forEach((e) => console.log(`    - ${e}`));
+    }
+    process.exit(result.errors.length > 0 ? 1 : 0);
+}
+// Only run main if this file is executed directly (not imported)
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((error) => {
+        console.error("Fatal error:", error);
+        process.exit(1);
+    });
+}

package/dist/cli/commands/credible-init.js

@@ -0,0 +1,82 @@
+/**
+ * Credible Init CLI Command
+ *
+ * Initializes a Credible Pod - a self-contained agent environment.
+ *
+ * Usage: npx 0xray credible init [options]
+ *
+ * Status: PLANNED - Not yet implemented
+ */
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const options = {
+        name: "",
+        force: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i] ?? "";
+        const nextArg = args[i + 1];
+        if (arg === "--name" && nextArg && !nextArg.startsWith("--")) {
+            options.name = nextArg;
+            i++;
+        }
+        else if (arg === "--template" && nextArg && !nextArg.startsWith("--")) {
+            options.template = nextArg;
+            i++;
+        }
+        else if (arg === "--force" || arg === "-f") {
+            options.force = true;
+        }
+        else if (arg && !arg.startsWith("--")) {
+            options.name = arg;
+        }
+    }
+    return options;
+}
+function showNotImplemented() {
+    console.log("");
+    console.log("╔══════════════════════════════════════════════════╗");
+    console.log("║           Credible Pod Initialization           ║");
+    console.log("╚══════════════════════════════════════════════════╝");
+    console.log("");
+    console.log("⚠️  This feature is planned but not yet implemented.");
+    console.log("");
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    console.log("");
+    console.log("📋 Planned Features:");
+    console.log("");
+    console.log("  Pod Types:");
+    console.log("    • dev     - Development environment with full tooling");
+    console.log("    • prod    - Production-optimized minimal environment");
+    console.log("    • minimal - Lightweight container for specific tasks");
+    console.log("");
+    console.log("  Features:");
+    console.log("    • Isolated agent environments");
+    console.log("    • Resource quotas and limits");
+    console.log("    • Persistent storage");
+    console.log("    • Network isolation");
+    console.log("    • Credential management");
+    console.log("");
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    console.log("");
+    console.log("💡 To be notified when this feature is available:");
+    console.log("   Track the evolution spec at docs/roadmap/STRINGRAY_EVOLUTION_SPEC.md");
+    console.log("");
+    console.log("🔜 Roadmap: Phase 3 (Polishing & Release)");
+    console.log("");
+}
+export async function credibleInitCommand() {
+    const cwd = process.cwd();
+    const options = parseArgs();
+    showNotImplemented();
+    console.log("Usage: npx 0xray credible init [options]");
+    console.log("");
+    console.log("Options:");
+    console.log("  --name <name>      Pod name (required)");
+    console.log("  --template <type>  Pod template (dev|prod|minimal)");
+    console.log("  --force, -f        Overwrite existing pod");
+    console.log("");
+    console.log("Example: npx 0xray credible init --name my-pod --template dev");
+    console.log("");
+}
+export default credibleInitCommand;

package/dist/cli/commands/grok-install.js

@@ -0,0 +1,16 @@
+/**
+ * CLI command: 0xray grok install
+ *
+ * Helps users register 0xRay MCP servers with the Grok CLI.
+ */
+import { installForGrokCLI } from '../../integrations/grok/grok-cli.js';
+export function registerGrokCommands(grokCmd) {
+    grokCmd
+        .command('install')
+        .description('Install 0xRay as a first-class Grok CLI plugin (hooks + MCP servers)')
+        .option('--dry-run', 'Show what would be done without making changes')
+        .option('--force', 'Force reinstall even if already present')
+        .action(async (options) => {
+        await installForGrokCLI({ dryRun: options.dryRun, force: options.force });
+    });
+}

package/dist/cli/commands/hermes-install.js

@@ -0,0 +1,66 @@
+import fs from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+import { frameworkLogger } from '../../core/framework-logger.js';
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+export function registerHermesCommands(hermesCmd) {
+    hermesCmd
+        .command('install')
+        .description('Install 0xRay as a Hermes Agent plugin (hooks + MCP servers)')
+        .option('--dry-run', 'Show what would be done without making changes')
+        .option('--force', 'Force reinstall even if already present')
+        .action(async (options) => {
+        await installForHermes({ dryRun: options.dryRun, force: options.force });
+    });
+}
+async function installForHermes(options = {}) {
+    frameworkLogger.log('hermes-integration', 'install-start', 'info', { options });
+    const home = homedir();
+    const targetPluginDir = path.join(home, '.hermes/plugins/strray-hermes');
+    const possibleSources = [
+        path.join(__dirname, '..', '..', '..', 'dist/integrations/hermes-agent'),
+        path.join(__dirname, '..', '..', '..', 'src/integrations/hermes-agent'),
+    ];
+    let sourceDir = possibleSources.find(p => fs.existsSync(p));
+    if (!sourceDir) {
+        console.error('[Hermes] Could not locate the strray-hermes plugin inside the package.');
+        return;
+    }
+    if (options.dryRun) {
+        console.log(`[Hermes] Dry run: Would copy plugin from ${sourceDir} → ${targetPluginDir}`);
+        return;
+    }
+    try {
+        if (fs.existsSync(targetPluginDir) && !options.force) {
+            console.log('[Hermes] strray-hermes plugin is already installed.');
+            console.log('Use --force to reinstall.');
+            return;
+        }
+        fs.mkdirSync(targetPluginDir, { recursive: true });
+        for (const entry of fs.readdirSync(sourceDir)) {
+            const src = path.join(sourceDir, entry);
+            const dst = path.join(targetPluginDir, entry);
+            if (fs.statSync(src).isDirectory()) {
+                fs.cpSync(src, dst, { recursive: true, force: true });
+            }
+            else {
+                fs.copyFileSync(src, dst);
+            }
+        }
+        frameworkLogger.log('hermes-integration', 'plugin-copied', 'info', { destination: targetPluginDir });
+        console.log(`\x1b[32m✓ Copied Hermes plugin to ${targetPluginDir}\x1b[0m`);
+        // Write after-install instructions
+        const afterInstallPath = path.join(targetPluginDir, 'after-install.md');
+        if (fs.existsSync(afterInstallPath)) {
+            console.log(`\nSee ${afterInstallPath} for post-install steps.`);
+        }
+        console.log('\n✅ 0xRay is now installed as a Hermes Agent plugin!');
+        console.log('Restart Hermes to load the plugin and its tools.');
+        console.log('  Run: /strray status  (to verify)');
+    }
+    catch (err) {
+        frameworkLogger.log('hermes-integration', 'install-error', 'error', { error: err.message });
+        console.error('Failed to install Hermes plugin:', err.message);
+    }
+    frameworkLogger.log('hermes-integration', 'install-complete', 'info', {});
+}