0xray 4.0.13 → 4.0.15

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.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/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 = [];
+    for (const skillsPath of [join(getConfigDir(cwd), "skills"), join(cwd, ".opencode", "skills")]) {
+        if (!existsSync(skillsPath))
+            continue;
+        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.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/archive-logs.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+/**
+ * Standalone Log Archive CLI
+ *
+ * Archives log files without requiring framework boot.
+ * Used by git hooks to prevent log truncation.
+ *
+ */
+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.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/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/XRAY_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/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/enforce.js

@@ -0,0 +1,78 @@
+import { beforeToolHook, afterToolHook } from "../../integrations/enforcement-gate.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+import { mcpClientManager } from "../../mcps/mcp-client.js";
+export async function enforceCommand(options) {
+    const phase = options.phase || "health";
+    let parsedArgs = null;
+    if (options.args) {
+        try {
+            parsedArgs = JSON.parse(options.args);
+        }
+        catch {
+            parsedArgs = {};
+        }
+    }
+    try {
+        switch (phase) {
+            case "pre": {
+                const result = await beforeToolHook(options.tool || "unknown", parsedArgs);
+                process.stdout.write(JSON.stringify(result) + "\n");
+                break;
+            }
+            case "post": {
+                let parsedResult = null;
+                if (options.result) {
+                    try {
+                        parsedResult = JSON.parse(options.result);
+                    }
+                    catch { }
+                }
+                const result = await afterToolHook(options.tool || "unknown", parsedArgs, parsedResult, options.error || null);
+                process.stdout.write(JSON.stringify(result) + "\n");
+                break;
+            }
+            case "validate": {
+                let files = [];
+                if (options.files) {
+                    try {
+                        files = JSON.parse(options.files);
+                    }
+                    catch { }
+                }
+                const result = await mcpClientManager.callServerTool("enforcer", "run-pre-commit-validation", { files, operation: "commit" });
+                process.stdout.write(JSON.stringify(result) + "\n");
+                break;
+            }
+            case "codex-check": {
+                let focusAreas = [];
+                if (options.focusAreas) {
+                    try {
+                        focusAreas = JSON.parse(options.focusAreas);
+                    }
+                    catch { }
+                }
+                const result = await mcpClientManager.callServerTool("enforcer", "codex-enforcement", {
+                    operation: "write",
+                    newCode: options.code || "",
+                    focusAreas,
+                });
+                process.stdout.write(JSON.stringify(result) + "\n");
+                break;
+            }
+            case "health": {
+                const result = await mcpClientManager.callServerTool("enforcer", "get-enforcement-status", {});
+                process.stdout.write(JSON.stringify(result) + "\n");
+                break;
+            }
+            default:
+                process.stderr.write(`Unknown phase: ${phase}\n`);
+                process.exit(1);
+        }
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        await frameworkLogger.log("enforce-command", "execution-error", "error", { phase, error: errMsg });
+        const fallback = { status: "error", phase, error: errMsg };
+        process.stdout.write(JSON.stringify(fallback) + "\n");
+    }
+}

package/dist/cli/commands/foundry-mint-wear.d.ts

@@ -0,0 +1,3 @@
+export declare function wantsCostume(targetDir: string): boolean;
+/** Re-apply mill overlay after CLI re-wear copies mill skills. */
+export declare function mintAfterWear(targetDir: string): void;

package/dist/cli/commands/foundry-mint-wear.js

@@ -0,0 +1,17 @@
+import path from "path";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { frameworkLogger } from "../../core/framework-logger.js";
+const require = createRequire(import.meta.url);
+const packageRoot = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+const millSuit = require(path.join(packageRoot, "scripts/foundry/mint-suit.cjs"));
+export function wantsCostume(targetDir) {
+    return millSuit.wantsCostume(targetDir);
+}
+/** Re-apply mill overlay after CLI re-wear copies mill skills. */
+export function mintAfterWear(targetDir) {
+    millSuit.mintConsumerSuit(packageRoot, targetDir, (component, action, status, details) => {
+        const level = status === "error" ? "error" : "info";
+        frameworkLogger.log(component, action, level, details);
+    });
+}

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 {};