0xray 2.0.0

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

@@ -0,0 +1,481 @@
+import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, cpSync, rmSync, statSync, unlinkSync } from "fs";
+import { join, basename, dirname } from "path";
+import { execSync } from "child_process";
+function getLocalRegistryPath() {
+    return join(process.cwd(), ".opencode", "strray", "skill-registry.json");
+}
+function getBundledRegistry() {
+    const paths = [
+        join(process.cwd(), "src", "skills", "registry.json"),
+        join(process.cwd(), "node_modules", "0xray", "dist", "skills", "registry.json"),
+        join(process.cwd(), "node_modules", "0xray", "src", "skills", "registry.json"),
+    ];
+    for (const p of paths) {
+        if (existsSync(p)) {
+            return JSON.parse(readFileSync(p, "utf-8"));
+        }
+    }
+    return null;
+}
+function getRegistry() {
+    const bundled = getBundledRegistry();
+    const localPath = getLocalRegistryPath();
+    if (existsSync(localPath)) {
+        const local = JSON.parse(readFileSync(localPath, "utf-8"));
+        if (bundled) {
+            const names = new Set(bundled.sources.map((s) => s.name));
+            for (const s of local.sources) {
+                if (!names.has(s.name))
+                    bundled.sources.push(s);
+            }
+            return bundled;
+        }
+        return local;
+    }
+    return bundled ?? { sources: [] };
+}
+function findSource(name) {
+    return getRegistry().sources.find((s) => s.name === name || s.url === name);
+}
+function resolveSourcePrefix(sourceArg, source) {
+    if (source?.name)
+        return source.name;
+    const match = sourceArg.match(/\/([^/]+?)(?:\.git)?$/);
+    return match?.[1] ?? sourceArg.replace(/[^a-zA-Z0-9-]/g, "-");
+}
+function cleanSourceSkills(skillsDir, sourcePrefix) {
+    let removed = 0;
+    const prefix = `${sourcePrefix}--`;
+    if (!existsSync(skillsDir))
+        return 0;
+    for (const entry of readdirSync(skillsDir, { withFileTypes: true })) {
+        if (entry.isDirectory() && entry.name.startsWith(prefix)) {
+            rmSync(join(skillsDir, entry.name), { recursive: true });
+            removed++;
+        }
+    }
+    return removed;
+}
+function extractRepoSlug(input) {
+    // Handle URLs
+    const https = input.match(/github\.com\/([^/]+)\/([^/.]+)/);
+    if (https)
+        return { owner: https[1], repo: https[2] };
+    // Handle bare repo names: "owner/repo" or just "repo" (assumes htafolla)
+    const bare = input.match(/^([a-zA-Z0-9_-]+)\/([a-zA-Z0-9_-]+)$/);
+    if (bare)
+        return { owner: bare[1], repo: bare[2] };
+    // Single word — assume it's a repo under the htafolla org
+    if (/^[a-zA-Z0-9_-]+$/.test(input))
+        return { owner: "htafolla", repo: input };
+    return null;
+}
+function cloneRepo(url, targetDir) {
+    if (existsSync(targetDir)) {
+        rmSync(targetDir, { recursive: true });
+    }
+    mkdirSync(targetDir, { recursive: true });
+    const tarPath = join(targetDir, "_repo.tar.gz");
+    const extracted = join(targetDir, "_repo");
+    // Always try gh first when authenticated (faster, handles auth seamlessly)
+    const slug = extractRepoSlug(url);
+    const ghTarget = slug ? `${slug.owner}/${slug.repo}` : url;
+    let hasGh = false;
+    try {
+        execSync("gh auth status --hostname github.com", { stdio: "pipe", timeout: 5000 });
+        hasGh = true;
+    }
+    catch { /* gh not installed or not authenticated */ }
+    if (hasGh) {
+        try {
+            console.log(`  Cloning via gh...`);
+            execSync(`gh repo clone ${ghTarget} "${extracted}" -- --depth 1`, { stdio: "pipe", timeout: 60000 });
+            return extracted;
+        }
+        catch (ghErr) {
+            const stderr = ghErr?.stderr?.toString("utf-8") || "";
+            console.log(`  gh failed: ${stderr.split("\n")[0]}`);
+        }
+    }
+    // Fallback: try as URL if no slug
+    if (!slug) {
+        execSync(`git clone --depth 1 ${url} "${extracted}"`, { stdio: "pipe" });
+        return extracted;
+    }
+    const errors = [];
+    // Fallback: tarball download (public repos)
+    for (const branch of ["main", "master"]) {
+        const archiveUrl = `https://codeload.github.com/${slug.owner}/${slug.repo}/tar.gz/${branch}`;
+        try {
+            execSync(`curl -fsSL "${archiveUrl}" -o "${tarPath}"`, { stdio: "pipe", timeout: 30000 });
+            if (!existsSync(tarPath) || statSync(tarPath).size < 100) {
+                if (existsSync(tarPath))
+                    unlinkSync(tarPath);
+                errors.push(`  ${branch}: downloaded empty file (repo may not exist)`);
+                continue;
+            }
+            execSync(`tar -xzf "${tarPath}" -C "${targetDir}"`, { stdio: "pipe" });
+            unlinkSync(tarPath);
+            const dirName = `${slug.repo}-${branch}`;
+            const repoDir = join(targetDir, dirName);
+            if (existsSync(repoDir))
+                return repoDir;
+            const dirs = readdirSync(targetDir).filter((f) => f.startsWith(slug.repo + "-") && f !== "_repo.tar.gz");
+            if (dirs.length > 0)
+                return join(targetDir, dirs[0]);
+            errors.push(`  ${branch}: archive extracted but repo directory not found`);
+        }
+        catch (tarErr) {
+            if (existsSync(tarPath)) {
+                try {
+                    unlinkSync(tarPath);
+                }
+                catch { /* ignore */ }
+            }
+            errors.push(`  tarball (${branch}): ${tarErr.message.split("\n")[0]}`);
+        }
+        finally {
+            if (existsSync(tarPath)) {
+                try {
+                    unlinkSync(tarPath);
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+    // Last resort: git clone (HTTPS then SSH)
+    const httpsUrl = `https://github.com/${slug.owner}/${slug.repo}.git`;
+    const sshUrl = `git@github.com:${slug.owner}/${slug.repo}.git`;
+    for (const [proto, gitUrl] of [["HTTPS", httpsUrl], ["SSH", sshUrl]]) {
+        try {
+            execSync(`git clone --depth 1 ${gitUrl} "${extracted}"`, { stdio: "pipe", timeout: 30000 });
+            return extracted;
+        }
+        catch (gitErr) {
+            const stderr = gitErr?.stderr?.toString("utf-8") || "";
+            if (stderr.includes("Authentication failed") || stderr.includes("Invalid username")) {
+                errors.push(`  git ${proto}: authentication failed — your GitHub token/credentials are expired or misconfigured`);
+            }
+            else if (stderr.includes("Permission denied")) {
+                errors.push(`  git ${proto}: permission denied — repo may be private`);
+            }
+            else if (stderr.includes("not found")) {
+                errors.push(`  git ${proto}: repository not found`);
+            }
+            else {
+                errors.push(`  git ${proto}: ${stderr.split("\n").filter((l) => l.includes("fatal:"))[0]?.trim() || gitErr.message.split("\n")[0]}`);
+            }
+        }
+    }
+    console.log("");
+    console.log("  Download failed after 4 attempts:");
+    for (const e of errors)
+        console.log(e);
+    console.log("");
+    console.log("  To fix git authentication:");
+    console.log("    1. Run: gh auth login");
+    console.log("    2. Or update your GitHub token: git credential-osxkeychain erase");
+    console.log("    3. Or use SSH: ssh-keygen -t ed25519 && gh ssh-key add");
+    console.log("");
+    throw new Error(`Failed to download ${url}. See errors above.`);
+}
+const SKILL_PLATFORMS = [".opencode", ".claude", ".codex", ".cursor", ".gemini", ".kiro", ".pi", ".trae", ".trae-cn", ".agents", ".continue", ".factory", ".windsurf"];
+function detectFormat(repoDir) {
+    if (existsSync(join(repoDir, "skills"))) {
+        const entries = readdirSync(join(repoDir, "skills"), { withFileTypes: true })
+            .filter((d) => d.isDirectory());
+        if (entries.some((d) => existsSync(join(repoDir, "skills", d.name, "SKILL.md")))) {
+            return { format: "skill-folders", root: join(repoDir, "skills") };
+        }
+    }
+    for (const platform of SKILL_PLATFORMS) {
+        const platformSkillsDir = join(repoDir, platform, "skills");
+        if (existsSync(platformSkillsDir)) {
+            const entries = readdirSync(platformSkillsDir, { withFileTypes: true })
+                .filter((d) => d.isDirectory());
+            if (entries.some((d) => existsSync(join(platformSkillsDir, d.name, "SKILL.md")))) {
+                return { format: "skill-folders", root: platformSkillsDir };
+            }
+        }
+    }
+    const entries = readdirSync(repoDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const entry of entries) {
+        const nestedSkillsDir = join(repoDir, entry.name, "skills");
+        if (existsSync(nestedSkillsDir)) {
+            const nestedEntries = readdirSync(nestedSkillsDir, { withFileTypes: true })
+                .filter((d) => d.isDirectory());
+            if (nestedEntries.some((d) => existsSync(join(nestedSkillsDir, d.name, "SKILL.md")))) {
+                return { format: "skill-folders", root: nestedSkillsDir };
+            }
+        }
+    }
+    const subdirs = readdirSync(repoDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory() && !d.name.startsWith(".") && d.name !== "integrations" && d.name !== "examples" && d.name !== "scripts" && d.name !== "node_modules");
+    for (const dir of subdirs) {
+        const mdFiles = readdirSync(join(repoDir, dir.name))
+            .filter((f) => f.endsWith(".md") && f !== "README.md" && f !== "CONTRIBUTING.md" && f !== "LICENSE");
+        if (mdFiles.length > 0) {
+            const sample = readFileSync(join(repoDir, dir.name, mdFiles[0]), "utf-8");
+            if (/^---\s*\n\s*name:/m.test(sample)) {
+                return { format: "flat-md", root: repoDir };
+            }
+        }
+    }
+    const rootMds = readdirSync(repoDir)
+        .filter((f) => f.endsWith(".md") && f !== "README.md" && f !== "CONTRIBUTING.md" && f !== "LICENSE");
+    if (rootMds.length > 0) {
+        const sample = readFileSync(join(repoDir, rootMds[0]), "utf-8");
+        if (/^---\s*\n\s*name:/m.test(sample)) {
+            return { format: "flat-md", root: repoDir };
+        }
+    }
+    if (existsSync(join(repoDir, "CLAUDE.md"))) {
+        return { format: "single-md", root: repoDir };
+    }
+    return { format: "unknown", root: repoDir };
+}
+function extractFrontmatter(content) {
+    const nameMatch = content.match(/^name:\s*(.+)$/m);
+    const descMatch = content.match(/^description:\s*(.+)$/m);
+    const body = content.replace(/^---[\s\S]*?---\n?/, "").trim();
+    return {
+        name: nameMatch ? nameMatch[1].trim() : "",
+        description: descMatch ? descMatch[1].trim() : "",
+        body,
+    };
+}
+function installSkillFolders(sourceRoot, skillsDir, sourcePrefix, sourceUrl, license) {
+    let count = 0;
+    const dirs = readdirSync(sourceRoot, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const d of dirs) {
+        const skillMd = join(sourceRoot, d.name, "SKILL.md");
+        if (!existsSync(skillMd))
+            continue;
+        const { name, description, body } = extractFrontmatter(readFileSync(skillMd, "utf-8"));
+        const finalName = name || d.name;
+        const finalDesc = description;
+        const destDir = join(skillsDir, `${sourcePrefix}--${d.name}`);
+        mkdirSync(destDir, { recursive: true });
+        if (finalName && finalDesc) {
+            writeFileSync(join(destDir, "SKILL.md"), `---\nname: ${finalName}\ndescription: ${finalDesc}\nsource: community\nsource_name: ${sourcePrefix}\nattribution: |\n  Originally from ${sourceUrl}\n  License: ${license || "unknown"}\n---\n\n${body}\n`);
+        }
+        else {
+            cpSync(skillMd, join(destDir, "SKILL.md"));
+        }
+        for (const f of readdirSync(join(sourceRoot, d.name))) {
+            if (f !== "SKILL.md") {
+                const src = join(sourceRoot, d.name, f);
+                const dest = join(destDir, f);
+                try {
+                    cpSync(src, dest, { recursive: true });
+                }
+                catch { /* skip */ }
+            }
+        }
+        count++;
+    }
+    return count;
+}
+function installFlatMd(repoDir, skillsDir, sourcePrefix, sourceUrl, license) {
+    let count = 0;
+    const subdirs = readdirSync(repoDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory() && !d.name.startsWith(".") && d.name !== "integrations" && d.name !== "examples" && d.name !== "scripts" && d.name !== "node_modules");
+    for (const cat of subdirs) {
+        const catDir = join(repoDir, cat.name);
+        const mdFiles = readdirSync(catDir).filter((f) => f.endsWith(".md") && f !== "README.md" && f !== "CONTRIBUTING.md" && f !== "LICENSE");
+        for (const mdFile of mdFiles) {
+            const content = readFileSync(join(catDir, mdFile), "utf-8");
+            const { name, description, body } = extractFrontmatter(content);
+            if (!name)
+                continue;
+            let slug = basename(mdFile, ".md");
+            const prefixMatch = slug.match(new RegExp(`^${cat.name}-`));
+            if (prefixMatch)
+                slug = slug.slice(prefixMatch[0].length);
+            if (!slug)
+                continue;
+            const destDir = join(skillsDir, `${sourcePrefix}--${slug}`);
+            mkdirSync(destDir, { recursive: true });
+            writeFileSync(join(destDir, "SKILL.md"), `---\nname: ${name}\ndescription: ${description}\nsource: community\nsource_name: ${sourcePrefix}\nattribution: |\n  Originally from ${sourceUrl}\n  License: ${license || "unknown"}\n---\n\n${body}\n`);
+            count++;
+        }
+    }
+    return count;
+}
+export async function skillInstallCommand(sourceArg, options) {
+    const registry = getRegistry();
+    const skillsDir = join(process.cwd(), ".opencode", "skills");
+    if (!sourceArg) {
+        console.log("\n  Recommended Starter Packs");
+        console.log("  ────────────────────────\n");
+        console.log("  Minimal Viable Power (3 sources):");
+        console.log("    npx 0xray skill:install superpowers");
+        console.log("    npx 0xray skill:install anthropic-skills");
+        console.log("    npx 0xray skill:install ui-ux-pro-max");
+        console.log("    → 80% of daily gains for most devs\n");
+        console.log("  Full Pro Setup (5 sources):");
+        console.log("    npx 0xray skill:install superpowers");
+        console.log("    npx 0xray skill:install anthropic-skills");
+        console.log("    npx 0xray skill:install antigravity");
+        console.log("    npx 0xray skill:install impeccable");
+        console.log("    npx 0xray skill:install ui-ux-pro-max");
+        console.log("    → The current meta for power users\n");
+        console.log("  Agency / Team Mode (4 sources):");
+        console.log("    npx 0xray skill:install agency-agents");
+        console.log("    npx 0xray skill:install superpowers");
+        console.log("    npx 0xray skill:install antigravity");
+        console.log("    npx 0xray skill:install ui-ux-pro-max");
+        console.log();
+        console.log("  Add specialized sources as needed:");
+        console.log("    Web3    → npx 0xray skill:install ai-web3-security");
+        console.log("    Vue     → npx 0xray skill:install vuejs-nuxt");
+        console.log("    Gemini  → npx 0xray skill:install gemini-skills");
+        console.log("    MiniMax → npx 0xray skill:install minimax");
+        console.log();
+        console.log("  Re-install to update community skills:");
+        console.log("    npx 0xray skill:install <source-name>   # removes old, installs fresh");
+        console.log();
+        console.log("  Available sources:\n");
+        for (const s of registry.sources) {
+            const installed = existsSync(join(skillsDir, `${s.name}--`));
+            console.log(`    ${s.name.padEnd(22)} [${installed ? "installed" : "available"}] ${s.license ? `(${s.license})` : ""}`);
+            console.log(`    ${"".padEnd(22)} ${s.url}`);
+            if (s.description)
+                console.log(`    ${"".padEnd(22)} ${s.description}`);
+            console.log();
+        }
+        console.log("  Usage:");
+        console.log("    npx 0xray skill:install <source-name>");
+        console.log("    npx 0xray skill:install <github-url>");
+        console.log("    npx 0xray skill:install <url> --path <subdir>");
+        console.log();
+        console.log("  Community skills are namespaced (e.g., agency-agents--code-review)");
+        console.log("  Framework skills are never overwritten.");
+        console.log("  Re-installing a source refreshes all its skills.");
+        return;
+    }
+    const source = findSource(sourceArg);
+    const url = source?.url || sourceArg;
+    const license = source?.license || "unknown";
+    const sourcePrefix = resolveSourcePrefix(sourceArg, source);
+    mkdirSync(skillsDir, { recursive: true });
+    const removed = cleanSourceSkills(skillsDir, sourcePrefix);
+    if (removed > 0) {
+        console.log(`  Removed ${removed} existing skills from ${sourcePrefix} (re-install)`);
+    }
+    const tmpDir = join(process.cwd(), ".opencode", "_tmp", "install");
+    console.log(`  Downloading ${url}...`);
+    const repoDir = cloneRepo(url, tmpDir);
+    const searchDir = options?.path ? join(repoDir, options.path) : repoDir;
+    const { format, root } = detectFormat(searchDir);
+    let count = 0;
+    if (format === "skill-folders") {
+        count = installSkillFolders(root, skillsDir, sourcePrefix, url, license);
+    }
+    else if (format === "flat-md") {
+        count = installFlatMd(root, skillsDir, sourcePrefix, url, license);
+    }
+    else if (format === "single-md") {
+        console.log("  Note: This repo uses CLAUDE.md format (tool/package), not SKILL.md format.");
+        console.log("  Skipping installation - consider installing via the project's native CLI.");
+        count = 0;
+    }
+    else {
+        console.log("  Could not detect skill format. Looking for SKILL.md folders at root...");
+        count = installSkillFolders(searchDir, skillsDir, sourcePrefix, url, license);
+        if (count === 0) {
+            count = installFlatMd(searchDir, skillsDir, sourcePrefix, url, license);
+        }
+    }
+    execSync(`rm -rf "${tmpDir}"`, { stdio: "pipe" });
+    console.log(`  Installed ${count} skills (${format}) → .opencode/skills/${sourcePrefix}--*/`);
+    if (removed > 0) {
+        console.log(`  (refreshed: ${removed} removed, ${count} installed)`);
+    }
+    const total = readdirSync(skillsDir).filter((d) => existsSync(join(skillsDir, d, "SKILL.md"))).length;
+    console.log(`  Total skills available: ${total}`);
+}
+export async function skillRegistryCommand(action, args) {
+    if (!action || action === "list") {
+        const registry = getRegistry();
+        const localPath = getLocalRegistryPath();
+        const localNames = existsSync(localPath)
+            ? new Set(JSON.parse(readFileSync(localPath, "utf-8")).sources.map((s) => s.name))
+            : new Set();
+        console.log("\n  Skills Registry\n  ===============\n");
+        if (registry.sources.length === 0) {
+            console.log("  No sources.\n");
+            return;
+        }
+        for (const s of registry.sources) {
+            const origin = localNames.has(s.name) ? "local" : "bundled";
+            console.log(`    ${s.name.padEnd(22)} [${origin}] ${s.license ? `(${s.license})` : ""}`);
+            console.log(`    ${"".padEnd(22)} ${s.url}`);
+            if (s.description)
+                console.log(`    ${"".padEnd(22)} ${s.description}`);
+            console.log();
+        }
+        return;
+    }
+    if (action === "add") {
+        const name = args?.name;
+        const url = args?.url;
+        if (!name || !url) {
+            console.log("\n  Usage: npx 0xray skill:registry add --name <name> --url <url>\n");
+            console.log("  Options:");
+            console.log("    --name <name>          Unique source name");
+            console.log("    --url <github-url>     Repository URL");
+            console.log("    --desc <description>   Short description");
+            console.log("    --license <license>    License (e.g. MIT, Apache-2.0)");
+            return;
+        }
+        const localPath = getLocalRegistryPath();
+        let existing = { sources: [] };
+        if (existsSync(localPath)) {
+            existing = JSON.parse(readFileSync(localPath, "utf-8"));
+        }
+        const src = {
+            name,
+            url,
+            description: args?.desc || args?.description,
+            license: args?.license,
+        };
+        const idx = existing.sources.findIndex((s) => s.name === name);
+        if (idx >= 0) {
+            existing.sources[idx] = src;
+            console.log(`  Updated: ${name}`);
+        }
+        else {
+            existing.sources.push(src);
+            console.log(`  Added: ${name}`);
+        }
+        mkdirSync(dirname(localPath), { recursive: true });
+        writeFileSync(localPath, JSON.stringify(existing, null, 2) + "\n");
+        console.log(`  Saved to ${localPath}`);
+        return;
+    }
+    if (action === "remove") {
+        const name = args?.name || args?.["_"]?.[0];
+        if (!name) {
+            console.log("  Usage: npx 0xray skill:registry remove --name <name>");
+            return;
+        }
+        const localPath = getLocalRegistryPath();
+        if (!existsSync(localPath)) {
+            console.log(`  "${name}" not found in local registry.`);
+            return;
+        }
+        const existing = JSON.parse(readFileSync(localPath, "utf-8"));
+        const idx = existing.sources.findIndex((s) => s.name === name);
+        if (idx < 0) {
+            console.log(`  "${name}" not found in local registry.`);
+            return;
+        }
+        existing.sources.splice(idx, 1);
+        writeFileSync(localPath, JSON.stringify(existing, null, 2) + "\n");
+        console.log(`  Removed: ${name}`);
+        return;
+    }
+    console.log(`  Unknown action: ${action}`);
+    console.log("  Usage: npx 0xray skill:registry [list|add|remove]");
+}

package/dist/cli/commands/status.js

@@ -0,0 +1,196 @@
+/**
+ * Status CLI Command
+ *
+ * Shows comprehensive framework status including:
+ * - OpenCode installation status
+ * - Installed skills
+ * - Configured agents
+ * - Health metrics
+ * - Inference engine status
+ *
+ * Usage: npx 0xray status
+ */
+import { readdirSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { getConfigDir } from "../../core/config-paths.js";
+function getSkillsList(cwd) {
+    const skills = [];
+    const configDir = getConfigDir(cwd);
+    const integrationsPath = join(configDir, "integrations");
+    if (existsSync(integrationsPath)) {
+        const integrationDirs = readdirSync(integrationsPath).filter((f) => existsSync(join(integrationsPath, f, "SKILL.md")));
+        skills.push(...integrationDirs);
+    }
+    const skillsPath = join(configDir, "skills");
+    if (existsSync(skillsPath)) {
+        const skillDirs = readdirSync(skillsPath).filter((f) => existsSync(join(skillsPath, f, "SKILL.md")));
+        skills.push(...skillDirs);
+    }
+    const uniqueSkills = [...new Set(skills)];
+    return { count: uniqueSkills.length, names: uniqueSkills.sort() };
+}
+function getAgentsList(cwd) {
+    const agentsFromSkills = [
+        "architect",
+        "security-auditor",
+        "code-reviewer",
+        "refactorer",
+        "testing-lead",
+        "bug-triage-specialist",
+        "researcher",
+    ];
+    const configuredAgents = [];
+    const configDir = getConfigDir(cwd);
+    const agentsConfigPath = join(configDir, "strray", "agents.json");
+    if (existsSync(agentsConfigPath)) {
+        try {
+            const config = JSON.parse(readFileSync(agentsConfigPath, "utf-8"));
+            if (config.agents) {
+                configuredAgents.push(...Object.keys(config.agents));
+            }
+        }
+        catch { /* ignore */ }
+    }
+    const featuresPath = join(configDir, "strray", "features.json");
+    if (existsSync(featuresPath)) {
+        try {
+            const features = JSON.parse(readFileSync(featuresPath, "utf-8"));
+            if (features.agent_management?.disabled_agents) {
+                const disabled = features.agent_management.disabled_agents;
+                agentsFromSkills.forEach((agent) => {
+                    if (!disabled.includes(agent) && !configuredAgents.includes(agent)) {
+                        configuredAgents.push(agent);
+                    }
+                });
+            }
+        }
+        catch { /* ignore */ }
+    }
+    if (configuredAgents.length === 0) {
+        configuredAgents.push(...agentsFromSkills);
+    }
+    return {
+        count: configuredAgents.length,
+        names: [...new Set(configuredAgents)].sort(),
+    };
+}
+function getHealthMetrics(cwd) {
+    const logPath = join(cwd, "logs", "framework", "activity.log");
+    const logExists = existsSync(logPath);
+    let recentEntries = 0;
+    if (logExists) {
+        try {
+            const content = readFileSync(logPath, "utf-8");
+            recentEntries = content.split("\n").filter((l) => l.trim()).length;
+        }
+        catch { /* ignore */ }
+    }
+    return { logPath, logExists, recentEntries };
+}
+function getInferenceStatus(cwd) {
+    let active = false;
+    let lastTuning = null;
+    let outcomesCount = 0;
+    let patternsCount = 0;
+    try {
+        const inferenceDir = join(getConfigDir(cwd), "strray", "inference");
+        const tunerStatusPath = join(inferenceDir, "tuner-status.json");
+        if (existsSync(tunerStatusPath)) {
+            const status = JSON.parse(readFileSync(tunerStatusPath, "utf-8"));
+            active = status.running ?? false;
+            lastTuning = status.lastTuningTime
+                ? new Date(status.lastTuningTime).toISOString()
+                : null;
+        }
+        const outcomesPath = join(inferenceDir, "outcomes.json");
+        if (existsSync(outcomesPath)) {
+            const outcomes = JSON.parse(readFileSync(outcomesPath, "utf-8"));
+            outcomesCount = Array.isArray(outcomes) ? outcomes.length : 0;
+        }
+        const patternsPath = join(inferenceDir, "patterns.json");
+        if (existsSync(patternsPath)) {
+            const patterns = JSON.parse(readFileSync(patternsPath, "utf-8"));
+            patternsCount = Array.isArray(patterns) ? patterns.length : 0;
+        }
+    }
+    catch { /* ignore */ }
+    return { active, lastTuning, outcomesCount, patternsCount };
+}
+export function getStatusReport(cwd = process.cwd()) {
+    const opencodeConfigPath = join(cwd, "opencode.json");
+    const cwdSkills = getSkillsList(cwd);
+    const agents = getAgentsList(cwd);
+    const health = getHealthMetrics(cwd);
+    const inference = getInferenceStatus(cwd);
+    return {
+        opencode: {
+            installed: existsSync(join(cwd, "node_modules", "0xray")),
+            configFound: existsSync(opencodeConfigPath) || existsSync(join(cwd, ".opencode", "enforcer-config.json")),
+        },
+        skills: cwdSkills,
+        agents,
+        health,
+        inference,
+    };
+}
+export function printStatus(report) {
+    const opencodeStatus = report.opencode.installed
+        ? "✅ Installed"
+        : "⚠️  Not installed locally";
+    const configStatus = report.opencode.configFound
+        ? "✅ Found"
+        : report.opencode.installed
+            ? "⚠️  Optional for consumers"
+            : "❌ Missing";
+    const logStatus = report.health.logExists
+        ? `✅ ${report.health.recentEntries} entries`
+        : "⚠️  No activity log";
+    const inferenceStatus = report.inference.active ? "✅ Active" : "⚠️  Idle";
+    const healthStatus = report.health.recentEntries > 100
+        ? "Good"
+        : report.health.recentEntries > 0
+            ? "Fair"
+            : "No data";
+    console.log("");
+    console.log("╔══════════════════════════════════════════════════╗");
+    console.log("║           xray Status                       ║");
+    console.log("╚══════════════════════════════════════════════════╝");
+    console.log("");
+    console.log(`✅ OpenCode: ${opencodeStatus}`);
+    console.log(`📄 Config:  ${configStatus}`);
+    console.log(`📦 Skills:  ${report.skills.count} loaded`);
+    console.log(`🤖 Agents:  ${report.agents.count} configured`);
+    console.log(`⚙️  Inference: ${inferenceStatus} (${report.inference.outcomesCount} outcomes, ${report.inference.patternsCount} patterns)`);
+    console.log(`📊 Health:  ${healthStatus}`);
+    console.log("");
+    if (report.skills.names.length > 0) {
+        console.log("Installed Skills:");
+        const cols = 4;
+        const rows = Math.ceil(report.skills.names.length / cols);
+        for (let i = 0; i < rows; i++) {
+            const row = report.skills.names.slice(i * cols, (i + 1) * cols);
+            console.log("  " + row.map((s) => `• ${s}`).join("  "));
+        }
+        console.log("");
+    }
+    if (report.agents.names.length > 0) {
+        console.log("Agents:");
+        const cols = 4;
+        const rows = Math.ceil(report.agents.names.length / cols);
+        for (let i = 0; i < rows; i++) {
+            const row = report.agents.names.slice(i * cols, (i + 1) * cols);
+            console.log("  " + row.map((a) => `• ${a}`).join("  "));
+        }
+        console.log("");
+    }
+    if (report.inference.lastTuning) {
+        console.log(`Last tuning: ${report.inference.lastTuning}`);
+        console.log("");
+    }
+}
+export async function statusCommand() {
+    const cwd = process.cwd();
+    const report = getStatusReport(cwd);
+    printStatus(report);
+}
+export default statusCommand;