@creativeintelligence/abbie 0.1.6 → 0.1.8

package/dist/cli/commands/windows/context.js

@@ -1,326 +0,0 @@
-import { Flags } from "@oclif/core";
-import { getBufferLines, getCurrentBufferInfo, getVisibleRange } from "../../../lib/nvim/remote.js";
-import { isRunning } from "../../../lib/tmux/index.js";
-import { redactContent } from "../../../lib/tmux/redaction.js";
-import * as windows from "../../../lib/windows/index.js";
-import { BaseCommand } from "../../base-command.js";
-function abbreviateHome(path) {
-    const home = process.env.HOME;
-    if (!home)
-        return path;
-    if (path === home)
-        return "~";
-    if (path.startsWith(`${home}/`))
-        return `~/${path.slice(home.length + 1)}`;
-    return path;
-}
-function paneRef(window) {
-    return `${window.session}:${window.window}.${window.pane}`;
-}
-function formatPathForDisplay(path, cwd) {
-    if (!path)
-        return path;
-    const normalizedCwd = cwd.endsWith("/") ? cwd : `${cwd}/`;
-    if (path.startsWith(normalizedCwd)) {
-        return path.slice(normalizedCwd.length);
-    }
-    return abbreviateHome(path);
-}
-function escapeXml(str) {
-    return str
-        .replace(/&/g, "&")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;")
-        .replace(/"/g, "&quot;")
-        .replace(/'/g, "&apos;");
-}
-function truncateToBytes(str, maxBytes) {
-    const buf = Buffer.from(str, "utf-8");
-    if (buf.length <= maxBytes) {
-        return str;
-    }
-    let low = 0;
-    let high = str.length;
-    while (low < high) {
-        const mid = Math.ceil((low + high) / 2);
-        const slice = str.slice(0, mid);
-        if (Buffer.byteLength(slice, "utf-8") <= maxBytes) {
-            low = mid;
-        }
-        else {
-            high = mid - 1;
-        }
-    }
-    return str.slice(0, low);
-}
-function bytesForLine(line) {
-    return Buffer.byteLength(`${line}\n`, "utf-8");
-}
-function buildWindowXmlLines(w, maxBytes) {
-    const baseLines = [];
-    baseLines.push(`  <window id="${escapeXml(w.id)}" session="${escapeXml(w.session)}" window="${w.window}" pane="${w.pane}" active="${w.active}">`);
-    baseLines.push(`    <cwd>${escapeXml(w.cwd)}</cwd>`);
-    baseLines.push(`    <cmd>${escapeXml(w.cmd)}</cmd>`);
-    if (w.nvim) {
-        const attrs = [
-            `available="${w.nvim.available}"`,
-            w.nvim.pid !== null ? `pid="${w.nvim.pid}"` : null,
-            w.nvim.server ? `server="${escapeXml(w.nvim.server)}"` : null,
-            w.nvim.discoveryMethod ? `discovery="${w.nvim.discoveryMethod}"` : null,
-        ].filter(Boolean);
-        baseLines.push(`    <nvim ${attrs.join(" ")}>`);
-        if (w.nvim.buffer) {
-            const bufAttrs = [
-                `path="${escapeXml(w.nvim.buffer.path)}"`,
-                `filetype="${escapeXml(w.nvim.buffer.filetype)}"`,
-                `modified="${w.nvim.buffer.modified}"`,
-                w.nvim.buffer.cursor ? `cursor="${escapeXml(w.nvim.buffer.cursor)}"` : null,
-            ].filter(Boolean);
-            baseLines.push(`      <buffer ${bufAttrs.join(" ")} />`);
-        }
-        baseLines.push("    </nvim>");
-    }
-    if (w.agent) {
-        const attrs = [
-            `type="${w.agent.type}"`,
-            `pid="${w.agent.pid}"`,
-            w.agent.sessionId ? `session="${escapeXml(w.agent.sessionId)}"` : null,
-            w.agent.issue ? `issue="${escapeXml(w.agent.issue)}"` : null,
-        ].filter(Boolean);
-        baseLines.push(`    <agent ${attrs.join(" ")} />`);
-    }
-    baseLines.push("  </window>");
-    const baseBytes = baseLines.reduce((sum, line) => sum + bytesForLine(line), 0);
-    if (baseBytes > maxBytes)
-        return null;
-    const excerpt = w.nvim?.excerpt;
-    if (!excerpt || excerpt.lines.length === 0) {
-        return { lines: baseLines, truncated: false };
-    }
-    const insertAt = baseLines.indexOf("    </nvim>");
-    if (insertAt === -1) {
-        return { lines: baseLines, truncated: false };
-    }
-    const excerptOpen = `      <excerpt scope="${excerpt.scope}" start_line="${excerpt.startLine}" end_line="${excerpt.endLine}" redacted="${excerpt.redacted}">`;
-    const excerptClose = "      </excerpt>";
-    const skeleton = [...baseLines];
-    skeleton.splice(insertAt, 0, excerptOpen, excerptClose);
-    const skeletonBytes = skeleton.reduce((sum, line) => sum + bytesForLine(line), 0);
-    if (skeletonBytes > maxBytes) {
-        return { lines: baseLines, truncated: true };
-    }
-    const remainingForContent = maxBytes - skeletonBytes;
-    const contentLines = [];
-    let used = 0;
-    let truncated = false;
-    for (const rawLine of excerpt.lines) {
-        const escaped = escapeXml(rawLine);
-        const line = `        ${escaped}`;
-        const lineBytes = bytesForLine(line);
-        if (used + lineBytes <= remainingForContent) {
-            contentLines.push(line);
-            used += lineBytes;
-            continue;
-        }
-        const remaining = remainingForContent - used;
-        const indentBytes = bytesForLine("        ");
-        if (remaining > indentBytes + 8) {
-            const availableForContent = remaining - indentBytes;
-            const clipped = truncateToBytes(escaped, Math.max(0, availableForContent));
-            contentLines.push(`        ${clipped}`);
-        }
-        truncated = true;
-        break;
-    }
-    const finalLines = [...baseLines];
-    finalLines.splice(insertAt, 0, excerptOpen, ...contentLines, excerptClose);
-    return { lines: finalLines, truncated };
-}
-function toXml(context, maxBytes) {
-    const lines = [];
-    let bytes = 0;
-    let truncated = false;
-    const closeRoot = "</workspace_context>";
-    const closeRootBytes = bytesForLine(closeRoot);
-    const root = `<workspace_context generated_at="${escapeXml(context.generatedAt)}" tmux_running="${context.tmuxRunning}">`;
-    lines.push(root);
-    bytes += bytesForLine(root);
-    for (const w of context.windows) {
-        const remaining = maxBytes - bytes - closeRootBytes;
-        if (remaining <= 0) {
-            truncated = true;
-            break;
-        }
-        const built = buildWindowXmlLines(w, remaining);
-        if (!built) {
-            truncated = true;
-            break;
-        }
-        const windowBytes = built.lines.reduce((sum, line) => sum + bytesForLine(line), 0);
-        if (bytes + windowBytes + closeRootBytes > maxBytes) {
-            truncated = true;
-            break;
-        }
-        lines.push(...built.lines);
-        bytes += windowBytes;
-        if (built.truncated) {
-            truncated = true;
-        }
-    }
-    lines.push(closeRoot);
-    return { xml: lines.join("\n"), truncated };
-}
-export default class WindowsContextCommand extends BaseCommand {
-    static summary = "Generate workspace context from windows inventory";
-    static hidden = false;
-    static examples = [
-        "$ abbie windows context",
-        "$ abbie windows context --focus",
-        "$ abbie windows context --json",
-        "$ abbie windows context --no-with-buffers",
-        "$ abbie windows context --max-bytes 100000",
-        "$ abbie windows context --no-redact",
-    ];
-    static flags = {
-        ...BaseCommand.baseFlags,
-        focus: Flags.boolean({
-            description: "Only include the focused window",
-            default: false,
-        }),
-        "with-buffers": Flags.boolean({
-            description: "Include buffer excerpts (visible range)",
-            default: true,
-            allowNo: true,
-        }),
-        "max-bytes": Flags.integer({
-            description: "Maximum output size in bytes",
-            default: 200000,
-        }),
-        redact: Flags.boolean({
-            description: "Enable redaction",
-            default: true,
-            allowNo: true,
-        }),
-    };
-    async execute() {
-        const { flags } = await this.parse(WindowsContextCommand);
-        this.parsedFlags = flags;
-        const generatedAt = new Date().toISOString();
-        const tmuxRunning = await isRunning();
-        if (!tmuxRunning) {
-            const context = {
-                generatedAt,
-                tmuxRunning: false,
-                truncated: false,
-                windows: [],
-            };
-            if (this.jsonEnabled?.()) {
-                return context;
-            }
-            const xml = toXml(context, flags["max-bytes"]);
-            context.truncated = xml.truncated;
-            const output = flags.format === "json" ? JSON.stringify(context, null, 2) : xml.xml;
-            this.log(output);
-            return context;
-        }
-        let states = await windows.inventory({
-            includeNvim: true,
-            includeAgent: true,
-            includeBuffers: false,
-        });
-        // Filter to focused window if requested
-        if (flags.focus) {
-            const focused = await windows.getFocusedWindow({ includeNvim: true, includeAgent: true });
-            states = focused ? [focused] : [];
-        }
-        const sorted = states.sort((a, b) => {
-            if (a.window.session !== b.window.session)
-                return a.window.session.localeCompare(b.window.session);
-            if (a.window.window !== b.window.window)
-                return a.window.window - b.window.window;
-            return a.window.pane - b.window.pane;
-        });
-        const ctxWindows = [];
-        for (const state of sorted) {
-            const id = state.window.paneId || paneRef(state.window);
-            const ref = paneRef(state.window);
-            let buffer = null;
-            let excerpt = null;
-            if (state.nvim?.available && state.nvim.serverAddr) {
-                const info = await getCurrentBufferInfo(state.nvim.serverAddr);
-                if (info) {
-                    const cursor = info.cursor ? `${info.cursor.line}:${info.cursor.col}` : null;
-                    buffer = {
-                        path: formatPathForDisplay(info.name, state.window.cwd),
-                        filetype: info.filetype,
-                        modified: info.modified,
-                        cursor,
-                    };
-                    if (flags["with-buffers"]) {
-                        const visible = await getVisibleRange(state.nvim.serverAddr, info.bufnr);
-                        if (visible) {
-                            const raw = await getBufferLines(state.nvim.serverAddr, info.bufnr, visible.topLine, visible.bottomLine);
-                            if (raw) {
-                                const joined = raw.join("\n");
-                                const redaction = flags.redact
-                                    ? redactContent(joined, "balanced")
-                                    : { content: joined, wasRedacted: false };
-                                const lines = redaction.content.split("\n");
-                                excerpt = {
-                                    scope: "visible",
-                                    startLine: visible.topLine,
-                                    endLine: visible.bottomLine,
-                                    redacted: flags.redact && redaction.wasRedacted,
-                                    lines,
-                                };
-                            }
-                        }
-                    }
-                }
-            }
-            ctxWindows.push({
-                id,
-                ref,
-                session: state.window.session,
-                window: state.window.window,
-                windowName: state.window.windowName,
-                pane: state.window.pane,
-                active: state.window.active,
-                cwd: abbreviateHome(state.window.cwd),
-                cmd: state.window.title,
-                nvim: state.nvim
-                    ? {
-                        available: state.nvim.available,
-                        pid: state.nvim.pid,
-                        server: state.nvim.serverAddr,
-                        discoveryMethod: state.nvim.discoveryMethod,
-                        buffer,
-                        excerpt,
-                    }
-                    : null,
-                agent: state.agent
-                    ? {
-                        type: state.agent.type,
-                        pid: state.agent.pid,
-                        sessionId: state.agent.sessionId,
-                        issue: state.agent.issue,
-                    }
-                    : null,
-            });
-        }
-        const context = {
-            generatedAt,
-            tmuxRunning: true,
-            truncated: false,
-            windows: ctxWindows,
-        };
-        if (this.jsonEnabled?.()) {
-            return context;
-        }
-        const xml = toXml(context, flags["max-bytes"]);
-        context.truncated = xml.truncated;
-        const output = flags.format === "json" ? JSON.stringify(context, null, 2) : xml.xml;
-        this.log(output);
-        return context;
-    }
-}

package/dist/cli/commands/windows/focus.d.ts

@@ -1,17 +0,0 @@
-import { BaseCommand } from "../../base-command.js";
-export default class WindowsFocusCommand extends BaseCommand {
-    static summary: string;
-    static hidden: boolean;
-    static examples: string[];
-    static flags: {
-        "with-nvim": import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        "with-buffers": import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-    };
-    execute(): Promise<unknown>;
-    private printText;
-}
-//# sourceMappingURL=focus.d.ts.map

package/dist/cli/commands/windows/focus.js

@@ -1,103 +0,0 @@
-import { Flags } from "@oclif/core";
-import { isRunning } from "../../../lib/tmux/index.js";
-import * as windows from "../../../lib/windows/index.js";
-import { BaseCommand } from "../../base-command.js";
-function abbreviateHome(path) {
-    const home = process.env.HOME;
-    if (!home)
-        return path;
-    if (path === home)
-        return "~";
-    if (path.startsWith(`${home}/`))
-        return `~/${path.slice(home.length + 1)}`;
-    return path;
-}
-function windowLabel(window) {
-    return `${window.window}:${window.windowName}`;
-}
-export default class WindowsFocusCommand extends BaseCommand {
-    static summary = "Show focused window";
-    static hidden = false;
-    static examples = [
-        "$ abbie windows focus",
-        "$ abbie windows focus --no-with-nvim",
-        "$ abbie windows focus --with-buffers",
-        "$ abbie windows focus --json",
-    ];
-    static flags = {
-        ...BaseCommand.baseFlags,
-        "with-nvim": Flags.boolean({
-            description: "Include nvim details",
-            default: true,
-            allowNo: true,
-        }),
-        "with-buffers": Flags.boolean({
-            description: "Include buffer list",
-            default: false,
-        }),
-    };
-    async execute() {
-        const { flags } = await this.parse(WindowsFocusCommand);
-        this.parsedFlags = flags;
-        const tmuxRunning = await isRunning();
-        if (!tmuxRunning) {
-            const result = { tmuxRunning: false, window: null };
-            if (!this.jsonEnabled?.()) {
-                this.log("tmux is not running");
-            }
-            return result;
-        }
-        const includeNvim = flags["with-nvim"] || flags["with-buffers"];
-        const includeBuffers = flags["with-buffers"];
-        const state = await windows.getFocusedWindow({
-            includeNvim,
-            includeAgent: true,
-            includeBuffers,
-        });
-        const result = { tmuxRunning: true, window: state };
-        if (!this.jsonEnabled?.()) {
-            this.printText(result, flags);
-        }
-        return result;
-    }
-    printText(result, flags) {
-        if (!result.window) {
-            this.log("No focused window");
-            return;
-        }
-        const { window, nvim, agent, buffers } = result.window;
-        this.log("FOCUSED WINDOW");
-        this.log(`Session: ${window.session}`);
-        this.log(`Window:  ${windowLabel(window)}`);
-        this.log(`Pane:    ${window.paneId || `${window.pane}`} (${window.active ? "active" : "inactive"})`);
-        this.log(`CWD:     ${abbreviateHome(window.cwd)}`);
-        this.log(`CMD:     ${window.title}`);
-        if (agent) {
-            this.log(`Agent:   ${agent.type} (pid: ${agent.pid}${agent.sessionId ? `, session: ${agent.sessionId}` : ""})`);
-        }
-        if (flags["with-nvim"]) {
-            this.log("");
-            this.log("NVIM");
-            if (nvim?.available) {
-                this.log(`PID:     ${nvim.pid ?? "-"}`);
-                this.log(`Server:  ${nvim.serverAddr ?? "-"}${nvim.discoveryMethod ? ` (${nvim.discoveryMethod})` : ""}`);
-            }
-            else {
-                this.log("Not available");
-            }
-        }
-        if (flags["with-buffers"]) {
-            this.log("");
-            this.log("BUFFERS");
-            if (buffers.length === 0) {
-                this.log("No buffers");
-            }
-            else {
-                for (const buf of buffers) {
-                    const mod = buf.modified ? " [modified]" : "";
-                    this.log(`- ${buf.name || buf.path} (${buf.filetype || "unknown"})${mod}`);
-                }
-            }
-        }
-    }
-}

package/dist/cli/commands/windows/list.d.ts

@@ -1,21 +0,0 @@
-import { BaseCommand } from "../../base-command.js";
-export default class WindowsListCommand extends BaseCommand {
-    static summary: string;
-    static hidden: boolean;
-    static examples: string[];
-    static flags: {
-        session: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        active: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        "with-nvim": import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        "with-agent": import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        sync: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-    };
-    execute(): Promise<unknown>;
-    private syncToConvex;
-    private printText;
-}
-//# sourceMappingURL=list.d.ts.map

package/dist/cli/commands/windows/list.js

@@ -1,172 +0,0 @@
-import { api, getHttpClient, isConvexConfigured } from "@creativeintelligence/sdk/convex";
-import { Flags } from "@oclif/core";
-import { getDeviceId } from "../../../lib/device.js";
-import { isRunning } from "../../../lib/tmux/index.js";
-import * as windows from "../../../lib/windows/index.js";
-import { BaseCommand } from "../../base-command.js";
-function abbreviateHome(path) {
-    const home = process.env.HOME;
-    if (!home)
-        return path;
-    if (path === home)
-        return "~";
-    if (path.startsWith(`${home}/`))
-        return `~/${path.slice(home.length + 1)}`;
-    return path;
-}
-function paneRef(window) {
-    return `${window.session}:${window.window}.${window.pane}`;
-}
-function windowLabel(window) {
-    return `${window.window}:${window.windowName}`;
-}
-function pad(value, width) {
-    if (value.length >= width)
-        return value;
-    return value + " ".repeat(width - value.length);
-}
-function formatRow(state) {
-    const id = state.window.paneId || paneRef(state.window);
-    return {
-        id,
-        session: state.window.session,
-        window: windowLabel(state.window),
-        cmd: state.window.title,
-        cwd: abbreviateHome(state.window.cwd),
-        nvim: state.nvim?.available ? "✓" : "-",
-        agent: state.agent?.type ?? "-",
-    };
-}
-export default class WindowsListCommand extends BaseCommand {
-    static summary = "List workspace windows (tmux panes)";
-    static hidden = false;
-    static examples = [
-        "$ abbie windows list",
-        "$ abbie windows list --session work",
-        "$ abbie windows list --active",
-        "$ abbie windows list --no-with-nvim",
-        "$ abbie windows list --no-with-agent",
-        "$ abbie windows list --sync",
-        "$ abbie windows list --json",
-    ];
-    static flags = {
-        ...BaseCommand.baseFlags,
-        session: Flags.string({
-            char: "s",
-            description: "Filter to specific tmux session",
-        }),
-        active: Flags.boolean({
-            description: "Only show active panes",
-            default: false,
-        }),
-        "with-nvim": Flags.boolean({
-            description: "Include nvim state",
-            default: true,
-            allowNo: true,
-        }),
-        "with-agent": Flags.boolean({
-            description: "Include agent detection",
-            default: true,
-            allowNo: true,
-        }),
-        sync: Flags.boolean({
-            description: "Sync windows to Convex for cross-device visibility",
-            default: false,
-        }),
-    };
-    async execute() {
-        const { flags } = await this.parse(WindowsListCommand);
-        this.parsedFlags = flags;
-        const tmuxRunning = await isRunning();
-        if (!tmuxRunning) {
-            const result = { tmuxRunning: false, windows: [] };
-            if (!this.jsonEnabled?.()) {
-                this.log("tmux is not running");
-            }
-            return result;
-        }
-        const states = await windows.inventory({
-            session: flags.session,
-            includeNvim: flags["with-nvim"],
-            includeAgent: flags["with-agent"],
-            includeBuffers: false,
-        });
-        const filtered = (flags.active ? states.filter((s) => s.window.active) : states).sort((a, b) => {
-            if (a.window.session !== b.window.session)
-                return a.window.session.localeCompare(b.window.session);
-            if (a.window.window !== b.window.window)
-                return a.window.window - b.window.window;
-            return a.window.pane - b.window.pane;
-        });
-        const result = { tmuxRunning: true, windows: filtered };
-        // Sync to Convex if requested
-        if (flags.sync) {
-            await this.syncToConvex(filtered);
-        }
-        if (!this.jsonEnabled?.()) {
-            this.printText(result);
-        }
-        return result;
-    }
-    async syncToConvex(states) {
-        if (!isConvexConfigured()) {
-            if (!this.jsonEnabled?.()) {
-                this.warn("Convex not configured, skipping sync");
-            }
-            return;
-        }
-        const deviceId = getDeviceId();
-        const windowData = states.map((state) => ({
-            paneId: state.window.paneId ||
-                `${state.window.session}:${state.window.window}.${state.window.pane}`,
-            tmuxSession: state.window.session,
-            windowIndex: state.window.window,
-            windowName: state.window.windowName,
-            paneIndex: state.window.pane,
-            cwd: state.window.cwd || "",
-            title: state.window.title || undefined,
-            isActive: state.window.active,
-            cols: state.window.size.cols,
-            rows: state.window.size.rows,
-            hasNvim: state.nvim?.available ?? false,
-            nvimPid: state.nvim?.pid ?? undefined,
-            nvimServerAddr: state.nvim?.serverAddr ?? undefined,
-            agentType: state.agent?.type ?? undefined,
-            agentPid: state.agent?.pid ?? undefined,
-        }));
-        try {
-            const client = getHttpClient();
-            const syncResult = await client.mutation(api.windows.sync, {
-                deviceId,
-                windows: windowData,
-            });
-            if (!this.jsonEnabled?.()) {
-                this.log(`Synced ${syncResult.synced} windows to Convex`);
-            }
-        }
-        catch (error) {
-            if (!this.jsonEnabled?.()) {
-                this.warn(`Failed to sync to Convex: ${error instanceof Error ? error.message : "Unknown error"}`);
-            }
-        }
-    }
-    printText(result) {
-        if (result.windows.length === 0) {
-            this.log("No windows found");
-            return;
-        }
-        const rows = result.windows.map(formatRow);
-        const widths = {
-            id: Math.max(2, ...rows.map((r) => r.id.length), "ID".length),
-            session: Math.max(2, ...rows.map((r) => r.session.length), "SESSION".length),
-            window: Math.max(2, ...rows.map((r) => r.window.length), "WINDOW".length),
-            cmd: Math.max(2, ...rows.map((r) => r.cmd.length), "CMD".length),
-            cwd: Math.max(2, ...rows.map((r) => r.cwd.length), "CWD".length),
-        };
-        this.log("WINDOWS");
-        this.log(`${pad("ID", widths.id)}  ${pad("SESSION", widths.session)}  ${pad("WINDOW", widths.window)}  ${pad("CMD", widths.cmd)}  ${pad("CWD", widths.cwd)}  NVIM  AGENT`);
-        for (const row of rows) {
-            this.log(`${pad(row.id, widths.id)}  ${pad(row.session, widths.session)}  ${pad(row.window, widths.window)}  ${pad(row.cmd, widths.cmd)}  ${pad(row.cwd, widths.cwd)}  ${pad(row.nvim, 4)}  ${row.agent}`);
-        }
-    }
-}

package/dist/cli/commands/windows/map.d.ts

@@ -1,17 +0,0 @@
-import { BaseCommand } from "../../base-command.js";
-export default class WindowsMapCommand extends BaseCommand {
-    static summary: string;
-    static hidden: boolean;
-    static examples: string[];
-    static flags: {
-        orphans: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        unmapped: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-    };
-    execute(): Promise<unknown>;
-    private printText;
-}
-//# sourceMappingURL=map.d.ts.map