cortex-agents 2.1.0 → 2.3.0

package/dist/tools/cortex.d.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 export declare const init: {
     description: string;
     args: {};
@@ -8,4 +9,22 @@ export declare const status: {
     args: {};
     execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
+/**
+ * cortex_configure — Write per-project model configuration to ./opencode.json.
+ *
+ * Accepts a primary model (for build/plan/debug) and a subagent model
+ * (for fullstack/testing/security/devops). Merges into any existing
+ * opencode.json at the project root, preserving other settings.
+ */
+export declare const configure: {
+    description: string;
+    args: {
+        primaryModel: z.ZodString;
+        subagentModel: z.ZodString;
+    };
+    execute(args: {
+        primaryModel: string;
+        subagentModel: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
 //# sourceMappingURL=cortex.d.ts.map

package/dist/tools/cortex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cortex.d.ts","sourceRoot":"","sources":["../../src/tools/cortex.ts"],"names":[],"mappings":"AAkEA,eAAO,MAAM,IAAI;;;;CAkDf,CAAC;AAEH,eAAO,MAAM,MAAM;;;;CAyDjB,CAAC"}
+{"version":3,"file":"cortex.d.ts","sourceRoot":"","sources":["../../src/tools/cortex.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAqExB,eAAO,MAAM,IAAI;;;;CAkDf,CAAC;AAEH,eAAO,MAAM,MAAM;;;;CAyDjB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;CAkHpB,CAAC"}

package/dist/tools/cortex.js

@@ -1,11 +1,13 @@
 import { tool } from "@opencode-ai/plugin";
 import * as fs from "fs";
 import * as path from "path";
+import { z } from "zod";
+import { PRIMARY_AGENTS, SUBAGENTS, MODEL_REGISTRY, } from "../registry.js";
 const CORTEX_DIR = ".cortex";
 const DEFAULT_CONFIG = {
     version: "1.0.0",
     worktree: {
-        root: "../.worktrees",
+        root: ".worktrees",
         autoCleanup: false,
     },
     branches: {
@@ -146,3 +148,110 @@ Plans: ${planCount}`;
         return output;
     },
 });
+/**
+ * cortex_configure — Write per-project model configuration to ./opencode.json.
+ *
+ * Accepts a primary model (for build/plan/debug) and a subagent model
+ * (for fullstack/testing/security/devops). Merges into any existing
+ * opencode.json at the project root, preserving other settings.
+ */
+export const configure = tool({
+    description: "Save per-project model configuration to ./opencode.json. " +
+        "Sets the model for primary agents (build, plan, debug) and subagents (fullstack, testing, security, devops). " +
+        "Available models — Premium: " +
+        MODEL_REGISTRY.filter((m) => m.tier === "premium")
+            .map((m) => `${m.name} (${m.id})`)
+            .join(", ") +
+        ". Standard: " +
+        MODEL_REGISTRY.filter((m) => m.tier === "standard")
+            .map((m) => `${m.name} (${m.id})`)
+            .join(", ") +
+        ". Fast: " +
+        MODEL_REGISTRY.filter((m) => m.tier === "fast")
+            .map((m) => `${m.name} (${m.id})`)
+            .join(", ") +
+        ".",
+    args: {
+        primaryModel: z
+            .string()
+            .describe("Model ID for primary agents (build, plan, debug). Format: provider/model-name"),
+        subagentModel: z
+            .string()
+            .describe("Model ID for subagents (fullstack, testing, security, devops). Format: provider/model-name"),
+    },
+    async execute(args, context) {
+        const configPath = path.join(context.worktree, "opencode.json");
+        // Read existing config or start fresh
+        let config = {};
+        if (fs.existsSync(configPath)) {
+            try {
+                config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            }
+            catch {
+                // Malformed JSON — start fresh but warn
+                config = {};
+            }
+        }
+        // Ensure schema and plugin
+        if (!config.$schema) {
+            config.$schema = "https://opencode.ai/config.json";
+        }
+        const plugins = config.plugin ?? [];
+        if (!plugins.includes("cortex-agents")) {
+            plugins.push("cortex-agents");
+        }
+        config.plugin = plugins;
+        // Build agent config
+        const agent = config.agent ?? {};
+        for (const name of PRIMARY_AGENTS) {
+            if (!agent[name])
+                agent[name] = {};
+            agent[name].model = args.primaryModel;
+        }
+        for (const name of SUBAGENTS) {
+            if (!agent[name])
+                agent[name] = {};
+            agent[name].model = args.subagentModel;
+        }
+        config.agent = agent;
+        // Write to project root (runtime config — what OpenCode reads)
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+        // Also write .opencode/models.json (per-project source of truth, version controlled)
+        const modelsPath = path.join(context.worktree, ".opencode", "models.json");
+        const modelsDir = path.dirname(modelsPath);
+        if (fs.existsSync(modelsDir)) {
+            const modelsConfig = {
+                primary: { model: args.primaryModel },
+                subagent: { model: args.subagentModel },
+                agents: {},
+            };
+            const agentsMap = {};
+            for (const name of PRIMARY_AGENTS) {
+                agentsMap[name] = { model: args.primaryModel };
+            }
+            for (const name of SUBAGENTS) {
+                agentsMap[name] = { model: args.subagentModel };
+            }
+            modelsConfig.agents = agentsMap;
+            fs.writeFileSync(modelsPath, JSON.stringify(modelsConfig, null, 2) + "\n");
+        }
+        // Build summary
+        const primaryDisplay = MODEL_REGISTRY.find((m) => m.id === args.primaryModel)?.name ??
+            args.primaryModel;
+        const subagentDisplay = MODEL_REGISTRY.find((m) => m.id === args.subagentModel)?.name ??
+            args.subagentModel;
+        const savedTo = fs.existsSync(modelsDir)
+            ? `${configPath}\n  .opencode/models.json`
+            : configPath;
+        return `✓ Model configuration saved to:
+  ${savedTo}
+
+Primary agents (build, plan, debug):
+  → ${primaryDisplay} (${args.primaryModel})
+
+Subagents (fullstack, testing, security, devops):
+  → ${subagentDisplay} (${args.subagentModel})
+
+Restart OpenCode to apply changes.`;
+    },
+});

package/dist/tools/session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/tools/session.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;CAsFf,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;CA8Df,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;CAuBf,CAAC"}
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/tools/session.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;CAuFf,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;CA8Df,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;CAuBf,CAAC"}

package/dist/tools/session.js

@@ -1,6 +1,7 @@
 import { tool } from "@opencode-ai/plugin";
 import * as fs from "fs";
 import * as path from "path";
+import { git } from "../utils/shell.js";
 const CORTEX_DIR = ".cortex";
 const SESSIONS_DIR = "sessions";
 function getDatePrefix() {
@@ -51,7 +52,8 @@ export const save = tool({
         let currentBranch = branch;
         if (!currentBranch) {
             try {
-                currentBranch = (await Bun.$ `git branch --show-current`.cwd(context.worktree).text()).trim();
+                const { stdout } = await git(context.worktree, "branch", "--show-current");
+                currentBranch = stdout.trim();
             }
             catch {
                 currentBranch = "unknown";

package/dist/tools/task.d.ts

@@ -0,0 +1,20 @@
+export declare const finalize: {
+    description: string;
+    args: {
+        commitMessage: import("zod").ZodString;
+        prTitle: import("zod").ZodOptional<import("zod").ZodString>;
+        prBody: import("zod").ZodOptional<import("zod").ZodString>;
+        baseBranch: import("zod").ZodOptional<import("zod").ZodString>;
+        planFilename: import("zod").ZodOptional<import("zod").ZodString>;
+        draft: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        commitMessage: string;
+        prTitle?: string | undefined;
+        prBody?: string | undefined;
+        baseBranch?: string | undefined;
+        planFilename?: string | undefined;
+        draft?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+//# sourceMappingURL=task.d.ts.map

package/dist/tools/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/tools/task.ts"],"names":[],"mappings":"AAyGA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;CAqNnB,CAAC"}

package/dist/tools/task.js

@@ -0,0 +1,310 @@
+import { tool } from "@opencode-ai/plugin";
+import * as fs from "fs";
+import * as path from "path";
+import { detectWorktreeInfo } from "../utils/worktree-detect.js";
+import { findPlanContent, extractPlanSections, buildPrBodyFromPlan, } from "../utils/plan-extract.js";
+import { git, gh, which } from "../utils/shell.js";
+const PROTECTED_BRANCHES = ["main", "master", "develop", "production", "staging"];
+const DOCS_DIR = "docs";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+/**
+ * Check if `gh` CLI is installed and authenticated.
+ */
+async function checkGhCli(cwd) {
+    // Check if gh exists
+    const ghPath = await which("gh");
+    if (!ghPath) {
+        return {
+            ok: false,
+            error: "GitHub CLI (gh) is not installed. Install it from https://cli.github.com/ and run `gh auth login`.",
+        };
+    }
+    // Check if authenticated
+    try {
+        await gh(cwd, "auth", "status");
+    }
+    catch {
+        return {
+            ok: false,
+            error: "GitHub CLI is not authenticated. Run `gh auth login` to authenticate.",
+        };
+    }
+    return { ok: true };
+}
+/**
+ * Check if a remote named "origin" is configured.
+ */
+async function checkRemote(cwd) {
+    try {
+        const { stdout } = await git(cwd, "remote", "-v");
+        if (!stdout.includes("origin")) {
+            return {
+                ok: false,
+                error: "No 'origin' remote configured. Add one with: git remote add origin <url>",
+            };
+        }
+        return { ok: true };
+    }
+    catch {
+        return { ok: false, error: "Could not check git remotes." };
+    }
+}
+/**
+ * Check whether docs/ has any content beyond .gitkeep files.
+ */
+function checkDocsExist(worktree) {
+    const docsRoot = path.join(worktree, DOCS_DIR);
+    if (!fs.existsSync(docsRoot)) {
+        return { exists: false, count: 0 };
+    }
+    let count = 0;
+    const subDirs = ["decisions", "features", "flows"];
+    for (const sub of subDirs) {
+        const subPath = path.join(docsRoot, sub);
+        if (fs.existsSync(subPath)) {
+            const files = fs.readdirSync(subPath).filter((f) => f.endsWith(".md") && f !== ".gitkeep");
+            count += files.length;
+        }
+    }
+    return { exists: count > 0, count };
+}
+/**
+ * Get a summary of commits that will be in the PR (commits ahead of base).
+ */
+async function getCommitLog(cwd, baseBranch) {
+    try {
+        const { stdout } = await git(cwd, "log", `${baseBranch}..HEAD`, "--oneline");
+        return stdout.trim();
+    }
+    catch {
+        // If base branch doesn't exist locally, try origin/<base>
+        try {
+            const { stdout } = await git(cwd, "log", `origin/${baseBranch}..HEAD`, "--oneline");
+            return stdout.trim();
+        }
+        catch {
+            return "";
+        }
+    }
+}
+// ─── Tool ────────────────────────────────────────────────────────────────────
+export const finalize = tool({
+    description: "Finalize a completed task: stage all changes, commit, push to origin, and create a PR via GitHub CLI. " +
+        "Auto-detects worktrees and targets the main branch. " +
+        "Auto-populates the PR body from .cortex/plans/ if a plan exists. " +
+        "Run docs_list and session_save BEFORE calling this tool.",
+    args: {
+        commitMessage: tool.schema
+            .string()
+            .describe("Commit message in conventional format (e.g., 'feat: add worktree launch tool')"),
+        prTitle: tool.schema
+            .string()
+            .optional()
+            .describe("PR title (defaults to the commit message)"),
+        prBody: tool.schema
+            .string()
+            .optional()
+            .describe("Custom PR body in markdown. If omitted, auto-generated from .cortex/plans/ or commit log."),
+        baseBranch: tool.schema
+            .string()
+            .optional()
+            .describe("Target branch for PR (auto-detected: 'main' for worktrees, default branch otherwise)"),
+        planFilename: tool.schema
+            .string()
+            .optional()
+            .describe("Plan filename from .cortex/plans/ to include in PR body"),
+        draft: tool.schema
+            .boolean()
+            .optional()
+            .describe("Create as draft PR (default: false)"),
+    },
+    async execute(args, context) {
+        const { commitMessage, prTitle, prBody: customPrBody, baseBranch: customBaseBranch, planFilename, draft = false, } = args;
+        const cwd = context.worktree;
+        const output = [];
+        const warnings = [];
+        // ── 1. Validate: git repo ─────────────────────────────────
+        try {
+            await git(cwd, "rev-parse", "--git-dir");
+        }
+        catch {
+            return "✗ Error: Not in a git repository.";
+        }
+        // ── 2. Detect worktree + branch ───────────────────────────
+        const wtInfo = await detectWorktreeInfo(cwd);
+        const branchName = wtInfo.currentBranch;
+        if (!branchName || branchName === "(unknown)") {
+            return "✗ Error: Could not determine current branch.";
+        }
+        if (PROTECTED_BRANCHES.includes(branchName)) {
+            return `✗ Error: Cannot finalize on protected branch '${branchName}'.
+Create a feature/bugfix branch first with branch_create or worktree_create.`;
+        }
+        // ── 3. Determine base branch ──────────────────────────────
+        let baseBranch = customBaseBranch || "";
+        if (!baseBranch) {
+            if (wtInfo.isWorktree) {
+                baseBranch = "main";
+            }
+            else {
+                // Try to detect default branch from origin
+                try {
+                    const { stdout } = await git(cwd, "symbolic-ref", "refs/remotes/origin/HEAD");
+                    baseBranch = stdout.trim().replace("refs/remotes/origin/", "");
+                }
+                catch {
+                    baseBranch = "main"; // Sensible default
+                }
+            }
+        }
+        output.push(`Branch: ${branchName} → ${baseBranch}`);
+        if (wtInfo.isWorktree) {
+            output.push(`Worktree detected (main tree: ${wtInfo.mainWorktreePath})`);
+        }
+        // ── 4. Check prerequisites ────────────────────────────────
+        const ghCheck = await checkGhCli(cwd);
+        if (!ghCheck.ok) {
+            return `✗ ${ghCheck.error}`;
+        }
+        const remoteCheck = await checkRemote(cwd);
+        if (!remoteCheck.ok) {
+            return `✗ ${remoteCheck.error}`;
+        }
+        // ── 5. Check docs (warning only) ─────────────────────────
+        const docsCheck = checkDocsExist(cwd);
+        if (!docsCheck.exists) {
+            warnings.push("No documentation found in docs/. Consider creating docs with docs_save before finalizing.");
+        }
+        else {
+            output.push(`Documentation: ${docsCheck.count} doc(s) found`);
+        }
+        // ── 6. Stage all changes ──────────────────────────────────
+        try {
+            await git(cwd, "add", "-A");
+        }
+        catch (error) {
+            return `✗ Error staging changes: ${error.message || error}`;
+        }
+        // ── 7. Commit ─────────────────────────────────────────────
+        let commitHash = "";
+        let commitSkipped = false;
+        try {
+            // Check if there's anything to commit
+            const { stdout: statusOut } = await git(cwd, "status", "--porcelain");
+            if (!statusOut.trim()) {
+                commitSkipped = true;
+                output.push("No new changes to commit (working tree clean)");
+            }
+            else {
+                await git(cwd, "commit", "-m", commitMessage);
+                const { stdout: hashOut } = await git(cwd, "rev-parse", "--short", "HEAD");
+                commitHash = hashOut.trim();
+                output.push(`Committed: ${commitHash} — ${commitMessage}`);
+            }
+        }
+        catch (error) {
+            return `✗ Error committing: ${error.message || error}`;
+        }
+        // ── 8. Push to origin ─────────────────────────────────────
+        try {
+            await git(cwd, "push", "-u", "origin", branchName);
+            output.push(`Pushed to origin/${branchName}`);
+        }
+        catch (error) {
+            return `✗ Error pushing to origin: ${error.message || error}
+
+All previous steps succeeded (changes committed). Try pushing manually:
+  git push -u origin ${branchName}`;
+        }
+        // ── 9. Build PR body ──────────────────────────────────────
+        let prBodyContent = customPrBody || "";
+        if (!prBodyContent) {
+            // Try to build from plan
+            const plan = findPlanContent(cwd, planFilename, branchName);
+            if (plan) {
+                const sections = extractPlanSections(plan.content, plan.filename);
+                prBodyContent = buildPrBodyFromPlan(sections);
+                output.push(`PR body generated from plan: ${plan.filename}`);
+            }
+            else {
+                // Fall back to commit log
+                const commitLog = await getCommitLog(cwd, baseBranch);
+                if (commitLog) {
+                    prBodyContent = `## Changes\n\n\`\`\`\n${commitLog}\n\`\`\``;
+                }
+                else {
+                    prBodyContent = `Implementation on branch \`${branchName}\``;
+                }
+            }
+        }
+        // ── 10. Create PR via gh ──────────────────────────────────
+        const finalPrTitle = prTitle || commitMessage;
+        let prUrl = "";
+        try {
+            // Check if PR already exists for this branch
+            const { stdout: existingPr } = await gh(cwd, "pr", "view", branchName, "--json", "url", "--jq", ".url");
+            if (existingPr.trim()) {
+                prUrl = existingPr.trim();
+                output.push(`PR already exists: ${prUrl}`);
+            }
+            else {
+                prUrl = await createPr(cwd, baseBranch, finalPrTitle, prBodyContent, draft);
+                output.push(`PR created: ${prUrl}`);
+            }
+        }
+        catch {
+            // PR doesn't exist yet, create it
+            try {
+                prUrl = await createPr(cwd, baseBranch, finalPrTitle, prBodyContent, draft);
+                output.push(`PR created: ${prUrl}`);
+            }
+            catch (error) {
+                // PR creation failed but everything else succeeded
+                output.push(`⚠ PR creation failed: ${error.message || error}`);
+                output.push("");
+                output.push("Changes are committed and pushed. Create the PR manually:");
+                output.push(`  gh pr create --base ${baseBranch} --title "${finalPrTitle}"`);
+            }
+        }
+        // ── Build final output ────────────────────────────────────
+        let finalOutput = `✓ Task finalized\n\n`;
+        finalOutput += output.join("\n");
+        if (warnings.length > 0) {
+            finalOutput += `\n\nWarnings:\n${warnings.map((w) => `  ⚠ ${w}`).join("\n")}`;
+        }
+        if (wtInfo.isWorktree) {
+            finalOutput += `\n\nThis is a worktree. When the PR is merged, you can clean up with:
+  worktree_remove (name: "${path.basename(cwd)}", deleteBranch: true)`;
+        }
+        return finalOutput;
+    },
+});
+/**
+ * Create a PR using gh CLI with array-based args (no shell injection).
+ * Uses a temp body file to avoid shell escaping issues with PR body content.
+ */
+async function createPr(cwd, baseBranch, title, body, draft) {
+    const bodyFile = path.join(cwd, ".cortex", ".pr-body-tmp.md");
+    const cortexDir = path.join(cwd, ".cortex");
+    if (!fs.existsSync(cortexDir)) {
+        fs.mkdirSync(cortexDir, { recursive: true });
+    }
+    fs.writeFileSync(bodyFile, body);
+    try {
+        const createArgs = [
+            "pr", "create",
+            "--base", baseBranch,
+            "--title", title,
+            "--body-file", bodyFile,
+        ];
+        if (draft)
+            createArgs.push("--draft");
+        const { stdout } = await gh(cwd, ...createArgs);
+        return stdout.trim();
+    }
+    finally {
+        if (fs.existsSync(bodyFile)) {
+            fs.unlinkSync(bodyFile);
+        }
+    }
+}

package/dist/tools/worktree.d.ts

@@ -1,4 +1,11 @@
-export declare const create: {
+import type { PluginInput } from "@opencode-ai/plugin";
+type Client = PluginInput["client"];
+type Shell = PluginInput["$"];
+/**
+ * Factory function that creates the worktree_create tool with access
+ * to the OpenCode client for toast notifications.
+ */
+export declare function createCreate(client: Client): {
     description: string;
     args: {
         name: import("zod").ZodString;
@@ -22,7 +29,11 @@ export declare const list: {
     args: {};
     execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
-export declare const remove: {
+/**
+ * Factory function that creates the worktree_remove tool with access
+ * to the OpenCode client for toast notifications and PTY cleanup.
+ */
+export declare function createRemove(client: Client): {
     description: string;
     args: {
         name: import("zod").ZodString;
@@ -42,4 +53,33 @@ export declare const open: {
         name: string;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
+/**
+ * Factory function that creates the worktree_launch tool with access
+ * to the OpenCode client (for PTY and toast) and shell.
+ *
+ * This uses a closure to capture `client` and `shell` since ToolContext
+ * does not provide access to the OpenCode client API.
+ */
+export declare function createLaunch(client: Client, shell: Shell): {
+    description: string;
+    args: {
+        name: import("zod").ZodString;
+        mode: import("zod").ZodEnum<{
+            terminal: "terminal";
+            pty: "pty";
+            background: "background";
+        }>;
+        plan: import("zod").ZodOptional<import("zod").ZodString>;
+        agent: import("zod").ZodOptional<import("zod").ZodString>;
+        prompt: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        name: string;
+        mode: "terminal" | "pty" | "background";
+        plan?: string | undefined;
+        agent?: string | undefined;
+        prompt?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export {};
 //# sourceMappingURL=worktree.d.ts.map

package/dist/tools/worktree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worktree.d.ts","sourceRoot":"","sources":["../../src/tools/worktree.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;CA8DjB,CAAC;AAEH,eAAO,MAAM,IAAI;;;;CAiCf,CAAC;AAEH,eAAO,MAAM,MAAM;;;;;;;;;;CA4DjB,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;CAgDf,CAAC"}
+{"version":3,"file":"worktree.d.ts","sourceRoot":"","sources":["../../src/tools/worktree.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAiBvD,KAAK,MAAM,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;AACpC,KAAK,KAAK,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;AAE9B;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;EAuF1C;AAED,eAAO,MAAM,IAAI;;;;CAiCf,CAAC;AAEH;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;EAkI1C;AAED,eAAO,MAAM,IAAI;;;;;;;;CAgDf,CAAC;AAkUH;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK;;;;;;;;;;;;;;;;;;;;EAsIxD"}