opencode-swarm-plugin 0.45.6 → 0.46.0

package/dist/hive.js

@@ -12711,6 +12711,7 @@ __export(exports_eval_capture, {
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { getSwarmMailLibSQL } from "swarm-mail";
 function getEvalDataPath(projectPath) {
   return path.join(projectPath, DEFAULT_EVAL_DATA_PATH);
 }
@@ -12890,7 +12891,7 @@ function getEvalDataStats(projectPath) {
   };
 }
 function getSessionDir() {
-  return path.join(os.homedir(), ".config", "swarm-tools", "sessions");
+  return process.env.SWARM_SESSIONS_DIR || path.join(os.homedir(), ".config", "swarm-tools", "sessions");
 }
 function getSessionPath(sessionId) {
   return path.join(getSessionDir(), `${sessionId}.jsonl`);
@@ -12901,15 +12902,46 @@ function ensureSessionDir() {
     fs.mkdirSync(sessionDir, { recursive: true });
   }
 }
-function captureCoordinatorEvent(event) {
+async function captureCoordinatorEvent(event) {
   CoordinatorEventSchema.parse(event);
-  ensureSessionDir();
-  const sessionPath = getSessionPath(event.session_id);
-  const line = `${JSON.stringify(event)}
+  try {
+    const projectPath = process.cwd();
+    const swarmMail = await getSwarmMailLibSQL(projectPath);
+    const eventType = `coordinator_${event.event_type.toLowerCase()}`;
+    const eventData = {
+      type: eventType,
+      project_key: projectPath,
+      timestamp: new Date(event.timestamp).getTime(),
+      session_id: event.session_id,
+      epic_id: event.epic_id,
+      event_type: event.event_type,
+      payload: event.payload
+    };
+    if (event.event_type === "DECISION") {
+      eventData.decision_type = event.decision_type;
+    } else if (event.event_type === "VIOLATION") {
+      eventData.violation_type = event.violation_type;
+    } else if (event.event_type === "OUTCOME") {
+      eventData.outcome_type = event.outcome_type;
+    } else if (event.event_type === "COMPACTION") {
+      eventData.compaction_type = event.compaction_type;
+    }
+    await swarmMail.appendEvent(eventData);
+    ensureSessionDir();
+    const sessionPath = getSessionPath(event.session_id);
+    const line = `${JSON.stringify(event)}
+`;
+    fs.appendFileSync(sessionPath, line, "utf-8");
+  } catch (error45) {
+    console.warn("Failed to append event to libSQL, using JSONL fallback:", error45);
+    ensureSessionDir();
+    const sessionPath = getSessionPath(event.session_id);
+    const line = `${JSON.stringify(event)}
 `;
-  fs.appendFileSync(sessionPath, line, "utf-8");
+    fs.appendFileSync(sessionPath, line, "utf-8");
+  }
 }
-function captureCompactionEvent(params) {
+async function captureCompactionEvent(params) {
   const event = {
     session_id: params.session_id,
     epic_id: params.epic_id,
@@ -12918,9 +12950,9 @@ function captureCompactionEvent(params) {
     compaction_type: params.compaction_type,
     payload: params.payload
   };
-  captureCoordinatorEvent(event);
+  await captureCoordinatorEvent(event);
 }
-function captureResearcherSpawned(params) {
+async function captureResearcherSpawned(params) {
   const event = {
     session_id: params.session_id,
     epic_id: params.epic_id,
@@ -12933,9 +12965,9 @@ function captureResearcherSpawned(params) {
       tools_used: params.tools_used || []
     }
   };
-  captureCoordinatorEvent(event);
+  await captureCoordinatorEvent(event);
 }
-function captureSkillLoaded(params) {
+async function captureSkillLoaded(params) {
   const event = {
     session_id: params.session_id,
     epic_id: params.epic_id,
@@ -12947,9 +12979,9 @@ function captureSkillLoaded(params) {
       context: params.context
     }
   };
-  captureCoordinatorEvent(event);
+  await captureCoordinatorEvent(event);
 }
-function captureInboxChecked(params) {
+async function captureInboxChecked(params) {
   const event = {
     session_id: params.session_id,
     epic_id: params.epic_id,
@@ -12961,9 +12993,9 @@ function captureInboxChecked(params) {
       urgent_count: params.urgent_count
     }
   };
-  captureCoordinatorEvent(event);
+  await captureCoordinatorEvent(event);
 }
-function captureBlockerResolved(params) {
+async function captureBlockerResolved(params) {
   const event = {
     session_id: params.session_id,
     epic_id: params.epic_id,
@@ -12977,9 +13009,9 @@ function captureBlockerResolved(params) {
       resolution: params.resolution
     }
   };
-  captureCoordinatorEvent(event);
+  await captureCoordinatorEvent(event);
 }
-function captureScopeChangeDecision(params) {
+async function captureScopeChangeDecision(params) {
   const event = {
     session_id: params.session_id,
     epic_id: params.epic_id,
@@ -12999,9 +13031,9 @@ function captureScopeChangeDecision(params) {
       rejection_reason: params.rejection_reason
     }
   };
-  captureCoordinatorEvent(event);
+  await captureCoordinatorEvent(event);
 }
-function captureBlockerDetected(params) {
+async function captureBlockerDetected(params) {
   const event = {
     session_id: params.session_id,
     epic_id: params.epic_id,
@@ -13016,7 +13048,7 @@ function captureBlockerDetected(params) {
       reported_at: new Date().toISOString()
     }
   };
-  captureCoordinatorEvent(event);
+  await captureCoordinatorEvent(event);
 }
 function readSessionEvents(sessionId) {
   const sessionPath = getSessionPath(sessionId);
@@ -13119,7 +13151,8 @@ var init_eval_capture = __esm(() => {
         "coordinator_edited_file",
         "coordinator_ran_tests",
         "coordinator_reserved_files",
-        "no_worker_spawned"
+        "no_worker_spawned",
+        "worker_completed_without_review"
       ]),
       payload: exports_external.any()
     }),
@@ -13242,7 +13275,7 @@ import {
   FlushManager,
   importFromJSONL,
   syncMemories,
-  getSwarmMailLibSQL,
+  getSwarmMailLibSQL as getSwarmMailLibSQL2,
   resolvePartialId,
   findCellsByPartialId
 } from "swarm-mail";
@@ -14033,7 +14066,7 @@ async function getHiveAdapter(projectKey) {
   if (adapterCache.has(projectKey)) {
     return adapterCache.get(projectKey);
   }
-  const swarmMail = await getSwarmMailLibSQL(projectKey);
+  const swarmMail = await getSwarmMailLibSQL2(projectKey);
   const db = await swarmMail.getDatabase();
   const adapter = createHiveAdapter(db, projectKey);
   await adapter.runMigrations();
@@ -14042,6 +14075,9 @@ async function getHiveAdapter(projectKey) {
   return adapter;
 }
 var getBeadsAdapter = getHiveAdapter;
+function clearHiveAdapterCache() {
+  adapterCache.clear();
+}
 async function autoMigrateFromJSONL(adapter, projectKey) {
   const jsonlPath = join2(projectKey, ".hive", "issues.jsonl");
   if (!existsSync2(jsonlPath)) {
@@ -14662,7 +14698,7 @@ var hive_sync = tool({
       outputPath: `${projectKey}/.hive/issues.jsonl`
     });
     const flushResult = await withTimeout(flushManager.flush(), TIMEOUT_MS, "flush hive");
-    const swarmMail = await getSwarmMailLibSQL(projectKey);
+    const swarmMail = await getSwarmMailLibSQL2(projectKey);
     const db = await swarmMail.getDatabase();
     const hivePath = join2(projectKey, ".hive");
     let memoriesSynced = 0;
@@ -14895,6 +14931,7 @@ export {
   getBeadsWorkingDirectory,
   getBeadsAdapter,
   ensureHiveDirectory,
+  clearHiveAdapterCache,
   checkBeadsMigrationNeeded,
   beads_update,
   beads_sync,

package/dist/hivemind-tools.d.ts

@@ -0,0 +1,479 @@
+/**
+ * Hivemind Tools - Unified Memory System
+ *
+ * Unifies semantic-memory and CASS tools under the hivemind namespace.
+ * Sessions and learnings are both memories with different sources.
+ *
+ * Key design decisions (ADR-011):
+ * - 8 tools instead of 15 (merged duplicates)
+ * - Collection filter: "default" for learnings, "claude" for Claude sessions, etc.
+ * - Unified search across learnings + sessions
+ * - No more naming collision with external semantic-memory MCP
+ *
+ * Tool mapping:
+ * - semantic-memory_store → hivemind_store
+ * - semantic-memory_find + cass_search → hivemind_find
+ * - semantic-memory_get + cass_view → hivemind_get
+ * - semantic-memory_remove → hivemind_remove
+ * - semantic-memory_validate → hivemind_validate
+ * - semantic-memory_stats + cass_stats + cass_health → hivemind_stats
+ * - cass_index → hivemind_index
+ * - NEW: hivemind_sync (sync to .hive/memories.jsonl)
+ */
+import { type MemoryAdapter, type StoreArgs, type FindArgs, type IdArgs, type StoreResult, type FindResult, type StatsResult, type OperationResult } from "./memory";
+export type { MemoryAdapter, StoreArgs, FindArgs, IdArgs, StoreResult, FindResult, StatsResult, OperationResult, };
+/**
+ * Get or create memory adapter for the current project
+ */
+declare function getMemoryAdapter(projectPath?: string): Promise<MemoryAdapter>;
+/**
+ * Get or create hivemind adapter (alias for getMemoryAdapter)
+ */
+export declare const getHivemindAdapter: typeof getMemoryAdapter;
+/**
+ * Reset adapter cache (for testing)
+ */
+export declare function resetHivemindCache(): void;
+/**
+ * hivemind_store - Store a memory with semantic embedding
+ */
+export declare const hivemind_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>;
+        confidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        autoTag: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        autoLink: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        extractEntities: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        information: string;
+        collection?: string | undefined;
+        tags?: string | undefined;
+        metadata?: string | undefined;
+        confidence?: number | undefined;
+        autoTag?: boolean | undefined;
+        autoLink?: boolean | undefined;
+        extractEntities?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * hivemind_find - Search all memories (learnings + sessions)
+ */
+export declare const hivemind_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>;
+};
+/**
+ * hivemind_get - Get a specific memory by ID
+ */
+export declare const hivemind_get: {
+    description: string;
+    args: {
+        id: import("zod").ZodString;
+    };
+    execute(args: {
+        id: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * hivemind_remove - Delete a memory
+ */
+export declare const hivemind_remove: {
+    description: string;
+    args: {
+        id: import("zod").ZodString;
+    };
+    execute(args: {
+        id: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * hivemind_validate - Validate a memory (reset decay timer)
+ */
+export declare const hivemind_validate: {
+    description: string;
+    args: {
+        id: import("zod").ZodString;
+    };
+    execute(args: {
+        id: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * hivemind_stats - Combined statistics and health check
+ */
+export declare const hivemind_stats: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * hivemind_index - Index AI session directories
+ */
+export declare const hivemind_index: {
+    description: string;
+    args: {
+        full: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        full?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * hivemind_sync - Sync memories to .hive/memories.jsonl
+ */
+export declare const hivemind_sync: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+declare const semantic_memory_store: any;
+declare const semantic_memory_find: any;
+declare const semantic_memory_get: any;
+declare const semantic_memory_remove: any;
+declare const semantic_memory_validate: any;
+declare const semantic_memory_list: any;
+declare const semantic_memory_stats: any;
+declare const semantic_memory_check: any;
+declare const semantic_memory_upsert: any;
+declare const cass_search: any;
+declare const cass_view: any;
+declare const cass_expand: any;
+declare const cass_health: any;
+declare const cass_index: any;
+declare const cass_stats: any;
+/**
+ * All hivemind tools + deprecation aliases
+ *
+ * Register these in the plugin with spread operator: { ...hivemindTools }
+ */
+export declare const hivemindTools: {
+    readonly hivemind_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>;
+            confidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+            autoTag: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            autoLink: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            extractEntities: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            information: string;
+            collection?: string | undefined;
+            tags?: string | undefined;
+            metadata?: string | undefined;
+            confidence?: number | undefined;
+            autoTag?: boolean | undefined;
+            autoLink?: boolean | undefined;
+            extractEntities?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_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 hivemind_get: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_remove: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_validate: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_stats: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_index: {
+        description: string;
+        args: {
+            full: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            full?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_sync: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_store": any;
+    readonly "semantic-memory_find": any;
+    readonly "semantic-memory_get": any;
+    readonly "semantic-memory_remove": any;
+    readonly "semantic-memory_validate": any;
+    readonly "semantic-memory_list": any;
+    readonly "semantic-memory_stats": any;
+    readonly "semantic-memory_check": any;
+    readonly "semantic-memory_upsert": any;
+    readonly cass_search: any;
+    readonly cass_view: any;
+    readonly cass_expand: any;
+    readonly cass_health: any;
+    readonly cass_index: any;
+    readonly cass_stats: any;
+};
+export { semantic_memory_store, semantic_memory_find, semantic_memory_get, semantic_memory_remove, semantic_memory_validate, semantic_memory_list, semantic_memory_stats, semantic_memory_check, semantic_memory_upsert, cass_search, cass_view, cass_expand, cass_health, cass_index, cass_stats, };
+export { createMemoryAdapter } from "./memory";
+export declare const memoryTools: {
+    readonly hivemind_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>;
+            confidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+            autoTag: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            autoLink: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            extractEntities: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            information: string;
+            collection?: string | undefined;
+            tags?: string | undefined;
+            metadata?: string | undefined;
+            confidence?: number | undefined;
+            autoTag?: boolean | undefined;
+            autoLink?: boolean | undefined;
+            extractEntities?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_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 hivemind_get: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_remove: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_validate: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_stats: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_index: {
+        description: string;
+        args: {
+            full: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            full?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_sync: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_store": any;
+    readonly "semantic-memory_find": any;
+    readonly "semantic-memory_get": any;
+    readonly "semantic-memory_remove": any;
+    readonly "semantic-memory_validate": any;
+    readonly "semantic-memory_list": any;
+    readonly "semantic-memory_stats": any;
+    readonly "semantic-memory_check": any;
+    readonly "semantic-memory_upsert": any;
+    readonly cass_search: any;
+    readonly cass_view: any;
+    readonly cass_expand: any;
+    readonly cass_health: any;
+    readonly cass_index: any;
+    readonly cass_stats: any;
+};
+export declare const cassTools: {
+    readonly hivemind_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>;
+            confidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+            autoTag: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            autoLink: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            extractEntities: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            information: string;
+            collection?: string | undefined;
+            tags?: string | undefined;
+            metadata?: string | undefined;
+            confidence?: number | undefined;
+            autoTag?: boolean | undefined;
+            autoLink?: boolean | undefined;
+            extractEntities?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_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 hivemind_get: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_remove: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_validate: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_stats: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_index: {
+        description: string;
+        args: {
+            full: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            full?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly hivemind_sync: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_store": any;
+    readonly "semantic-memory_find": any;
+    readonly "semantic-memory_get": any;
+    readonly "semantic-memory_remove": any;
+    readonly "semantic-memory_validate": any;
+    readonly "semantic-memory_list": any;
+    readonly "semantic-memory_stats": any;
+    readonly "semantic-memory_check": any;
+    readonly "semantic-memory_upsert": any;
+    readonly cass_search: any;
+    readonly cass_view: any;
+    readonly cass_expand: any;
+    readonly cass_health: any;
+    readonly cass_index: any;
+    readonly cass_stats: any;
+};
+export declare const resetMemoryCache: typeof resetHivemindCache;
+//# sourceMappingURL=hivemind-tools.d.ts.map

package/dist/hivemind-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hivemind-tools.d.ts","sourceRoot":"","sources":["../src/hivemind-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAeH,OAAO,EAEN,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,MAAM,UAAU,CAAC;AASlB,YAAY,EACX,aAAa,EACb,SAAS,EACT,QAAQ,EACR,MAAM,EACN,WAAW,EACX,UAAU,EACV,WAAW,EACX,eAAe,GACf,CAAC;AAmBF;;GAEG;AACH,iBAAe,gBAAgB,CAC9B,WAAW,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,aAAa,CAAC,CAcxB;AA8BD;;GAEG;AACH,eAAO,MAAM,kBAAkB,yBAAmB,CAAC;AAEnD;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAIzC;AA2CD;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;CAkDzB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;CAuCxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;CAUvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;CAiB1B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;CAmB5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc;;;;CAyBzB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;CA8DzB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;CAgCxB,CAAC;AAmBH,QAAA,MAAM,qBAAqB,KAAmF,CAAC;AAC/G,QAAA,MAAM,oBAAoB,KAAgF,CAAC;AAC3G,QAAA,MAAM,mBAAmB,KAA6E,CAAC;AACvG,QAAA,MAAM,sBAAsB,KAAsF,CAAC;AACnH,QAAA,MAAM,wBAAwB,KAA4F,CAAC;AAC3H,QAAA,MAAM,oBAAoB,KAAgF,CAAC;AAC3G,QAAA,MAAM,qBAAqB,KAAmF,CAAC;AAC/G,QAAA,MAAM,qBAAqB,KAAmF,CAAC;AAC/G,QAAA,MAAM,sBAAsB,KAAoF,CAAC;AAGjH,QAAA,MAAM,WAAW,KAAuE,CAAC;AACzF,QAAA,MAAM,SAAS,KAAmE,CAAC;AACnF,QAAA,MAAM,WAAW,KAAqE,CAAC;AACvF,QAAA,MAAM,WAAW,KAAyE,CAAC;AAC3F,QAAA,MAAM,UAAU,KAAwE,CAAC;AACzF,QAAA,MAAM,UAAU,KAAwE,CAAC;AAMzF;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BhB,CAAC;AAMX,OAAO,EACN,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB,EACnB,sBAAsB,EACtB,wBAAwB,EACxB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACrB,sBAAsB,EACtB,WAAW,EACX,SAAS,EACT,WAAW,EACX,WAAW,EACX,UAAU,EACV,UAAU,GACV,CAAC;AAGF,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAG/C,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgB,CAAC;AACzC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgB,CAAC;AAGvC,eAAO,MAAM,gBAAgB,2BAAqB,CAAC"}