opencode-swarm-plugin 0.29.0 → 0.30.2

package/bin/swarm.ts

@@ -32,7 +32,15 @@ import {
   migrateBeadsToHive,
   mergeHistoricBeads,
   importJsonlToPGLite,
+  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(
@@ -71,6 +79,68 @@ const magenta = (s: string) => `\x1b[35m${s}\x1b[0m`;
 
 const PACKAGE_NAME = "opencode-swarm-plugin";
 
+// ============================================================================
+// File Operation Helpers
+// ============================================================================
+
+type FileStatus = "created" | "updated" | "unchanged";
+
+interface FileStats {
+  created: number;
+  updated: number;
+  unchanged: number;
+}
+
+/**
+ * Write a file with status logging (created/updated/unchanged)
+ * @param path - File path to write
+ * @param content - Content to write
+ * @param label - Label for logging (e.g., "Plugin", "Command")
+ * @returns Status of the operation
+ */
+function writeFileWithStatus(path: string, content: string, label: string): FileStatus {
+  const exists = existsSync(path);
+  
+  if (exists) {
+    const current = readFileSync(path, "utf-8");
+    if (current === content) {
+      p.log.message(dim(`  ${label}: ${path} (unchanged)`));
+      return "unchanged";
+    }
+  }
+  
+  writeFileSync(path, content);
+  const status: FileStatus = exists ? "updated" : "created";
+  p.log.success(`${label}: ${path} (${status})`);
+  return status;
+}
+
+/**
+ * Create a directory with logging
+ * @param path - Directory path to create
+ * @returns true if created, false if already exists
+ */
+function mkdirWithStatus(path: string): boolean {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+    p.log.message(dim(`  Created directory: ${path}`));
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Remove a file with logging
+ * @param path - File path to remove
+ * @param label - Label for logging
+ */
+function rmWithStatus(path: string, label: string): void {
+  if (existsSync(path)) {
+    rmSync(path);
+    p.log.message(dim(`  Removed ${label}: ${path}`));
+  }
+}
+
 // ============================================================================
 // Seasonal Messages (inspired by Astro's Houston)
 // ============================================================================
@@ -363,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)",
   },
 ];
 
@@ -1165,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)":
@@ -1318,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");
@@ -1428,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
   }
@@ -1558,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)",
@@ -1581,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`);
           }
@@ -1606,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):",
@@ -1705,41 +1888,41 @@ 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]) {
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
+    mkdirWithStatus(dir);
   }
 
-  writeFileSync(pluginPath, getPluginWrapper());
-  p.log.success("Plugin: " + pluginPath);
-
-  writeFileSync(commandPath, SWARM_COMMAND);
-  p.log.success("Command: " + commandPath);
+  // 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")
-  writeFileSync(plannerAgentPath, getPlannerAgent(coordinatorModel as string));
-  p.log.success("Planner agent: " + plannerAgentPath);
-
-  writeFileSync(workerAgentPath, getWorkerAgent(workerModel as string));
-  p.log.success("Worker agent: " + workerAgentPath);
+  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)) {
-    rmSync(legacyPlannerPath);
-    p.log.message(dim("  Removed legacy: " + legacyPlannerPath));
-  }
-  if (existsSync(legacyWorkerPath)) {
-    rmSync(legacyWorkerPath);
-    p.log.message(dim("  Removed legacy: " + legacyWorkerPath));
+  if (existsSync(legacyPlannerPath) || existsSync(legacyWorkerPath)) {
+    p.log.step("Cleaning up legacy agent files...");
   }
+  rmWithStatus(legacyPlannerPath, "legacy planner");
+  rmWithStatus(legacyWorkerPath, "legacy worker");
 
-  p.log.success("Skills directory: " + skillsDir);
+  p.log.message(dim(`  Skills directory: ${skillsDir}`));
 
   // Show bundled skills info (and optionally sync to global skills dir)
   const bundledSkillsPath = join(__dirname, "..", "global-skills");
@@ -1850,17 +2033,29 @@ async function setup() {
     }
   }
 
+  // Show setup summary
+  const totalFiles = stats.created + stats.updated + stats.unchanged;
+  const summaryParts: string[] = [];
+  if (stats.created > 0) summaryParts.push(`${stats.created} created`);
+  if (stats.updated > 0) summaryParts.push(`${stats.updated} updated`);
+  if (stats.unchanged > 0) summaryParts.push(`${stats.unchanged} unchanged`);
+  
+  p.log.message("");
+  p.log.success(`Setup complete: ${totalFiles} files (${summaryParts.join(", ")})`);
+
   p.note(
-    'cd your-project\nbd init\nopencode\n/swarm "your task"\n\nSkills: Use skills_list to see available skills',
+    'cd your-project\nswarm init\nopencode\n/swarm "your task"\n\nSkills: Use skills_list to see available skills',
     "Next steps",
   );
 
-  p.outro("Setup complete! Run 'swarm doctor' to verify.");
+  p.outro("Run 'swarm doctor' to verify installation.");
 }
 
 async function init() {
   p.intro("swarm init v" + VERSION);
 
+  const projectPath = process.cwd();
+
   const gitDir = existsSync(".git");
   if (!gitDir) {
     p.log.error("Not in a git repository");
@@ -1869,12 +2064,15 @@ async function init() {
     process.exit(1);
   }
 
+  // Check for existing .hive or .beads directories
+  const hiveDir = existsSync(".hive");
   const beadsDir = existsSync(".beads");
-  if (beadsDir) {
-    p.log.warn("Beads already initialized in this project");
+  
+  if (hiveDir) {
+    p.log.warn("Hive already initialized in this project (.hive/ exists)");
 
     const reinit = await p.confirm({
-      message: "Re-initialize beads?",
+      message: "Continue anyway?",
       initialValue: false,
     });
 
@@ -1882,25 +2080,54 @@ async function init() {
       p.outro("Aborted");
       process.exit(0);
     }
+  } else if (beadsDir) {
+    // Offer migration from .beads to .hive
+    p.log.warn("Found legacy .beads/ directory");
+    
+    const migrate = await p.confirm({
+      message: "Migrate .beads/ to .hive/?",
+      initialValue: true,
+    });
+
+    if (!p.isCancel(migrate) && migrate) {
+      const s = p.spinner();
+      s.start("Migrating .beads/ to .hive/...");
+      
+      const result = await migrateBeadsToHive(projectPath);
+      
+      if (result.migrated) {
+        s.stop("Migration complete");
+        p.log.success("Renamed .beads/ to .hive/");
+        
+        // Merge historic beads if beads.base.jsonl exists
+        const mergeResult = await mergeHistoricBeads(projectPath);
+        if (mergeResult.merged > 0) {
+          p.log.success(`Merged ${mergeResult.merged} historic cells`);
+        }
+      } else {
+        s.stop("Migration skipped: " + result.reason);
+      }
+    }
   }
 
   const s = p.spinner();
-  s.start("Initializing beads...");
-
-  const success = await runInstall("bd init");
+  s.start("Initializing hive...");
 
-  if (success) {
-    s.stop("Beads initialized");
-    p.log.success("Created .beads/ directory");
+  try {
+    // Create .hive directory using our function (no bd CLI needed)
+    ensureHiveDirectory(projectPath);
+    
+    s.stop("Hive initialized");
+    p.log.success("Created .hive/ directory");
 
-    const createBead = await p.confirm({
-      message: "Create your first bead?",
+    const createCell = await p.confirm({
+      message: "Create your first cell?",
       initialValue: true,
     });
 
-    if (!p.isCancel(createBead) && createBead) {
+    if (!p.isCancel(createCell) && createCell) {
       const title = await p.text({
-        message: "Bead title:",
+        message: "Cell title:",
         placeholder: "Implement user authentication",
         validate: (v) => (v.length === 0 ? "Title required" : undefined),
       });
@@ -1917,17 +2144,22 @@ async function init() {
         });
 
         if (!p.isCancel(typeResult)) {
-          const beadSpinner = p.spinner();
-          beadSpinner.start("Creating bead...");
-
-          const createSuccess = await runInstall(
-            'bd create --title "' + title + '" --type ' + typeResult,
-          );
-
-          if (createSuccess) {
-            beadSpinner.stop("Bead created");
-          } else {
-            beadSpinner.stop("Failed to create bead");
+          const cellSpinner = p.spinner();
+          cellSpinner.start("Creating cell...");
+
+          try {
+            // Use HiveAdapter to create the cell (no bd CLI needed)
+            const adapter = await getHiveAdapter(projectPath);
+            const cell = await adapter.createCell(projectPath, {
+              title: title as string,
+              type: typeResult as "feature" | "bug" | "task" | "chore",
+              priority: 2,
+            });
+            
+            cellSpinner.stop("Cell created: " + cell.id);
+          } catch (error) {
+            cellSpinner.stop("Failed to create cell");
+            p.log.error(error instanceof Error ? error.message : String(error));
           }
         }
       }
@@ -1953,9 +2185,9 @@ async function init() {
     }
 
     p.outro("Project initialized! Use '/swarm' in OpenCode to get started.");
-  } else {
-    s.stop("Failed to initialize beads");
-    p.log.error("Make sure 'bd' is installed: swarm doctor");
+  } catch (error) {
+    s.stop("Failed to initialize hive");
+    p.log.error(error instanceof Error ? error.message : String(error));
     p.outro("Aborted");
     process.exit(1);
   }

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":"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"}