cortex-agents 2.3.0 → 3.4.0

package/dist/utils/ide.js

@@ -0,0 +1,307 @@
+/**
+ * IDE Detection System
+ *
+ * Detects the current Integrated Development Environment or editor context.
+ * This is used to offer appropriate worktree launch options that match
+ * the user's current workflow.
+ *
+ * Detection is based on environment variables set by various IDEs when
+ * running terminal sessions within them.
+ */
+import { shellEscape, which } from "./shell.js";
+/**
+ * Detect the current IDE/editor environment.
+ * Checks environment variables, process hierarchy, and context clues.
+ */
+export function detectIDE() {
+    const env = process.env;
+    // VS Code detection
+    // VSCODE_PID is set when running in VS Code's integrated terminal
+    // VSCODE_CWD is set in some VS Code contexts
+    // TERM_PROGRAM=vscode is set by VS Code's terminal
+    if (env.VSCODE_PID || env.VSCODE_CWD || env.TERM_PROGRAM === "vscode") {
+        return {
+            type: "vscode",
+            name: "Visual Studio Code",
+            version: env.VSCODE_VERSION,
+            hasIntegratedTerminal: true,
+            canOpenInTerminal: true,
+            canOpenInWindow: true,
+            detectionSource: env.VSCODE_PID ? "VSCODE_PID" :
+                env.VSCODE_CWD ? "VSCODE_CWD" : "TERM_PROGRAM",
+        };
+    }
+    // Cursor detection
+    // CURSOR_TRACE_ID is set by Cursor AI editor
+    // CURSOR_SHELL_VERSION indicates Cursor's shell integration
+    if (env.CURSOR_TRACE_ID || env.CURSOR_SHELL_VERSION) {
+        return {
+            type: "cursor",
+            name: "Cursor",
+            version: env.CURSOR_SHELL_VERSION,
+            hasIntegratedTerminal: true,
+            canOpenInTerminal: true,
+            canOpenInWindow: true,
+            detectionSource: env.CURSOR_TRACE_ID ? "CURSOR_TRACE_ID" : "CURSOR_SHELL_VERSION",
+        };
+    }
+    // Windsurf detection
+    // WINDSURF_PARENT_PROCESS indicates Windsurf editor
+    // WINDSURF_EDITOR is set by Windsurf's terminal
+    if (env.WINDSURF_PARENT_PROCESS || env.WINDSURF_EDITOR) {
+        return {
+            type: "windsurf",
+            name: "Windsurf",
+            hasIntegratedTerminal: true,
+            canOpenInTerminal: true,
+            canOpenInWindow: true,
+            detectionSource: env.WINDSURF_PARENT_PROCESS ? "WINDSURF_PARENT_PROCESS" : "WINDSURF_EDITOR",
+        };
+    }
+    // JetBrains detection
+    // TERMINAL_EMULATOR contains "JetBrains" when in JB IDE terminal
+    // JETBRAINS_IDE is set by some JetBrains IDEs
+    if (env.TERMINAL_EMULATOR?.includes("JetBrains") || env.JETBRAINS_IDE) {
+        return {
+            type: "jetbrains",
+            name: env.JETBRAINS_IDE_NAME || "JetBrains IDE",
+            hasIntegratedTerminal: true,
+            canOpenInTerminal: true, // Can open in terminal, but no CLI for new window
+            canOpenInWindow: false, // JB IDEs don't have CLI window opening
+            detectionSource: env.JETBRAINS_IDE ? "JETBRAINS_IDE" : "TERMINAL_EMULATOR",
+        };
+    }
+    // Zed detection
+    // ZED_TERM is set by Zed's integrated terminal
+    // TERM_PROGRAM=zed in some Zed configurations
+    if (env.ZED_TERM || env.TERM_PROGRAM === "zed") {
+        return {
+            type: "zed",
+            name: "Zed",
+            hasIntegratedTerminal: true,
+            canOpenInTerminal: true,
+            canOpenInWindow: true,
+            detectionSource: env.ZED_TERM ? "ZED_TERM" : "TERM_PROGRAM",
+        };
+    }
+    // Terminal-only detection (fallback when no IDE detected)
+    // This means we're in a standalone terminal emulator
+    if (env.TERM_PROGRAM || env.TMUX || env.TERM) {
+        return {
+            type: "terminal",
+            name: env.TERM_PROGRAM || env.TERM || "Terminal",
+            hasIntegratedTerminal: false,
+            canOpenInTerminal: false,
+            canOpenInWindow: true,
+            detectionSource: env.TERM_PROGRAM ? "TERM_PROGRAM" :
+                env.TMUX ? "TMUX" : "TERM",
+        };
+    }
+    // Unknown environment
+    return {
+        type: "unknown",
+        name: "Unknown",
+        hasIntegratedTerminal: false,
+        canOpenInTerminal: false,
+        canOpenInWindow: true,
+        detectionSource: "none",
+    };
+}
+/**
+ * Get the command to open a worktree in the IDE's integrated terminal.
+ * Returns null if the IDE doesn't support CLI-based opening.
+ *
+ * Note: This function is currently unused but kept for future use.
+ * All inputs are escaped to prevent command injection.
+ */
+export function getIDEOpenCommand(ide, worktreePath) {
+    // Escape the path to prevent command injection
+    const safePath = shellEscape(worktreePath);
+    switch (ide.type) {
+        case "vscode":
+            // VS Code: use `code` CLI to open folder in new window
+            return `code --new-window "${safePath}"`;
+        case "cursor":
+            // Cursor: use `cursor` CLI
+            return `cursor --new-window "${safePath}"`;
+        case "windsurf":
+            // Windsurf: use `windsurf` CLI
+            return `windsurf "${safePath}"`;
+        case "zed":
+            // Zed: use `zed` CLI
+            return `zed "${safePath}"`;
+        case "jetbrains":
+            // JetBrains: requires manual opening or platform-specific CLI
+            // Common CLIs: idea, webstorm, pycharm, etc.
+            return null;
+        default:
+            return null;
+    }
+}
+/**
+ * Get the name of the CLI binary for the detected IDE.
+ * Returns null if no CLI is available or known.
+ */
+export function getIDECliBinary(ide) {
+    switch (ide.type) {
+        case "vscode":
+            return "code";
+        case "cursor":
+            return "cursor";
+        case "windsurf":
+            return "windsurf";
+        case "zed":
+            return "zed";
+        default:
+            return null;
+    }
+}
+/**
+ * Get a human-readable hint for installing an IDE's CLI binary.
+ * Each IDE has a different installation method.
+ */
+export function getInstallHint(type, binary) {
+    switch (type) {
+        case "vscode":
+            return "Cmd+Shift+P → 'Shell Command: Install code command in PATH'";
+        case "cursor":
+            return "Cmd+Shift+P → 'Shell Command: Install cursor command in PATH'";
+        case "windsurf":
+            return "Ensure Windsurf is installed and 'windsurf' is in PATH";
+        case "zed":
+            return "Ensure Zed is installed and 'zed' is in PATH";
+        default:
+            return `Ensure '${binary}' is in PATH`;
+    }
+}
+/**
+ * Async version of detectIDE() that also checks whether the IDE's CLI binary
+ * is actually available in PATH. Use this in tools where you need to verify
+ * runtime availability before offering IDE launch options.
+ *
+ * The sync detectIDE() is preserved for non-async contexts.
+ */
+export async function detectIDEWithCLICheck() {
+    const ide = detectIDE();
+    const cliBinary = getIDECliBinary(ide);
+    if (cliBinary) {
+        const available = await which(cliBinary);
+        ide.cliAvailable = !!available;
+        ide.cliBinary = cliBinary;
+        if (!available) {
+            ide.cliInstallHint = getInstallHint(ide.type, cliBinary);
+        }
+    }
+    else {
+        ide.cliAvailable = false;
+    }
+    return ide;
+}
+/**
+ * Check if we're already inside an IDE terminal.
+ * This helps determine if we should offer "stay here" as primary option.
+ */
+export function isInIDETerminal() {
+    const ide = detectIDE();
+    return ide.hasIntegratedTerminal && !!process.env.TERM;
+}
+/**
+ * Generate contextual recommendations based on detected environment.
+ * Used by agents to offer appropriate launch options to users.
+ */
+export function generateEnvironmentRecommendations(ide) {
+    const recommendations = [];
+    if (ide.hasIntegratedTerminal && ide.canOpenInTerminal && ide.cliAvailable !== false) {
+        // Only offer IDE option when CLI is confirmed available or hasn't been checked yet
+        recommendations.push({
+            option: `Open in ${ide.name} (Recommended)`,
+            priority: "high",
+            reason: `${ide.name} integrated terminal maintains context and is familiar`,
+            mode: "ide",
+        });
+    }
+    else if (ide.hasIntegratedTerminal && ide.cliAvailable === false) {
+        // IDE detected but CLI missing — note it but don't recommend
+        recommendations.push({
+            option: `Open in ${ide.name} (CLI not installed)`,
+            priority: "low",
+            reason: `${ide.cliBinary || "CLI"} not in PATH. ${ide.cliInstallHint || "Install the CLI to enable this option."}`,
+            mode: "ide",
+        });
+    }
+    recommendations.push({
+        option: "Open in new terminal tab",
+        priority: ide.cliAvailable === false ? "high" : "medium",
+        reason: "Open in your current terminal emulator as a new tab",
+        mode: "terminal",
+    });
+    recommendations.push({
+        option: "Open in-app PTY",
+        priority: "medium",
+        reason: "Embedded terminal within this OpenCode session",
+        mode: "pty",
+    });
+    recommendations.push({
+        option: "Run in background",
+        priority: "low",
+        reason: "AI implements headlessly while you keep working here",
+        mode: "background",
+    });
+    recommendations.push({
+        option: "Stay in current session",
+        priority: "low",
+        reason: "Continue working in this terminal session",
+        mode: "stay",
+    });
+    return recommendations;
+}
+/**
+ * Format environment detection as a human-readable report.
+ * Used by the detect_environment tool.
+ */
+export function formatEnvironmentReport(ide, terminalName) {
+    const lines = [
+        `## Environment Detection`,
+        ``,
+        `**IDE/Editor:** ${ide.name}`,
+        `**Detection Method:** ${ide.detectionSource}`,
+        `**Terminal:** ${terminalName}`,
+        `**Platform:** ${process.platform}`,
+        ``,
+    ];
+    if (ide.version) {
+        lines.push(`**Version:** ${ide.version}`, ``);
+    }
+    lines.push(`### Capabilities`, ``);
+    if (ide.hasIntegratedTerminal) {
+        lines.push(`- ✓ Has integrated terminal`);
+    }
+    else {
+        lines.push(`- ✗ No integrated terminal`);
+    }
+    if (ide.canOpenInWindow) {
+        if (ide.cliAvailable === false) {
+            lines.push(`- ⚠ Can open new window via CLI — but \`${ide.cliBinary || "cli"}\` NOT found in PATH`);
+            if (ide.cliInstallHint) {
+                lines.push(`  Fix: ${ide.cliInstallHint}`);
+            }
+        }
+        else if (ide.cliAvailable === true) {
+            lines.push(`- ✓ Can open new window via CLI (\`${ide.cliBinary}\` available)`);
+        }
+        else {
+            lines.push(`- ✓ Can open new window via CLI`);
+        }
+    }
+    else {
+        lines.push(`- ✗ Cannot open new window via CLI`);
+    }
+    lines.push(``, `### Recommended Launch Options`, ``);
+    const recommendations = generateEnvironmentRecommendations(ide);
+    for (const rec of recommendations) {
+        const priorityBadge = rec.priority === "high" ? " (Recommended)" :
+            rec.priority === "medium" ? "" : "";
+        lines.push(`- **${rec.option}${priorityBadge}** — ${rec.reason}`);
+    }
+    return lines.join("\n");
+}

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

@@ -13,6 +13,13 @@ export interface PlanSections {
     /** The raw plan filename */
     filename: string;
 }
+/**
+ * Extract GitHub issue references from plan frontmatter.
+ *
+ * Looks for `issues: [42, 51]` in YAML frontmatter.
+ * Returns an array of issue numbers, or an empty array if none found.
+ */
+export declare function extractIssueRefs(planContent: string): number[];
 /**
  * Extract relevant sections from a plan markdown file for composing a PR body.
  *

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

@@ -1 +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"}
+{"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,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAY9D;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,CA0C9C"}

package/dist/utils/plan-extract.js

@@ -2,6 +2,25 @@ import * as fs from "fs";
 import * as path from "path";
 const CORTEX_DIR = ".cortex";
 const PLANS_DIR = "plans";
+/**
+ * Extract GitHub issue references from plan frontmatter.
+ *
+ * Looks for `issues: [42, 51]` in YAML frontmatter.
+ * Returns an array of issue numbers, or an empty array if none found.
+ */
+export function extractIssueRefs(planContent) {
+    const frontmatterMatch = planContent.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch)
+        return [];
+    // Match issues: [42, 51] or issues: [42]
+    const issuesMatch = frontmatterMatch[1].match(/issues:\s*\[([^\]]*)\]/);
+    if (!issuesMatch)
+        return [];
+    return issuesMatch[1]
+        .split(",")
+        .map((s) => parseInt(s.trim(), 10))
+        .filter((n) => !isNaN(n) && n > 0);
+}
 /**
  * Extract relevant sections from a plan markdown file for composing a PR body.
  *
@@ -106,7 +125,12 @@ export function findPlanContent(worktree, planFilename, branchName) {
     if (!fs.existsSync(plansDir))
         return null;
     if (planFilename) {
-        const filepath = path.join(plansDir, planFilename);
+        // Prevent path traversal — resolve and verify the path is strictly inside plansDir
+        const filepath = path.resolve(plansDir, planFilename);
+        const resolvedPlansDir = path.resolve(plansDir);
+        if (!filepath.startsWith(resolvedPlansDir + path.sep)) {
+            return null; // Reject traversal attempts and directory-level references (".", "")
+        }
         if (fs.existsSync(filepath)) {
             return { content: fs.readFileSync(filepath, "utf-8"), filename: planFilename };
         }

package/dist/utils/repl.d.ts

@@ -0,0 +1,114 @@
+/**
+ * REPL Loop Utilities
+ *
+ * State management, plan task parsing, build/test command auto-detection,
+ * and progress formatting for the implement agent's iterative task loop.
+ *
+ * State is persisted to `.cortex/repl-state.json` so it survives context
+ * compaction, session restarts, and agent switches.
+ */
+export type TaskStatus = "pending" | "in_progress" | "passed" | "failed" | "skipped";
+export interface TaskIteration {
+    /** ISO timestamp of this iteration */
+    at: string;
+    /** Outcome of this iteration */
+    result: "pass" | "fail" | "skip";
+    /** Test output summary, error message, or skip reason */
+    detail: string;
+}
+export interface ReplTask {
+    /** Zero-based index in the task list */
+    index: number;
+    /** Task description from the plan */
+    description: string;
+    /** Current status in the state machine */
+    status: TaskStatus;
+    /** Number of failed attempts (resets on pass) */
+    retries: number;
+    /** Full iteration history */
+    iterations: TaskIteration[];
+}
+export interface ReplState {
+    /** Source plan filename */
+    planFilename: string;
+    /** ISO timestamp when the loop started */
+    startedAt: string;
+    /** ISO timestamp when the loop completed (all tasks done or aborted) */
+    completedAt?: string;
+    /** Auto-detected or user-provided build command */
+    buildCommand: string | null;
+    /** Auto-detected or user-provided test command */
+    testCommand: string | null;
+    /** Optional lint command */
+    lintCommand: string | null;
+    /** Max retries per task before escalating to user (default: 3) */
+    maxRetries: number;
+    /** Index of the currently active task (-1 if not started) */
+    currentTaskIndex: number;
+    /** All tasks in the loop */
+    tasks: ReplTask[];
+}
+export interface CommandDetection {
+    buildCommand: string | null;
+    testCommand: string | null;
+    lintCommand: string | null;
+    /** Detected framework name (e.g., "vitest", "jest", "pytest") */
+    framework: string;
+    /** Whether auto-detection found anything */
+    detected: boolean;
+}
+/**
+ * Parse plan tasks from plan markdown content.
+ *
+ * Looks for unchecked checkbox items (`- [ ] ...`) in a `## Tasks` section.
+ * Falls back to any unchecked checkboxes anywhere in the document.
+ * Strips the `Task N:` prefix if present to get a clean description.
+ */
+export declare function parseTasksFromPlan(planContent: string): string[];
+/**
+ * Auto-detect build, test, and lint commands from project configuration files.
+ *
+ * Detection priority:
+ *   1. package.json (npm/node projects)
+ *   2. Makefile
+ *   3. Cargo.toml (Rust)
+ *   4. go.mod (Go)
+ *   5. pyproject.toml / setup.py (Python)
+ *   6. mix.exs (Elixir)
+ */
+export declare function detectCommands(cwd: string): Promise<CommandDetection>;
+/**
+ * Read the current REPL state from .cortex/repl-state.json.
+ * Returns null if no state file exists.
+ */
+export declare function readReplState(cwd: string): ReplState | null;
+/**
+ * Write REPL state to .cortex/repl-state.json.
+ * Uses atomic write (temp file + rename) to prevent corruption.
+ */
+export declare function writeReplState(cwd: string, state: ReplState): void;
+/**
+ * Get the next pending task (first task with status "pending").
+ * Returns null if all tasks are done.
+ */
+export declare function getNextTask(state: ReplState): ReplTask | null;
+/**
+ * Get the currently in-progress task.
+ * Returns null if no task is in progress.
+ */
+export declare function getCurrentTask(state: ReplState): ReplTask | null;
+/**
+ * Check if the loop is complete (no pending or in_progress tasks).
+ */
+export declare function isLoopComplete(state: ReplState): boolean;
+/**
+ * Format the current loop status as a human-readable string.
+ * Used by repl_status tool output.
+ */
+export declare function formatProgress(state: ReplState): string;
+/**
+ * Format a full summary of the loop results for PR body inclusion.
+ * Returns a markdown block with a results table, counts, and timing.
+ */
+export declare function formatSummary(state: ReplState): string;
+//# sourceMappingURL=repl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"repl.d.ts","sourceRoot":"","sources":["../../src/utils/repl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAaH,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,aAAa,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;AAErF,MAAM,WAAW,aAAa;IAC5B,sCAAsC;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,gCAAgC;IAChC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IACjC,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,QAAQ;IACvB,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,qCAAqC;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,0CAA0C;IAC1C,MAAM,EAAE,UAAU,CAAC;IACnB,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,6BAA6B;IAC7B,UAAU,EAAE,aAAa,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,SAAS;IACxB,2BAA2B;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mDAAmD;IACnD,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,kDAAkD;IAClD,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,4BAA4B;IAC5B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,kEAAkE;IAClE,UAAU,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,gBAAgB,EAAE,MAAM,CAAC;IACzB,4BAA4B;IAC5B,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,iEAAiE;IACjE,SAAS,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,QAAQ,EAAE,OAAO,CAAC;CACnB;AAID;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAsBhE;AA4BD;;;;;;;;;;GAUG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA6H3E;AAWD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAwB3D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAuBlE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,QAAQ,GAAG,IAAI,CAE7D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,QAAQ,GAAG,IAAI,CAEhE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAIxD;AAWD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAwEvD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CA+EtD"}