0xray 4.0.13 → 4.0.15

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

@@ -0,0 +1,522 @@
+import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, cpSync, rmSync, statSync, unlinkSync, copyFileSync } from "fs";
+import { join, basename, dirname } from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+import { execSync } from "child_process";
+function getLocalRegistryPath() {
+    return join(process.cwd(), ".xray", "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]");
+}
+// ── Cross-platform builtin skill sync ────────────────────────────────
+// Each platform's install command calls this to copy framework skills.
+export function syncBuiltinSkills(targetSkillsDir, packageRoot) {
+    const root = packageRoot ?? join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+    const millSuit = createRequire(import.meta.url)(join(root, "scripts/foundry/mint-suit.cjs"));
+    if (!millSuit.wantsCostume(process.cwd()))
+        return 0;
+    const candidateDirs = [
+        join(root, "dist", "skills"),
+        join(root, "src", "skills"),
+    ];
+    const sourceDir = candidateDirs.find(existsSync);
+    if (!sourceDir)
+        return 0;
+    let copied = 0;
+    try {
+        if (!existsSync(targetSkillsDir))
+            mkdirSync(targetSkillsDir, { recursive: true });
+        for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const skillMd = join(sourceDir, entry.name, "SKILL.md");
+            if (!existsSync(skillMd))
+                continue;
+            const destMd = join(targetSkillsDir, entry.name, "SKILL.md");
+            const destDir = dirname(destMd);
+            if (!existsSync(destDir))
+                mkdirSync(destDir, { recursive: true });
+            if (existsSync(destMd) && statSync(skillMd).mtime <= statSync(destMd).mtime)
+                continue;
+            copyFileSync(skillMd, destMd);
+            copied++;
+        }
+    }
+    catch {
+        // best-effort
+    }
+    return copied;
+}

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

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