@creativeintelligence/abbie 0.1.0

package/dist/cli/commands/start.js

@@ -0,0 +1,228 @@
+/**
+ * abbie (default command) — the single entry point.
+ *
+ * First run:
+ *   1. Check Pi → not found → auto-install
+ *   2. Install Abbie Pi extension
+ *   3. Open browser for Clerk auth
+ *   4. Launch Pi (extension auto-starts bridge)
+ *
+ * Subsequent runs:
+ *   Launch Pi directly (extension handles bridge)
+ */
+import { existsSync, mkdirSync, cpSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync, spawn, execSync } from "node:child_process";
+import { Flags } from "@oclif/core";
+import { BaseCommand } from "../base-command.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PI_PACKAGE = "@mariozechner/pi-coding-agent";
+const ABBIE_HOME = join(homedir(), ".abbie");
+const PI_AGENT_DIR = join(homedir(), ".pi", "agent");
+const PI_EXT_DIR = join(PI_AGENT_DIR, "extensions", "abbie");
+function piInstalled() {
+    try {
+        const result = spawnSync("pi", ["--version"], { encoding: "utf8", timeout: 5000 });
+        if (result.status === 0 && result.stdout?.trim()) {
+            return { installed: true, version: result.stdout.trim(), path: "pi" };
+        }
+    }
+    catch { /* not found */ }
+    return { installed: false };
+}
+function abbieConfigured() {
+    const configPath = join(ABBIE_HOME, "config.json");
+    if (!existsSync(configPath))
+        return false;
+    try {
+        const cfg = JSON.parse(readFileSync(configPath, "utf8"));
+        return Boolean(cfg.clerkId || cfg.convexUrl);
+    }
+    catch {
+        return false;
+    }
+}
+function extensionInstalled() {
+    return existsSync(join(PI_EXT_DIR, "index.ts")) || existsSync(join(PI_EXT_DIR, "index.js"));
+}
+export default class DefaultCommand extends BaseCommand {
+    static id = "";
+    static summary = "Launch Abbie";
+    static description = `Start an agent session powered by Pi with cloud sync via Abbie.
+
+On first run, walks you through setup:
+  • Installs Pi (the coding agent runtime) if needed
+  • Installs the Abbie extension into Pi
+  • Authenticates with your Abbie account
+  • Launches Pi with the bridge auto-connected
+
+After setup, just run \`abbie\` to start working.`;
+    static examples = [
+        "$ abbie",
+        "$ abbie --setup",
+        "$ abbie --status",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        setup: Flags.boolean({
+            description: "Force re-run the setup wizard",
+            default: false,
+        }),
+        status: Flags.boolean({
+            description: "Show setup status and exit",
+            default: false,
+        }),
+    };
+    // Pass-through: any extra args go to pi
+    static strict = false;
+    async execute() {
+        const { flags, argv } = await this.parse(DefaultCommand);
+        this.parsedFlags = flags;
+        const pi = piInstalled();
+        const configured = abbieConfigured();
+        const extOk = extensionInstalled();
+        // --status: show state and exit
+        if (flags.status) {
+            this.log("");
+            this.log("  abbie status");
+            this.log("");
+            this.log(`  pi:        ${pi.installed ? `✓ ${pi.version}` : "✗ not installed"}`);
+            this.log(`  extension: ${extOk ? "✓ installed" : "✗ not installed"}`);
+            this.log(`  auth:      ${configured ? "✓ configured" : "✗ not configured"}`);
+            this.log("");
+            return { pi: pi.installed, extension: extOk, auth: configured };
+        }
+        // Setup needed?
+        const needsSetup = flags.setup || !pi.installed || !configured || !extOk;
+        if (needsSetup) {
+            await this.runSetup(pi, configured, extOk);
+            // Re-check after setup
+            const piNow = piInstalled();
+            if (!piNow.installed) {
+                this.error("Pi installation failed. Install manually:\n\n  npm install -g @mariozechner/pi-coding-agent\n");
+            }
+        }
+        // Launch Pi with any pass-through args
+        this.log("");
+        this.log("  launching pi...");
+        this.log("");
+        const piArgs = argv.length > 0 ? argv : [];
+        const child = spawn("pi", piArgs, {
+            stdio: "inherit",
+            env: process.env,
+            cwd: process.cwd(),
+        });
+        process.on("SIGINT", () => child.kill("SIGINT"));
+        process.on("SIGTERM", () => child.kill("SIGTERM"));
+        return new Promise((resolve) => {
+            child.on("exit", (code) => {
+                resolve({ exitCode: code ?? 0 });
+            });
+        });
+    }
+    async runSetup(pi, configured, extOk) {
+        this.log("");
+        this.log("  abbie setup");
+        this.log("  ──────────");
+        this.log("");
+        // Step 1: Install Pi
+        if (!pi.installed) {
+            this.log("  [1/3] installing pi...");
+            this.log(`         npm install -g ${PI_PACKAGE}`);
+            this.log("");
+            try {
+                execSync(`npm install -g ${PI_PACKAGE}`, {
+                    stdio: ["pipe", "pipe", "pipe"],
+                    encoding: "utf8",
+                    timeout: 120_000,
+                });
+                const check = piInstalled();
+                if (check.installed) {
+                    this.log(`  ✓ pi ${check.version} installed`);
+                }
+                else {
+                    this.error("Pi install completed but binary not found. Check your PATH.");
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                this.logWarn(`auto-install failed: ${msg}`);
+                this.log("");
+                this.log("  install manually:");
+                this.log(`  npm install -g ${PI_PACKAGE}`);
+                this.log("");
+                this.error("Pi is required to continue.");
+            }
+        }
+        else {
+            this.log(`  [1/3] pi ${pi.version} ✓`);
+        }
+        this.log("");
+        // Step 2: Install Abbie extension
+        if (!extOk) {
+            this.log("  [2/3] installing abbie extension...");
+            // Find the bundled extension
+            const extSource = this.findExtensionSource();
+            if (extSource) {
+                mkdirSync(PI_EXT_DIR, { recursive: true });
+                cpSync(extSource, PI_EXT_DIR, { recursive: true });
+                this.log("  ✓ extension installed");
+            }
+            else {
+                this.logWarn("extension source not found — the abbie tools won't be available in Pi");
+                this.logWarn("this is non-fatal; you can install it manually later");
+            }
+        }
+        else {
+            this.log("  [2/3] extension ✓");
+        }
+        this.log("");
+        // Step 3: Authenticate
+        if (!configured) {
+            this.log("  [3/3] authenticating...");
+            this.log("         opening browser for login...");
+            this.log("");
+            // Delegate to the login command
+            try {
+                await this.config.runCommand("login", []);
+            }
+            catch {
+                this.logWarn("login failed or was cancelled — you can run `abbie login` later");
+            }
+        }
+        else {
+            this.log("  [3/3] authenticated ✓");
+        }
+        this.log("");
+        this.log("  setup complete");
+        this.log("");
+        this.log("  tip: open Pi and type /login to connect an AI provider");
+        this.log("       (Anthropic, OpenAI, Google, or GitHub Copilot)");
+    }
+    /**
+     * Find the bundled extension source directory.
+     * Looks in several locations depending on how the CLI is installed.
+     */
+    findExtensionSource() {
+        const candidates = [
+            // When installed globally via npm — extension bundled in package
+            join(__dirname, "..", "..", "..", "extensions", "abbie"),
+            // When running from the monorepo
+            join(process.cwd(), "extensions", "abbie"),
+            // The canonical location (might already exist from manual setup)
+            join(homedir(), ".pi", "agent", "extensions", "abbie"),
+        ];
+        for (const candidate of candidates) {
+            if (existsSync(join(candidate, "index.ts")) || existsSync(join(candidate, "index.js"))) {
+                // Don't "find" the target as a source — that's circular
+                if (candidate === PI_EXT_DIR)
+                    continue;
+                return candidate;
+            }
+        }
+        return null;
+    }
+}

package/dist/cli/commands/state/dump.d.ts

@@ -0,0 +1,28 @@
+import { BaseCommand } from "../../base-command.js";
+export default class StateDump extends BaseCommand {
+    static description: string;
+    static hidden: boolean;
+    static examples: string[];
+    static flags: {
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        summary: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        include: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+    };
+    private getAgentsDir;
+    protected execute(): Promise<unknown>;
+    private shouldInclude;
+    private dumpEvents;
+    private dumpSessions;
+    private dumpResources;
+    private dumpBacklog;
+    private dumpTriage;
+    private dumpPlans;
+    private printSummary;
+    private printFull;
+    private getStatusIcon;
+}
+//# sourceMappingURL=dump.d.ts.map

package/dist/cli/commands/state/dump.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dump.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/state/dump.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AA2FpD,MAAM,CAAC,OAAO,OAAO,SAAU,SAAQ,WAAW;IAChD,OAAgB,WAAW,SAAqD;IAChF,OAAgB,MAAM,UAAS;IAE/B,OAAgB,QAAQ,WAKtB;IAEF,OAAgB,KAAK;;;;;;;;MAgBnB;IAEF,OAAO,CAAC,YAAY;cAKJ,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAkD3C,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,UAAU;IAoClB,OAAO,CAAC,YAAY;IAiBpB,OAAO,CAAC,aAAa;IA+BrB,OAAO,CAAC,WAAW;IAwCnB,OAAO,CAAC,UAAU;IA6BlB,OAAO,CAAC,SAAS;IAwBjB,OAAO,CAAC,YAAY;IAiBpB,OAAO,CAAC,SAAS;IAsDjB,OAAO,CAAC,aAAa;CActB"}

package/dist/cli/commands/state/dump.js

@@ -0,0 +1,314 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { Flags } from "@oclif/core";
+import { EventStore } from "../../../lib/events.js";
+import { HeartbeatManager } from "../../../lib/heartbeat.js";
+import { ResourceManager } from "../../../lib/resources.js";
+import { getAllSessions } from "../../../lib/session-manager.js";
+import { BaseCommand } from "../../base-command.js";
+export default class StateDump extends BaseCommand {
+    static description = "Dump unified state across all agents subsystems";
+    static hidden = false;
+    static examples = [
+        "<%= config.bin %> state dump",
+        "<%= config.bin %> state dump --project hostagent",
+        "<%= config.bin %> state dump --json --quiet",
+        "<%= config.bin %> state dump --summary",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        project: Flags.string({
+            char: "p",
+            description: "Filter by project",
+        }),
+        summary: Flags.boolean({
+            char: "s",
+            description: "Show summary only (no details)",
+            default: false,
+        }),
+        include: Flags.string({
+            char: "i",
+            description: "Include specific stores (comma-separated: events,sessions,resources,backlog,triage,plans)",
+        }),
+    };
+    getAgentsDir() {
+        const home = process.env.HOME || "~";
+        return join(home, ".abbie");
+    }
+    async execute() {
+        const { flags } = await this.parse(StateDump);
+        this.parsedFlags = flags;
+        const agentsDir = this.getAgentsDir();
+        const includeStores = flags.include?.split(",").map((s) => s.trim()) || null;
+        const dump = {
+            timestamp: new Date().toISOString(),
+            sources: {
+                events: join(agentsDir, "events"),
+                sessions: join(agentsDir, "sessions"),
+                resources: join(agentsDir, "resources"),
+                backlog: join(agentsDir, "backlog"),
+                triage: join(agentsDir, "triage"),
+                plans: join(agentsDir, "plans"),
+            },
+            events: this.shouldInclude("events", includeStores)
+                ? this.dumpEvents(agentsDir, flags.project)
+                : { projects: [], total_events: 0, active_sessions: 0 },
+            sessions: this.shouldInclude("sessions", includeStores)
+                ? this.dumpSessions(flags.project)
+                : { active: [], stale: [], total: 0 },
+            resources: this.shouldInclude("resources", includeStores)
+                ? this.dumpResources(agentsDir)
+                : { resources: [], total_leases: 0 },
+            backlog: this.shouldInclude("backlog", includeStores)
+                ? this.dumpBacklog(agentsDir, flags.project)
+                : { items: [], by_status: {}, by_project: {}, total: 0 },
+            triage: this.shouldInclude("triage", includeStores)
+                ? this.dumpTriage(agentsDir)
+                : { queues: [], total_issues: 0 },
+            plans: this.shouldInclude("plans", includeStores)
+                ? this.dumpPlans(flags.project)
+                : { sessions: [], by_project: {}, total: 0 },
+        };
+        if (flags.json || flags.format === "json") {
+            return dump;
+        }
+        if (flags.summary) {
+            this.printSummary(dump);
+        }
+        else {
+            this.printFull(dump);
+        }
+        return dump;
+    }
+    shouldInclude(store, includeStores) {
+        return includeStores === null || includeStores.includes(store);
+    }
+    dumpEvents(agentsDir, projectFilter) {
+        const eventsDir = join(agentsDir, "events");
+        if (!existsSync(eventsDir)) {
+            return { projects: [], total_events: 0, active_sessions: 0 };
+        }
+        const eventStore = new EventStore();
+        let projects = [];
+        try {
+            const entries = readdirSync(eventsDir, { withFileTypes: true });
+            projects = entries
+                .filter((e) => e.isDirectory())
+                .map((e) => e.name)
+                .filter((p) => !projectFilter || p === projectFilter);
+        }
+        catch {
+            return { projects: [], total_events: 0, active_sessions: 0 };
+        }
+        let totalEvents = 0;
+        let activeSessions = 0;
+        for (const project of projects) {
+            try {
+                const events = eventStore.readAll(project);
+                totalEvents += events.length;
+                const active = eventStore.getActiveSessions(project);
+                activeSessions += active.length;
+            }
+            catch {
+                // Skip project if events can't be read
+            }
+        }
+        return { projects, total_events: totalEvents, active_sessions: activeSessions };
+    }
+    dumpSessions(projectFilter) {
+        const heartbeat = new HeartbeatManager();
+        let active = heartbeat.listActiveSessions();
+        let stale = heartbeat.listStaleSessions();
+        if (projectFilter) {
+            active = active.filter((s) => s.project === projectFilter);
+            stale = stale.filter((s) => s.project === projectFilter);
+        }
+        return {
+            active,
+            stale,
+            total: active.length + stale.length,
+        };
+    }
+    dumpResources(agentsDir) {
+        const resourcesDir = join(agentsDir, "resources");
+        const resourceManager = new ResourceManager(resourcesDir);
+        const allResources = resourceManager.listResources();
+        const resources = [];
+        let totalLeases = 0;
+        for (const { resource, availability } of allResources) {
+            const leases = availability.leases.map((lease) => ({
+                lease_id: lease.lease_id,
+                session_id: lease.session_id,
+                agent: lease.agent,
+                expires_at: lease.expires_at,
+            }));
+            totalLeases += leases.length;
+            resources.push({
+                name: resource,
+                available: availability.available,
+                total: availability.total,
+                leases,
+            });
+        }
+        return {
+            resources,
+            total_leases: totalLeases,
+        };
+    }
+    dumpBacklog(agentsDir, projectFilter) {
+        const backlogDir = join(agentsDir, "backlog");
+        if (!existsSync(backlogDir)) {
+            return { items: [], by_status: {}, by_project: {}, total: 0 };
+        }
+        const items = [];
+        const byStatus = {};
+        const byProject = {};
+        try {
+            const projectDirs = readdirSync(backlogDir, { withFileTypes: true })
+                .filter((e) => e.isDirectory())
+                .map((e) => e.name)
+                .filter((p) => !projectFilter || p === projectFilter);
+            for (const project of projectDirs) {
+                const projectDir = join(backlogDir, project);
+                const files = readdirSync(projectDir).filter((f) => f.endsWith(".json"));
+                for (const file of files) {
+                    try {
+                        const content = readFileSync(join(projectDir, file), "utf-8");
+                        const item = JSON.parse(content);
+                        items.push(item);
+                        byStatus[item.status] = (byStatus[item.status] || 0) + 1;
+                        byProject[item.project] = (byProject[item.project] || 0) + 1;
+                    }
+                    catch {
+                        // Skip invalid files
+                    }
+                }
+            }
+        }
+        catch {
+            return { items: [], by_status: {}, by_project: {}, total: 0 };
+        }
+        return { items, by_status: byStatus, by_project: byProject, total: items.length };
+    }
+    dumpTriage(agentsDir) {
+        const triageDir = join(agentsDir, "triage");
+        if (!existsSync(triageDir)) {
+            return { queues: [], total_issues: 0 };
+        }
+        const queues = [];
+        let totalIssues = 0;
+        try {
+            const files = readdirSync(triageDir).filter((f) => f.endsWith(".json"));
+            for (const file of files) {
+                try {
+                    const content = readFileSync(join(triageDir, file), "utf-8");
+                    const queue = JSON.parse(content);
+                    queues.push(queue);
+                    totalIssues += queue.issues?.length || 0;
+                }
+                catch {
+                    // Skip invalid files
+                }
+            }
+        }
+        catch {
+            return { queues: [], total_issues: 0 };
+        }
+        return { queues, total_issues: totalIssues };
+    }
+    dumpPlans(projectFilter) {
+        const plansDir = this.getPlansDir();
+        const sessions = [];
+        try {
+            const sessionsByProject = getAllSessions(plansDir);
+            // Flatten the Record<string, SessionMetadata[]> into SessionMetadata[]
+            for (const [project, projectSessions] of Object.entries(sessionsByProject)) {
+                if (!projectFilter || project === projectFilter) {
+                    sessions.push(...projectSessions);
+                }
+            }
+        }
+        catch {
+            return { sessions: [], by_project: {}, total: 0 };
+        }
+        const byProject = {};
+        for (const session of sessions) {
+            byProject[session.project] = (byProject[session.project] || 0) + 1;
+        }
+        return { sessions, by_project: byProject, total: sessions.length };
+    }
+    printSummary(dump) {
+        this.log(`=== Agents State Dump ===`);
+        this.log(`Timestamp: ${dump.timestamp}`);
+        this.log("");
+        this.log(`Events: ${dump.events.total_events} events across ${dump.events.projects.length} projects`);
+        this.log(`Sessions: ${dump.sessions.active.length} active, ${dump.sessions.stale.length} stale`);
+        this.log(`Resources: ${dump.resources.total_leases} active leases`);
+        this.log(`Backlog: ${dump.backlog.total} items`);
+        this.log(`Triage: ${dump.triage.total_issues} issues in ${dump.triage.queues.length} queues`);
+        this.log(`Plans: ${dump.plans.total} sessions`);
+    }
+    printFull(dump) {
+        this.printSummary(dump);
+        this.log("");
+        // Active sessions
+        if (dump.sessions.active.length > 0) {
+            this.log("=== Active Sessions ===");
+            for (const session of dump.sessions.active) {
+                this.log(`  ${this.getStatusIcon(session.status)} ${session.session_id}`);
+                this.log(`     Agent: ${session.agent} | Project: ${session.project}`);
+                if (session.issue)
+                    this.log(`     Issue: ${session.issue}`);
+            }
+            this.log("");
+        }
+        // Resource leases
+        if (dump.resources.total_leases > 0) {
+            this.log("=== Resource Leases ===");
+            for (const resource of dump.resources.resources) {
+                for (const lease of resource.leases) {
+                    this.log(`  ${resource.name}: ${lease.agent} (${lease.session_id})`);
+                    this.log(`     Expires: ${lease.expires_at}`);
+                }
+            }
+            this.log("");
+        }
+        // Backlog by status
+        if (dump.backlog.total > 0) {
+            this.log("=== Backlog by Status ===");
+            for (const [status, count] of Object.entries(dump.backlog.by_status)) {
+                this.log(`  ${status}: ${count}`);
+            }
+            this.log("");
+        }
+        // Triage queues
+        if (dump.triage.queues.length > 0) {
+            this.log("=== Triage Queues ===");
+            for (const queue of dump.triage.queues) {
+                this.log(`  ${queue.workspace}/${queue.team}: ${queue.issues?.length || 0} issues`);
+            }
+            this.log("");
+        }
+        // Plans by project
+        if (dump.plans.total > 0) {
+            this.log("=== Plans by Project ===");
+            for (const [project, count] of Object.entries(dump.plans.by_project)) {
+                this.log(`  ${project}: ${count} sessions`);
+            }
+        }
+    }
+    getStatusIcon(status) {
+        switch (status) {
+            case "active":
+                return "🟢";
+            case "idle":
+                return "🟡";
+            case "stale":
+                return "🟠";
+            case "dead":
+                return "🔴";
+            default:
+                return "⚪";
+        }
+    }
+}

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

@@ -0,0 +1,56 @@
+/**
+ * abbie status — config + content sync health overview.
+ *
+ * Reads local sync state + sidecar manifest, reports:
+ * - Last successful sync time
+ * - Per-agent managed keys + drift detection
+ * - Content sync (rules/skills/hooks) status
+ * - Convex reachability
+ * - Pending changes
+ */
+import { BaseCommand } from "../base-command.js";
+type StatusResult = {
+    authenticated: boolean;
+    convexConfigured: boolean;
+    lastSyncAt: number | null;
+    consecutiveFailures: number;
+    agents: {
+        agent: string;
+        configPath: string;
+        configExists: boolean;
+        managedKeys: string[];
+        lastSyncAt: number | null;
+        hasBackup: boolean;
+        drift: boolean;
+    }[];
+    content?: {
+        lastSyncAt: number | null;
+        consecutiveFailures: number;
+        rules: {
+            managed: string[];
+            lastSyncAt: number | null;
+        };
+        skills: {
+            managed: string[];
+            lastSyncAt: number | null;
+        };
+        hooks: {
+            managed: string[];
+            lastSyncAt: number | null;
+        };
+    };
+};
+export default class StatusCommand extends BaseCommand {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        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<StatusResult>;
+}
+export {};
+//# sourceMappingURL=status.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/status.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAWH,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,KAAK,YAAY,GAAG;IAClB,aAAa,EAAE,OAAO,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,MAAM,EAAE;QACN,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,OAAO,CAAC;QACtB,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;QAC1B,SAAS,EAAE,OAAO,CAAC;QACnB,KAAK,EAAE,OAAO,CAAC;KAChB,EAAE,CAAC;IACJ,OAAO,CAAC,EAAE;QACR,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;QAC1B,mBAAmB,EAAE,MAAM,CAAC;QAC5B,KAAK,EAAE;YAAE,OAAO,EAAE,MAAM,EAAE,CAAC;YAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,CAAC;QACxD,MAAM,EAAE;YAAE,OAAO,EAAE,MAAM,EAAE,CAAC;YAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,CAAC;QACzD,KAAK,EAAE;YAAE,OAAO,EAAE,MAAM,EAAE,CAAC;YAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,CAAC;KACzD,CAAC;CACH,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,WAAW;IACpD,OAAgB,OAAO,SAAiC;IAExD,OAAgB,WAAW,SAIN;IAErB,OAAgB,QAAQ,WAGtB;IAEF,OAAgB,KAAK;;;;;MAEnB;IAEI,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC;CAoLvC"}