cortex-agents 2.1.0 → 2.3.0

package/dist/utils/plan-extract.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Sections extracted from a plan for use in a PR body.
+ */
+export interface PlanSections {
+    /** Plan title from frontmatter or first heading */
+    title: string;
+    /** Summary paragraph(s) */
+    summary: string;
+    /** Task list in markdown checkbox format */
+    tasks: string;
+    /** Key decisions section */
+    decisions: string;
+    /** The raw plan filename */
+    filename: string;
+}
+/**
+ * Extract relevant sections from a plan markdown file for composing a PR body.
+ *
+ * Parses the plan looking for ## Summary, ## Tasks, and ## Key Decisions sections.
+ * Falls back gracefully if sections are missing.
+ */
+export declare function extractPlanSections(planContent: string, filename: string): PlanSections;
+/**
+ * Build a PR body from extracted plan sections.
+ */
+export declare function buildPrBodyFromPlan(sections: PlanSections): string;
+/**
+ * Find and read a plan file from .cortex/plans/.
+ *
+ * If a specific filename is given, reads that file.
+ * Otherwise, finds the most recent plan matching the branch type prefix.
+ */
+export declare function findPlanContent(worktree: string, planFilename?: string, branchName?: string): {
+    content: string;
+    filename: string;
+} | null;
+//# sourceMappingURL=plan-extract.d.ts.map

package/dist/utils/plan-extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-extract.d.ts","sourceRoot":"","sources":["../../src/utils/plan-extract.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,2BAA2B;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,4BAA4B;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CAuCvF;AAmCD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAwBlE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,MAAM,EACrB,UAAU,CAAC,EAAE,MAAM,GAClB;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAqC9C"}

package/dist/utils/plan-extract.js

@@ -0,0 +1,137 @@
+import * as fs from "fs";
+import * as path from "path";
+const CORTEX_DIR = ".cortex";
+const PLANS_DIR = "plans";
+/**
+ * Extract relevant sections from a plan markdown file for composing a PR body.
+ *
+ * Parses the plan looking for ## Summary, ## Tasks, and ## Key Decisions sections.
+ * Falls back gracefully if sections are missing.
+ */
+export function extractPlanSections(planContent, filename) {
+    const result = {
+        title: "",
+        summary: "",
+        tasks: "",
+        decisions: "",
+        filename,
+    };
+    // Extract title from frontmatter
+    const frontmatterMatch = planContent.match(/^---\n([\s\S]*?)\n---/);
+    if (frontmatterMatch) {
+        const titleMatch = frontmatterMatch[1].match(/title:\s*"?([^"\n]+)"?/);
+        if (titleMatch)
+            result.title = titleMatch[1].trim();
+    }
+    // Fallback: extract title from first # heading
+    if (!result.title) {
+        const headingMatch = planContent.match(/^#\s+(.+)$/m);
+        if (headingMatch)
+            result.title = headingMatch[1].trim();
+    }
+    // Extract sections by heading
+    // Split on ## headings and capture each section
+    const sections = splitByHeadings(planContent);
+    for (const [heading, content] of sections) {
+        const h = heading.toLowerCase();
+        if (h.includes("summary")) {
+            result.summary = content.trim();
+        }
+        else if (h.includes("task")) {
+            result.tasks = content.trim();
+        }
+        else if (h.includes("decision") || h.includes("key decision")) {
+            result.decisions = content.trim();
+        }
+    }
+    return result;
+}
+/**
+ * Split markdown content into sections based on ## headings.
+ * Returns an array of [heading, content] tuples.
+ */
+function splitByHeadings(content) {
+    const sections = [];
+    const lines = content.split("\n");
+    let currentHeading = "";
+    let currentContent = [];
+    for (const line of lines) {
+        const headingMatch = line.match(/^##\s+(.+)$/);
+        if (headingMatch) {
+            // Save previous section
+            if (currentHeading) {
+                sections.push([currentHeading, currentContent.join("\n")]);
+            }
+            currentHeading = headingMatch[1];
+            currentContent = [];
+        }
+        else if (currentHeading) {
+            currentContent.push(line);
+        }
+    }
+    // Save last section
+    if (currentHeading) {
+        sections.push([currentHeading, currentContent.join("\n")]);
+    }
+    return sections;
+}
+/**
+ * Build a PR body from extracted plan sections.
+ */
+export function buildPrBodyFromPlan(sections) {
+    const parts = [];
+    if (sections.summary) {
+        parts.push(`## Summary\n\n${sections.summary}`);
+    }
+    if (sections.tasks) {
+        parts.push(`## Tasks\n\n${sections.tasks}`);
+    }
+    if (sections.decisions) {
+        parts.push(`## Key Decisions\n\n${sections.decisions}`);
+    }
+    if (parts.length === 0) {
+        return `Implementation based on plan: \`${sections.filename}\``;
+    }
+    parts.push(`---\n*Auto-generated by cortex-agents from plan: \`${sections.filename}\`*`);
+    return parts.join("\n\n");
+}
+/**
+ * Find and read a plan file from .cortex/plans/.
+ *
+ * If a specific filename is given, reads that file.
+ * Otherwise, finds the most recent plan matching the branch type prefix.
+ */
+export function findPlanContent(worktree, planFilename, branchName) {
+    const plansDir = path.join(worktree, CORTEX_DIR, PLANS_DIR);
+    if (!fs.existsSync(plansDir))
+        return null;
+    if (planFilename) {
+        const filepath = path.join(plansDir, planFilename);
+        if (fs.existsSync(filepath)) {
+            return { content: fs.readFileSync(filepath, "utf-8"), filename: planFilename };
+        }
+        return null;
+    }
+    // Try to find a matching plan by branch type
+    // e.g., branch "feature/auth" → look for plans with "feature" type
+    const planFiles = fs
+        .readdirSync(plansDir)
+        .filter((f) => f.endsWith(".md") && f !== ".gitkeep")
+        .sort()
+        .reverse(); // Most recent first
+    if (planFiles.length === 0)
+        return null;
+    // If branch name provided, try to match by type
+    if (branchName) {
+        const branchType = branchName.split("/")[0]; // "feature", "bugfix", etc.
+        const matched = planFiles.find((f) => f.includes(branchType));
+        if (matched) {
+            const filepath = path.join(plansDir, matched);
+            return { content: fs.readFileSync(filepath, "utf-8"), filename: matched };
+        }
+    }
+    // Fall back to most recent plan
+    const mostRecent = planFiles[0];
+    const filepath = path.join(plansDir, mostRecent);
+    return { content: fs.readFileSync(filepath, "utf-8"), filename: mostRecent };
+}

package/dist/utils/propagate.d.ts

@@ -0,0 +1,22 @@
+interface PropagateResult {
+    /** Plans that were copied */
+    copied: string[];
+    /** Whether .cortex was newly initialized in the target */
+    initialized: boolean;
+}
+/**
+ * Propagate plans from the main project into a worktree's .cortex/plans/ directory.
+ *
+ * Ensures the worktree is self-contained with its own copy of the plans,
+ * so the new OpenCode session has full context without referencing the parent.
+ */
+export declare function propagatePlan(opts: {
+    /** Main project root (source) */
+    sourceWorktree: string;
+    /** Worktree path (target) */
+    targetWorktree: string;
+    /** Specific plan filename to copy — copies all plans if omitted */
+    planFilename?: string;
+}): PropagateResult;
+export {};
+//# sourceMappingURL=propagate.d.ts.map

package/dist/utils/propagate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propagate.d.ts","sourceRoot":"","sources":["../../src/utils/propagate.ts"],"names":[],"mappings":"AAMA,UAAU,eAAe;IACvB,6BAA6B;IAC7B,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,0DAA0D;IAC1D,WAAW,EAAE,OAAO,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAClC,iCAAiC;IACjC,cAAc,EAAE,MAAM,CAAC;IACvB,6BAA6B;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,mEAAmE;IACnE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG,eAAe,CA6DlB"}

package/dist/utils/propagate.js

@@ -0,0 +1,64 @@
+import * as fs from "fs";
+import * as path from "path";
+const CORTEX_DIR = ".cortex";
+const PLANS_DIR = "plans";
+/**
+ * Propagate plans from the main project into a worktree's .cortex/plans/ directory.
+ *
+ * Ensures the worktree is self-contained with its own copy of the plans,
+ * so the new OpenCode session has full context without referencing the parent.
+ */
+export function propagatePlan(opts) {
+    const { sourceWorktree, targetWorktree, planFilename } = opts;
+    const sourcePlansDir = path.join(sourceWorktree, CORTEX_DIR, PLANS_DIR);
+    const targetCortexDir = path.join(targetWorktree, CORTEX_DIR);
+    const targetPlansDir = path.join(targetCortexDir, PLANS_DIR);
+    const result = { copied: [], initialized: false };
+    // Check source has plans
+    if (!fs.existsSync(sourcePlansDir)) {
+        return result;
+    }
+    // Initialize target .cortex if needed
+    if (!fs.existsSync(targetCortexDir)) {
+        fs.mkdirSync(targetCortexDir, { recursive: true });
+        result.initialized = true;
+    }
+    if (!fs.existsSync(targetPlansDir)) {
+        fs.mkdirSync(targetPlansDir, { recursive: true });
+    }
+    // Copy config.json if it exists (for consistent configuration)
+    const sourceConfig = path.join(sourceWorktree, CORTEX_DIR, "config.json");
+    if (fs.existsSync(sourceConfig)) {
+        const targetConfig = path.join(targetCortexDir, "config.json");
+        if (!fs.existsSync(targetConfig)) {
+            fs.copyFileSync(sourceConfig, targetConfig);
+        }
+    }
+    // Create sessions dir in target (tools expect it)
+    const targetSessionsDir = path.join(targetCortexDir, "sessions");
+    if (!fs.existsSync(targetSessionsDir)) {
+        fs.mkdirSync(targetSessionsDir, { recursive: true });
+    }
+    if (planFilename) {
+        // Copy specific plan
+        const sourcePlan = path.join(sourcePlansDir, planFilename);
+        if (fs.existsSync(sourcePlan)) {
+            const targetPlan = path.join(targetPlansDir, planFilename);
+            fs.copyFileSync(sourcePlan, targetPlan);
+            result.copied.push(planFilename);
+        }
+    }
+    else {
+        // Copy all plans
+        const planFiles = fs
+            .readdirSync(sourcePlansDir)
+            .filter((f) => f.endsWith(".md") && f !== ".gitkeep");
+        for (const file of planFiles) {
+            const sourcePlan = path.join(sourcePlansDir, file);
+            const targetPlan = path.join(targetPlansDir, file);
+            fs.copyFileSync(sourcePlan, targetPlan);
+            result.copied.push(file);
+        }
+    }
+    return result;
+}

package/dist/utils/shell.d.ts

@@ -0,0 +1,53 @@
+export interface ExecResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export interface ExecOptions {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    timeout?: number;
+    /** If true, resolve even on non-zero exit codes instead of rejecting. */
+    nothrow?: boolean;
+}
+/**
+ * Execute a command with array-based arguments (no shell invocation).
+ * Uses child_process.execFile which never spawns a shell, preventing injection.
+ *
+ * By default, rejects on non-zero exit codes. Pass `nothrow: true` to always resolve.
+ */
+export declare function exec(cmd: string, args: string[], opts?: ExecOptions): Promise<ExecResult>;
+/**
+ * Fire-and-forget spawn. Returns the ChildProcess for PID tracking.
+ * Uses child_process.spawn with shell: false (default).
+ */
+export declare function spawn(cmd: string, args: string[], opts?: ExecOptions & {
+    stdio?: "ignore" | "pipe";
+}): import("child_process").ChildProcess;
+/**
+ * Shorthand for running a git command.
+ */
+export declare function git(cwd: string, ...args: string[]): Promise<ExecResult>;
+/**
+ * Shorthand for running a gh (GitHub CLI) command.
+ */
+export declare function gh(cwd: string, ...args: string[]): Promise<ExecResult>;
+/**
+ * Check if a binary exists in PATH.
+ */
+export declare function which(bin: string): Promise<string | null>;
+/**
+ * Send a signal to a process. Returns true if signal was sent, false if
+ * the process doesn't exist or we lack permissions.
+ */
+export declare function kill(pid: number, signal?: NodeJS.Signals): boolean;
+/**
+ * Check if a process is alive (sends signal 0 — no actual signal).
+ */
+export declare function isAlive(pid: number): boolean;
+/**
+ * Escape a string for safe inclusion in a shell command.
+ * Use only when array-based argument passing is impossible (e.g., osascript).
+ */
+export declare function shellEscape(str: string): string;
+//# sourceMappingURL=shell.d.ts.map

package/dist/utils/shell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell.d.ts","sourceRoot":"","sources":["../../src/utils/shell.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yEAAyE;IACzE,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAClB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EAAE,EACd,IAAI,GAAE,WAAgB,GACrB,OAAO,CAAC,UAAU,CAAC,CAqCrB;AAED;;;GAGG;AACH,wBAAgB,KAAK,CACnB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EAAE,EACd,IAAI,GAAE,WAAW,GAAG;IAAE,KAAK,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAA;CAAO,wCAYvD;AAED;;GAEG;AACH,wBAAsB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAE7E;AAED;;GAEG;AACH,wBAAsB,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAE5E;AAED;;GAEG;AACH,wBAAsB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAQ/D;AAED;;;GAGG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,OAAmB,GAAG,OAAO,CAO7E;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAO5C;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAS/C"}

package/dist/utils/shell.js

@@ -0,0 +1,118 @@
+import { execFile, spawn as cpSpawn } from "child_process";
+/**
+ * Execute a command with array-based arguments (no shell invocation).
+ * Uses child_process.execFile which never spawns a shell, preventing injection.
+ *
+ * By default, rejects on non-zero exit codes. Pass `nothrow: true` to always resolve.
+ */
+export function exec(cmd, args, opts = {}) {
+    return new Promise((resolve, reject) => {
+        execFile(cmd, args, {
+            cwd: opts.cwd,
+            env: opts.env ?? process.env,
+            timeout: opts.timeout ?? 30_000,
+            maxBuffer: 10 * 1024 * 1024,
+        }, (error, stdout, stderr) => {
+            const result = {
+                stdout: String(stdout ?? ""),
+                stderr: String(stderr ?? ""),
+                exitCode: error ? error.code ?? 1 : 0,
+            };
+            if (error) {
+                if (error.code === "ENOENT") {
+                    reject(new Error(`Command not found: ${cmd}`));
+                    return;
+                }
+                if (!opts.nothrow) {
+                    const err = new Error(result.stderr || error.message);
+                    err.exitCode = result.exitCode;
+                    err.stdout = result.stdout;
+                    err.stderr = result.stderr;
+                    reject(err);
+                    return;
+                }
+            }
+            resolve(result);
+        });
+    });
+}
+/**
+ * Fire-and-forget spawn. Returns the ChildProcess for PID tracking.
+ * Uses child_process.spawn with shell: false (default).
+ */
+export function spawn(cmd, args, opts = {}) {
+    const stdio = opts.stdio ?? "ignore";
+    const child = cpSpawn(cmd, args, {
+        cwd: opts.cwd,
+        env: opts.env ?? process.env,
+        stdio: stdio === "pipe" ? ["ignore", "pipe", "pipe"] : "ignore",
+        detached: false,
+    });
+    // Prevent unhandled error crashes on spawn failure
+    child.on("error", () => { });
+    return child;
+}
+/**
+ * Shorthand for running a git command.
+ */
+export async function git(cwd, ...args) {
+    return exec("git", ["-C", cwd, ...args]);
+}
+/**
+ * Shorthand for running a gh (GitHub CLI) command.
+ */
+export async function gh(cwd, ...args) {
+    return exec("gh", args, { cwd });
+}
+/**
+ * Check if a binary exists in PATH.
+ */
+export async function which(bin) {
+    try {
+        const result = await exec(process.platform === "win32" ? "where" : "which", [bin]);
+        const p = result.stdout.trim().split("\n")[0];
+        return p || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Send a signal to a process. Returns true if signal was sent, false if
+ * the process doesn't exist or we lack permissions.
+ */
+export function kill(pid, signal = "SIGTERM") {
+    try {
+        process.kill(pid, signal);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a process is alive (sends signal 0 — no actual signal).
+ */
+export function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Escape a string for safe inclusion in a shell command.
+ * Use only when array-based argument passing is impossible (e.g., osascript).
+ */
+export function shellEscape(str) {
+    // Replace backslashes first, then other dangerous characters
+    return str
+        .replace(/\\/g, "\\\\")
+        .replace(/"/g, '\\"')
+        .replace(/'/g, "'\\''")
+        .replace(/`/g, "\\`")
+        .replace(/\$/g, "\\$")
+        .replace(/!/g, "\\!");
+}

package/dist/utils/terminal.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Terminal Driver System — Strategy pattern for cross-platform terminal tab management.
+ *
+ * Each supported terminal emulator implements the TerminalDriver interface for:
+ *   - detect()  — check if this is the active terminal
+ *   - openTab() — open a new tab and return identifiers
+ *   - closeTab() — close a tab by its identifiers (idempotent, never throws)
+ *
+ * Session data is persisted to `.cortex/.terminal-session` inside each worktree
+ * so tabs can be closed when the worktree is removed.
+ */
+/** Persisted session data for an opened terminal tab. */
+export interface TerminalSession {
+    /** Driver name (e.g., "iterm2", "kitty", "tmux", "pty") */
+    terminal: string;
+    platform: NodeJS.Platform;
+    sessionId?: string;
+    windowId?: string;
+    tabId?: string;
+    paneId?: string;
+    dbusPath?: string;
+    pid?: number;
+    ptyId?: string;
+    mode: "terminal" | "pty" | "background";
+    branch: string;
+    agent: string;
+    worktreePath: string;
+    startedAt: string;
+}
+/** Options passed to a driver's openTab() method. */
+export interface TabOpenOptions {
+    worktreePath: string;
+    opencodeBin: string;
+    agent: string;
+    prompt: string;
+    branchName: string;
+}
+/** Common interface for all terminal drivers. */
+export interface TerminalDriver {
+    readonly name: string;
+    detect(): boolean;
+    openTab(opts: TabOpenOptions): Promise<Partial<TerminalSession>>;
+    closeTab(session: TerminalSession): Promise<boolean>;
+}
+/** Persist terminal session data to the worktree's .cortex directory. */
+export declare function writeSession(worktreePath: string, session: TerminalSession): void;
+/** Read terminal session data from the worktree's .cortex directory. */
+export declare function readSession(worktreePath: string): TerminalSession | null;
+/**
+ * Detect the active terminal emulator and return the matching driver.
+ * Falls back to FallbackDriver if no specific terminal is detected.
+ */
+export declare function detectDriver(): TerminalDriver;
+/**
+ * Get a driver by name (used when closing a tab from a persisted session).
+ * Returns null if the driver name is unknown.
+ */
+export declare function getDriverByName(name: string): TerminalDriver | null;
+/**
+ * Close a terminal session using the appropriate driver.
+ * Handles all modes (terminal, pty, background) with PID fallback.
+ *
+ * This is the main entry point for worktree_remove cleanup.
+ */
+export declare function closeSession(session: TerminalSession): Promise<boolean>;
+//# sourceMappingURL=terminal.d.ts.map

package/dist/utils/terminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../src/utils/terminal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAQH,yDAAyD;AACzD,MAAM,WAAW,eAAe;IAC9B,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC;IAG1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IAGf,IAAI,EAAE,UAAU,GAAG,KAAK,GAAG,YAAY,CAAC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qDAAqD;AACrD,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,iDAAiD;AACjD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,MAAM,IAAI,OAAO,CAAC;IAClB,OAAO,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC;IACjE,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACtD;AAMD,yEAAyE;AACzE,wBAAgB,YAAY,CAC1B,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,eAAe,GACvB,IAAI,CASN;AAED,wEAAwE;AACxE,wBAAgB,WAAW,CACzB,YAAY,EAAE,MAAM,GACnB,eAAe,GAAG,IAAI,CAQxB;AA6kBD;;;GAGG;AACH,wBAAgB,YAAY,IAAI,cAAc,CAM7C;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAEnE;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,CAY7E"}