opencode-swarm-plugin 0.30.0 → 0.30.2

package/.turbo/turbo-build.log

@@ -1,9 +1,9 @@
 $ bun build ./src/index.ts --outdir ./dist --target node --external @electric-sql/pglite --external swarm-mail && bun build ./src/plugin.ts --outfile ./dist/plugin.js --target node --external @electric-sql/pglite --external swarm-mail && tsc
-Bundled 200 modules in 34ms
+Bundled 811 modules in 121ms
 
-  index.js  1.20 MB  (entry point)
+  index.js  1.71 MB  (entry point)
 
-Bundled 201 modules in 44ms
+Bundled 812 modules in 142ms
 
-  plugin.js  1.16 MB  (entry point)
+  plugin.js  1.67 MB  (entry point)
 

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # opencode-swarm-plugin
 
+## 0.30.2
+
+### Patch Changes
+
+- [`5858148`](https://github.com/joelhooks/swarm-tools/commit/5858148d5785393c0a6993a2595fba275f305707) Thanks [@joelhooks](https://github.com/joelhooks)! - chore: trigger publish workflow
+
+## 0.30.1
+
+### Patch Changes
+
+- [`57d5600`](https://github.com/joelhooks/swarm-tools/commit/57d5600a53e148ce1d1da48b3b5a8723a5552e04) Thanks [@joelhooks](https://github.com/joelhooks)! - ## 🚦 Review Gate UX Fix + Verbose Setup
+
+  > _"A common mistake that people make when trying to design something completely foolproof is to underestimate the ingenuity of complete fools."_
+  > — Douglas Adams, _Mostly Harmless_
+
+  Two UX improvements that make swarm coordination feel less like shouting into the void.
+
+  ### What Changed
+
+  **Review Gate Response Fix:**
+
+  - `swarm_complete` no longer returns `success: false` when code review is pending
+  - Now returns `success: true` with `status: "pending_review"` or `status: "needs_changes"`
+  - **Why it matters**: The old format made review checkpoints look like errors. Agents would retry unnecessarily or report failures when the workflow was actually working as designed. Review gates are a feature, not a bug.
+
+  **Setup Command Verbosity:**
+
+  - Added `p.log.step()` and `p.log.success()` throughout swarm setup
+  - Users can now see exactly what's happening: dependency checks, git init, swarm-mail connection
+  - **Why it matters**: Silent setup commands feel broken. Explicit progress logs build trust and make debugging easier when setup actually does fail.
+
+  ### Why It Matters
+
+  **For Agents:**
+
+  - No more false-negative responses from review gates
+  - Clear workflow state (pending vs. needs changes vs. complete)
+  - Reduced retry loops and error noise
+
+  **For Users:**
+
+  - Setup command shows its work (not a black box)
+  - Review process is transparent in logs
+  - Easier to diagnose when things actually break
+
+  **Backward compatible:** Yes. Existing agents checking for `success: false` will still work, they just won't see false errors anymore.
+
 ## 0.30.0
 
 ### Minor Changes

package/README.md

@@ -220,7 +220,8 @@ These tools significantly enhance the swarm experience:
 |------|---------|---------|
 | [CASS](https://github.com/Dicklesworthstone/coding_agent_session_search) | Historical context - queries past sessions for similar decompositions | See below |
 | [UBS](https://github.com/Dicklesworthstone/ultimate_bug_scanner) | Bug scanning - runs on subtask completion to catch issues | See below |
-| [semantic-memory](https://github.com/joelhooks/semantic-memory) | Learning persistence - stores patterns across sessions | Requires Ollama (see above) |
+
+> **Note:** Semantic memory is now embedded in the plugin. No separate installation needed - just install Ollama for vector embeddings.
 
 #### Installing CASS
 
@@ -243,15 +244,11 @@ cd ultimate_bug_scanner
 pip install -e .
 ```
 
-#### Installing semantic-memory
-
-The `semantic-memory_check` tool verifies Ollama is ready (see installation steps above).
-
 **Why install these?**
 
 - **CASS** - When you run `/swarm "Add OAuth"`, the coordinator queries CASS for similar past tasks. Without it, decomposition is based only on the current task description.
 - **UBS** - Every `swarm_complete` runs UBS to scan for bugs. Without it, you lose automatic bug detection.
-- **semantic-memory** - Pattern maturity and anti-pattern detection persist across sessions. Without it, learning resets each session.
+- **Ollama** - Enables vector similarity search for semantic memory. Without it, memory falls back to full-text search (still functional, less semantic).
 
 Run `swarm doctor` to check which dependencies are installed.
 

package/bin/swarm.ts

@@ -35,6 +35,12 @@ import {
   ensureHiveDirectory,
   getHiveAdapter,
 } from "../src/hive";
+import {
+  legacyDatabaseExists,
+  getMigrationStatus,
+  migrateLegacyMemories,
+} from "swarm-mail";
+import { getSwarmMail } from "swarm-mail";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(
@@ -427,22 +433,13 @@ const DEPENDENCIES: Dependency[] = [
     description: "AI-powered static analysis for pre-completion bug scanning",
   },
   {
-    name: "semantic-memory",
-    command: "semantic-memory",
-    checkArgs: ["stats"],
-    required: false,
-    install: "npm install -g semantic-memory",
-    installType: "npm",
-    description: "Learning persistence with vector search",
-  },
-  {
-    name: "Redis",
-    command: "redis-cli",
-    checkArgs: ["ping"],
+    name: "Ollama",
+    command: "ollama",
+    checkArgs: ["--version"],
     required: false,
-    install: "brew install redis && brew services start redis",
+    install: "brew install ollama && ollama pull mxbai-embed-large",
     installType: "brew",
-    description: "Rate limiting (SQLite fallback available)",
+    description: "Local embeddings for semantic memory (embedded in plugin)",
   },
 ];
 
@@ -1229,8 +1226,8 @@ function getFixCommand(dep: Dependency): string | null {
   switch (dep.name) {
     case "OpenCode":
       return "brew install sst/tap/opencode";
-    case "semantic-memory":
-      return "npm install -g semantic-memory";
+    case "Ollama":
+      return "brew install ollama && ollama pull mxbai-embed-large";
     case "Redis":
       return "brew install redis && brew services start redis";
     case "CASS (Coding Agent Session Search)":
@@ -1382,6 +1379,7 @@ async function setup() {
   let isReinstall = false;
 
   // Check if already configured FIRST
+  p.log.step("Checking existing configuration...");
   const configDir = join(homedir(), ".config", "opencode");
   const pluginDir = join(configDir, "plugin");
   const commandDir = join(configDir, "command");
@@ -1492,6 +1490,8 @@ async function setup() {
     }
     if (action === "reinstall") {
       isReinstall = true;
+      p.log.step("Reinstalling swarm configuration...");
+      p.log.message(dim("  This will check dependencies, sync skills, and update config files"));
     }
     // action === "reinstall" - fall through to full setup
   }
@@ -1622,11 +1622,13 @@ async function setup() {
   }
 
   // Check for .beads → .hive migration
+  p.log.step("Checking for legacy .beads directory...");
   const cwd = process.cwd();
   const migrationCheck = checkBeadsMigrationNeeded(cwd);
   if (migrationCheck.needed) {
-    p.log.step("Legacy .beads directory detected");
-    p.log.message(dim("  Found: " + migrationCheck.beadsPath));
+    p.log.warn("Found legacy .beads directory");
+    p.log.message(dim("  Path: " + migrationCheck.beadsPath));
+    p.log.message(dim("  Will rename to .hive/ and merge history"));
     
     const shouldMigrate = await p.confirm({
       message: "Migrate .beads to .hive? (recommended)",
@@ -1645,17 +1647,23 @@ async function setup() {
       try {
         const result = await migrateBeadsToHive(cwd);
         if (result.migrated) {
-          migrateSpinner.stop("Migration complete");
-          p.log.success("Renamed .beads/ → .hive/");
+          migrateSpinner.stop("Renamed .beads/ → .hive/");
+          p.log.success("Directory migration complete");
           
           // Merge historic beads into issues.jsonl
+          migrateSpinner.start("Merging historic cells...");
           const mergeResult = await mergeHistoricBeads(cwd);
           if (mergeResult.merged > 0) {
-            p.log.success(`Merged ${mergeResult.merged} historic beads (${mergeResult.skipped} already present)`);
+            migrateSpinner.stop("Historic cells merged");
+            p.log.success(`Merged ${mergeResult.merged} cells (${mergeResult.skipped} already present)`);
+          } else {
+            migrateSpinner.stop("No historic cells to merge");
           }
           
           // Import JSONL into PGLite database
+          migrateSpinner.start("Importing to database...");
           const importResult = await importJsonlToPGLite(cwd);
+          migrateSpinner.stop("Database import complete");
           if (importResult.imported > 0 || importResult.updated > 0) {
             p.log.success(`Database: ${importResult.imported} imported, ${importResult.updated} updated`);
           }
@@ -1670,10 +1678,121 @@ async function setup() {
     } else {
       p.log.warn("Skipping migration - .beads will continue to work but is deprecated");
     }
+  } else {
+    p.log.message(dim("  No legacy .beads directory found"));
+  }
+
+  // Check for legacy semantic-memory migration
+  p.log.step("Checking for legacy semantic-memory database...");
+  if (legacyDatabaseExists()) {
+    p.log.warn("Found legacy semantic-memory database");
+    
+    const migrationStatus = await getMigrationStatus();
+    if (migrationStatus) {
+      const { total, withEmbeddings } = migrationStatus;
+      p.log.message(dim(`  Memories: ${total} total (${withEmbeddings} with embeddings)`));
+      p.log.message(dim(`  Will migrate to swarm-mail unified database`));
+      
+      const shouldMigrate = await p.confirm({
+        message: "Migrate to swarm-mail database? (recommended)",
+        initialValue: true,
+      });
+
+      if (p.isCancel(shouldMigrate)) {
+        p.cancel("Setup cancelled");
+        process.exit(0);
+      }
+
+      if (shouldMigrate) {
+        const migrateSpinner = p.spinner();
+        migrateSpinner.start("Connecting to target database...");
+        
+        try {
+          // Get swarm-mail database for this project
+          const targetDb = await getSwarmMail(cwd);
+          migrateSpinner.message("Migrating memories...");
+          
+          // Run migration with progress updates
+          const result = await migrateLegacyMemories({
+            targetDb,
+            onProgress: (msg) => {
+              // Update spinner message for key milestones
+              if (msg.includes("complete") || msg.includes("Progress:")) {
+                migrateSpinner.message(msg.replace("[migrate] ", ""));
+              }
+            },
+          });
+          
+          migrateSpinner.stop("Semantic memory migration complete");
+          
+          if (result.migrated > 0) {
+            p.log.success(`Migrated ${result.migrated} memories to swarm-mail`);
+          }
+          if (result.skipped > 0) {
+            p.log.message(dim(`  Skipped ${result.skipped} (already exist)`));
+          }
+          if (result.failed > 0) {
+            p.log.warn(`Failed to migrate ${result.failed} memories`);
+            for (const error of result.errors.slice(0, 3)) {
+              p.log.message(dim(`  ${error}`));
+            }
+            if (result.errors.length > 3) {
+              p.log.message(dim(`  ... and ${result.errors.length - 3} more errors`));
+            }
+          }
+        } catch (error) {
+          migrateSpinner.stop("Migration failed");
+          p.log.error(error instanceof Error ? error.message : String(error));
+        }
+      } else {
+        p.log.warn("Skipping migration - legacy semantic-memory will continue to work but is deprecated");
+      }
+    }
+  } else {
+    p.log.message(dim("  No legacy semantic-memory database found"));
+  }
+
+  // Check for legacy semantic-memory MCP server in OpenCode config
+  p.log.step("Checking for legacy MCP servers...");
+  const opencodeConfigPath = join(configDir, 'config.json');
+  if (existsSync(opencodeConfigPath)) {
+    try {
+      const opencodeConfig = JSON.parse(readFileSync(opencodeConfigPath, 'utf-8'));
+      if (opencodeConfig.mcpServers?.['semantic-memory']) {
+        p.log.warn('Found legacy semantic-memory MCP server');
+        p.log.message(dim('  Semantic memory is now embedded in the plugin'));
+        
+        const removeMcp = await p.confirm({
+          message: 'Remove from MCP servers config?',
+          initialValue: true,
+        });
+
+        if (p.isCancel(removeMcp)) {
+          p.cancel('Setup cancelled');
+          process.exit(0);
+        }
+
+        if (removeMcp) {
+          delete opencodeConfig.mcpServers['semantic-memory'];
+          writeFileSync(opencodeConfigPath, JSON.stringify(opencodeConfig, null, 2));
+          p.log.success('Removed semantic-memory from MCP servers');
+          p.log.message(dim(`  Updated: ${opencodeConfigPath}`));
+        } else {
+          p.log.warn('Keeping legacy MCP - you may see duplicate semantic-memory tools');
+        }
+      } else {
+        p.log.message(dim('  No legacy MCP servers found'));
+      }
+    } catch (error) {
+      p.log.message(dim('  Could not parse OpenCode config (skipping MCP check)'));
+    }
+  } else {
+    p.log.message(dim('  No OpenCode config found (skipping MCP check)'));
   }
 
   // Model selection
-  p.log.step("Configure swarm agents...");
+  p.log.step("Configuring swarm agents...");
+  p.log.message(dim("  Coordinator handles orchestration, worker executes tasks"));
 
   const coordinatorModel = await p.select({
     message: "Select coordinator model (for orchestration/planning):",
@@ -1769,27 +1888,37 @@ async function setup() {
     process.exit(0);
   }
 
+  p.log.success("Selected models:");
+  p.log.message(dim(`  Coordinator: ${coordinatorModel}`));
+  p.log.message(dim(`  Worker: ${workerModel}`));
+
   p.log.step("Setting up OpenCode integration...");
 
   // Track file operation statistics
   const stats: FileStats = { created: 0, updated: 0, unchanged: 0 };
 
   // Create directories if needed
+  p.log.step("Creating configuration directories...");
   const skillsDir = join(configDir, "skills");
   for (const dir of [pluginDir, commandDir, agentDir, swarmAgentDir, skillsDir]) {
     mkdirWithStatus(dir);
   }
 
   // Write plugin and command files
+  p.log.step("Writing configuration files...");
   stats[writeFileWithStatus(pluginPath, getPluginWrapper(), "Plugin")]++;
   stats[writeFileWithStatus(commandPath, SWARM_COMMAND, "Command")]++;
 
   // Write nested agent files (swarm/planner.md, swarm/worker.md)
   // This is the format used by Task(subagent_type="swarm/worker")
+  p.log.step("Writing agent configuration...");
   stats[writeFileWithStatus(plannerAgentPath, getPlannerAgent(coordinatorModel as string), "Planner agent")]++;
   stats[writeFileWithStatus(workerAgentPath, getWorkerAgent(workerModel as string), "Worker agent")]++;
 
   // Clean up legacy flat agent files if they exist
+  if (existsSync(legacyPlannerPath) || existsSync(legacyWorkerPath)) {
+    p.log.step("Cleaning up legacy agent files...");
+  }
   rmWithStatus(legacyPlannerPath, "legacy planner");
   rmWithStatus(legacyWorkerPath, "legacy worker");
 

package/dist/hive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hive.d.ts","sourceRoot":"","sources":["../src/hive.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"hive.d.ts","sourceRoot":"","sources":["../src/hive.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -34,6 +34,7 @@ import type { Plugin } from "@opencode-ai/plugin";
  * - repo-crawl:* - GitHub API tools for repository research
  * - skills:* - Agent skills discovery, activation, and execution
  * - mandate:* - Agent voting system for collaborative knowledge curation
+ * - semantic-memory:* - Semantic memory with vector embeddings (Ollama + PGLite)
  *
  * @param input - Plugin context from OpenCode
  * @returns Plugin hooks including tools, events, and tool execution hooks
@@ -138,6 +139,84 @@ export { swarmTools, SwarmError, DecompositionError, formatSubtaskPrompt, format
  * Note: hiveTools includes both hive_* and beads_* (legacy aliases)
  */
 export declare const allTools: {
+    readonly "semantic-memory_store": {
+        description: string;
+        args: {
+            information: import("zod").ZodString;
+            collection: import("zod").ZodOptional<import("zod").ZodString>;
+            tags: import("zod").ZodOptional<import("zod").ZodString>;
+            metadata: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            information: string;
+            collection?: string | undefined;
+            tags?: string | undefined;
+            metadata?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_find": {
+        description: string;
+        args: {
+            query: import("zod").ZodString;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            collection: import("zod").ZodOptional<import("zod").ZodString>;
+            expand: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            fts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            query: string;
+            limit?: number | undefined;
+            collection?: string | undefined;
+            expand?: boolean | undefined;
+            fts?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_get": {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_remove": {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_validate": {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_list": {
+        description: string;
+        args: {
+            collection: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            collection?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_stats": {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_check": {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
     readonly mandate_file: {
         description: string;
         args: {
@@ -1441,4 +1520,19 @@ export { guardrailOutput, truncateWithBoundaries, createMetrics, DEFAULT_GUARDRA
  * ```
  */
 export { SWARM_COMPACTION_CONTEXT, createCompactionHook } from "./compaction-hook";
+/**
+ * Re-export memory module
+ *
+ * Includes:
+ * - memoryTools - All semantic-memory tools (store, find, get, remove, validate, list, stats, check)
+ * - createMemoryAdapter - Factory function for memory adapter
+ * - resetMemoryCache - Cache management for testing
+ *
+ * Types:
+ * - MemoryAdapter - Memory adapter interface
+ * - StoreArgs, FindArgs, IdArgs, ListArgs - Tool argument types
+ * - StoreResult, FindResult, StatsResult, HealthResult, OperationResult - Result types
+ */
+export { memoryTools, createMemoryAdapter, resetMemoryCache, type MemoryAdapter, type StoreArgs, type FindArgs, type IdArgs, type ListArgs, type StoreResult, type FindResult, type StatsResult, type HealthResult, type OperationResult, } from "./memory-tools";
+export type { Memory, SearchResult, SearchOptions } from "swarm-mail";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,MAAM,EAAsB,MAAM,qBAAqB,CAAC;AAqCtE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,WAAW,EAAE,MAuLzB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAe,WAAW,CAAC;AAM3B;;GAEG;AACH,cAAc,WAAW,CAAC;AAE1B;;;;;;;;;;;GAWG;AACH,cAAc,QAAQ,CAAC;AAEvB;;;;;;;;;;;;GAYG;AACH,OAAO,EACL,cAAc,EACd,cAAc,EACd,4BAA4B,EAC5B,4BAA4B,EAC5B,oBAAoB,EACpB,4BAA4B,EAC5B,4BAA4B,EAC5B,mBAAmB,EACnB,sBAAsB,EACtB,oBAAoB,EACpB,KAAK,cAAc,GACpB,MAAM,cAAc,CAAC;AAEtB;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EACL,cAAc,EACd,4BAA4B,EAC5B,4BAA4B,EAC5B,iBAAiB,EACjB,KAAK,cAAc,GACpB,MAAM,cAAc,CAAC;AAEtB;;;;;GAKG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;;;;;GAMG;AACH,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,eAAe,EACf,eAAe,GAChB,MAAM,cAAc,CAAC;AAEtB;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EACL,UAAU,EACV,UAAU,EACV,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACrB,sBAAsB,EACtB,iBAAiB,EAEjB,UAAU,EACV,cAAc,EACd,wBAAwB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,GACxB,MAAM,SAAS,CAAC;AAMjB;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWX,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,QAAQ,CAAC;AAEhD;;;;;;;;;;;;;GAaG;AACH,OAAO,EACL,aAAa,EACb,yBAAyB,EACzB,UAAU,EACV,UAAU,EACV,YAAY,EACZ,eAAe,EACf,qBAAqB,EACrB,yBAAyB,EACzB,sBAAsB,EACtB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,kBAAkB,GACxB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;;;;;GAaG;AACH,OAAO,EACL,SAAS,EACT,eAAe,EACf,aAAa,EACb,mBAAmB,EACnB,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,WAAW,EACX,sBAAsB,EACtB,cAAc,EACd,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,gBAAgB,GACtB,MAAM,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9D;;;;;;;;;;;;;;GAcG;AACH,OAAO,EACL,WAAW,EACX,cAAc,EACd,QAAQ,EACR,UAAU,EACV,gBAAgB,EAChB,yBAAyB,EACzB,qBAAqB,EACrB,wBAAwB,EACxB,kBAAkB,EAClB,KAAK,KAAK,EACV,KAAK,aAAa,EAClB,KAAK,QAAQ,GACd,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAExD;;;;;;;;;;;;GAYG;AACH,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACnB,wBAAwB,EACxB,sBAAsB,EACtB,4BAA4B,EAC5B,8BAA8B,EAC9B,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,GAC/B,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;;GAWG;AACH,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,qBAAqB,EACrB,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,eAAe,GACrB,MAAM,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;GAaG;AACH,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,aAAa,EACb,wBAAwB,EACxB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACtB,MAAM,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,wBAAwB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEnF;;;;;;;;;;;;GAYG;AACH,OAAO,EACL,WAAW,EACX,mBAAmB,EACnB,gBAAgB,EAChB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,eAAe,GACrB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC"}