opencode-swarm-plugin 0.30.0 → 0.30.3

package/src/hive.integration.test.ts

@@ -16,9 +16,11 @@ import {
   hive_start,
   hive_ready,
   hive_link_thread,
+  hive_sync,
   HiveError,
   getHiveAdapter,
   setHiveWorkingDirectory,
+  getHiveWorkingDirectory,
   // Legacy aliases for backward compatibility tests
   beads_link_thread,
   BeadError,
@@ -1120,6 +1122,118 @@ describe("beads integration", () => {
     });
   });
 
+  describe("hive_sync", () => {
+    it("commits .hive changes before pulling (regression test for unstaged changes error)", async () => {
+      const { mkdirSync, rmSync, writeFileSync, existsSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+      const { execSync } = await import("node:child_process");
+
+      // Create a temp git repository
+      const tempProject = join(tmpdir(), `hive-sync-test-${Date.now()}`);
+      mkdirSync(tempProject, { recursive: true });
+
+      // Initialize git repo
+      execSync("git init", { cwd: tempProject });
+      execSync('git config user.email "test@example.com"', { cwd: tempProject });
+      execSync('git config user.name "Test User"', { cwd: tempProject });
+
+      // Create .hive directory and issues.jsonl
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+      const issuesPath = join(hiveDir, "issues.jsonl");
+      writeFileSync(issuesPath, "");
+
+      // Initial commit
+      execSync("git add .", { cwd: tempProject });
+      execSync('git commit -m "initial commit"', { cwd: tempProject });
+
+      // Set working directory for hive commands
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Create a cell (this will mark it dirty and flush will write to JSONL)
+        await hive_create.execute(
+          { title: "Sync test cell", type: "task" },
+          mockContext,
+        );
+
+        // Sync with auto_pull=false (skip pull since no remote configured)
+        const result = await hive_sync.execute(
+          { auto_pull: false },
+          mockContext,
+        );
+
+        // Should succeed
+        expect(result).toContain("successfully");
+
+        // Verify .hive changes were committed (working tree should be clean)
+        const status = execSync("git status --porcelain", {
+          cwd: tempProject,
+          encoding: "utf-8",
+        });
+        expect(status.trim()).toBe("");
+
+        // Verify commit exists
+        const log = execSync("git log --oneline", {
+          cwd: tempProject,
+          encoding: "utf-8",
+        });
+        expect(log).toContain("chore: sync hive");
+      } finally {
+        // Restore original working directory
+        setHiveWorkingDirectory(originalDir);
+
+        // Cleanup
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+
+    it("handles case with no changes to commit", async () => {
+      const { mkdirSync, rmSync, writeFileSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+      const { execSync } = await import("node:child_process");
+
+      // Create temp git repo
+      const tempProject = join(tmpdir(), `hive-sync-test-${Date.now()}`);
+      mkdirSync(tempProject, { recursive: true });
+
+      // Initialize git
+      execSync("git init", { cwd: tempProject });
+      execSync('git config user.email "test@example.com"', { cwd: tempProject });
+      execSync('git config user.name "Test User"', { cwd: tempProject });
+
+      // Create .hive directory with committed issues.jsonl
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+      writeFileSync(join(hiveDir, "issues.jsonl"), "");
+
+      // Commit everything
+      execSync("git add .", { cwd: tempProject });
+      execSync('git commit -m "initial"', { cwd: tempProject });
+
+      // Set working directory
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Sync with no changes (should handle gracefully)
+        const result = await hive_sync.execute(
+          { auto_pull: false },
+          mockContext,
+        );
+
+        // Should return "No cells to sync" since no dirty cells
+        expect(result).toContain("No cells to sync");
+      } finally {
+        setHiveWorkingDirectory(originalDir);
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+  });
+
   describe("mergeHistoricBeads", () => {
     it("merges empty base file - no changes", async () => {
       const { mergeHistoricBeads } = await import("./hive");

package/src/hive.ts

@@ -1053,38 +1053,49 @@ export const hive_sync = tool({
       }
     }
 
-    // 6. Pull if requested
+    // 6. Pull if requested (check if remote exists first)
     if (autoPull) {
-      const pullResult = await withTimeout(
-        runGitCommand(["pull", "--rebase"]),
-        TIMEOUT_MS,
-        "git pull --rebase",
-      );
+      const remoteCheckResult = await runGitCommand(["remote"]);
+      const hasRemote = remoteCheckResult.stdout.trim() !== "";
 
-      if (pullResult.exitCode !== 0) {
-        throw new HiveError(
-          `Failed to pull: ${pullResult.stderr}`,
+      if (hasRemote) {
+        const pullResult = await withTimeout(
+          runGitCommand(["pull", "--rebase"]),
+          TIMEOUT_MS,
           "git pull --rebase",
-          pullResult.exitCode,
         );
+
+        if (pullResult.exitCode !== 0) {
+          throw new HiveError(
+            `Failed to pull: ${pullResult.stderr}`,
+            "git pull --rebase",
+            pullResult.exitCode,
+          );
+        }
       }
     }
 
-    // 7. Push
-    const pushResult = await withTimeout(
-      runGitCommand(["push"]),
-      TIMEOUT_MS,
-      "git push",
-    );
-    if (pushResult.exitCode !== 0) {
-      throw new HiveError(
-        `Failed to push: ${pushResult.stderr}`,
+    // 7. Push (check if remote exists first)
+    const remoteCheckResult = await runGitCommand(["remote"]);
+    const hasRemote = remoteCheckResult.stdout.trim() !== "";
+
+    if (hasRemote) {
+      const pushResult = await withTimeout(
+        runGitCommand(["push"]),
+        TIMEOUT_MS,
         "git push",
-        pushResult.exitCode,
       );
+      if (pushResult.exitCode !== 0) {
+        throw new HiveError(
+          `Failed to push: ${pushResult.stderr}`,
+          "git push",
+          pushResult.exitCode,
+        );
+      }
+      return "Hive synced and pushed successfully";
+    } else {
+      return "Hive synced successfully (no remote configured)";
     }
-
-    return "Hive synced and pushed successfully";
   },
 });
 

package/src/index.ts

@@ -46,6 +46,7 @@ import { reviewTools } from "./swarm-review";
 import { repoCrawlTools } from "./repo-crawl";
 import { skillsTools, setSkillsProjectDirectory } from "./skills";
 import { mandateTools } from "./mandates";
+import { memoryTools } from "./memory-tools";
 import {
   guardrailOutput,
   DEFAULT_GUARDRAIL_CONFIG,
@@ -69,6 +70,7 @@ import {
  * - 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
@@ -148,9 +150,10 @@ export const SwarmPlugin: Plugin = async (
      * - beads:* - Legacy aliases (deprecated, use hive:* instead)
      * - agent-mail:init, agent-mail:send, agent-mail:reserve, etc. (legacy MCP)
      * - swarm-mail:init, swarm-mail:send, swarm-mail:reserve, etc. (embedded)
-     * - repo-crawl:readme, repo-crawl:structure, etc.
-     * - mandate:file, mandate:vote, mandate:query, etc.
-     */
+ * - repo-crawl:readme, repo-crawl:structure, etc.
+ * - mandate:file, mandate:vote, mandate:query, etc.
+ * - semantic-memory:store, semantic-memory:find, semantic-memory:get, etc.
+ */
     tool: {
       ...hiveTools,
       ...swarmMailTools,
@@ -161,6 +164,7 @@ export const SwarmPlugin: Plugin = async (
       ...repoCrawlTools,
       ...skillsTools,
       ...mandateTools,
+      ...memoryTools,
     },
 
     /**
@@ -417,6 +421,7 @@ export const allTools = {
   ...repoCrawlTools,
   ...skillsTools,
   ...mandateTools,
+  ...memoryTools,
 } as const;
 
 /**
@@ -644,3 +649,33 @@ export {
  * ```
  */
 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";

package/src/memory-tools.test.ts

@@ -0,0 +1,111 @@
+/**
+ * Memory Tools Integration Tests
+ *
+ * Tests for semantic-memory_* tool registration and execution.
+ */
+
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { memoryTools, resetMemoryCache } from "./memory-tools";
+import { closeAllSwarmMail } from "swarm-mail";
+
+describe("memory tools integration", () => {
+	afterAll(async () => {
+		resetMemoryCache();
+		await closeAllSwarmMail();
+	});
+
+	test("all tools are registered with correct names", () => {
+		const toolNames = Object.keys(memoryTools);
+		expect(toolNames).toContain("semantic-memory_store");
+		expect(toolNames).toContain("semantic-memory_find");
+		expect(toolNames).toContain("semantic-memory_get");
+		expect(toolNames).toContain("semantic-memory_remove");
+		expect(toolNames).toContain("semantic-memory_validate");
+		expect(toolNames).toContain("semantic-memory_list");
+		expect(toolNames).toContain("semantic-memory_stats");
+		expect(toolNames).toContain("semantic-memory_check");
+	});
+
+	test("tools have execute functions", () => {
+		for (const [name, tool] of Object.entries(memoryTools)) {
+			expect(typeof tool.execute).toBe("function");
+		}
+	});
+
+	describe("semantic-memory_store", () => {
+		test("executes and returns JSON", async () => {
+			const tool = memoryTools["semantic-memory_store"];
+			const result = await tool.execute(
+				{
+					information: "Test memory for tools integration",
+					tags: "test",
+				},
+				{ sessionID: "test-session" } as any,
+			);
+
+			expect(typeof result).toBe("string");
+			const parsed = JSON.parse(result);
+			expect(parsed.id).toBeDefined();
+			expect(parsed.id).toMatch(/^mem_/);
+			expect(parsed.message).toContain("Stored memory");
+		});
+	});
+
+	describe("semantic-memory_find", () => {
+		test("executes and returns JSON array", async () => {
+			// Store a memory first
+			const storeTool = memoryTools["semantic-memory_store"];
+			await storeTool.execute(
+				{
+					information: "Findable test memory with unique keyword xyztest123",
+				},
+				{ sessionID: "test-session" } as any,
+			);
+
+			// Search for it
+			const findTool = memoryTools["semantic-memory_find"];
+			const result = await findTool.execute(
+				{
+					query: "xyztest123",
+					limit: 5,
+				},
+				{ sessionID: "test-session" } as any,
+			);
+
+			expect(typeof result).toBe("string");
+			const parsed = JSON.parse(result);
+			expect(parsed.results).toBeDefined();
+			expect(Array.isArray(parsed.results)).toBe(true);
+			expect(parsed.count).toBeGreaterThanOrEqual(0);
+		});
+	});
+
+	describe("semantic-memory_stats", () => {
+		test("returns memory and embedding counts", async () => {
+			const tool = memoryTools["semantic-memory_stats"];
+			const result = await tool.execute(
+				{},
+				{ sessionID: "test-session" } as any,
+			);
+
+			expect(typeof result).toBe("string");
+			const parsed = JSON.parse(result);
+			expect(typeof parsed.memories).toBe("number");
+			expect(typeof parsed.embeddings).toBe("number");
+		});
+	});
+
+	describe("semantic-memory_check", () => {
+		test("checks Ollama health", async () => {
+			const tool = memoryTools["semantic-memory_check"];
+			const result = await tool.execute(
+				{},
+				{ sessionID: "test-session" } as any,
+			);
+
+			expect(typeof result).toBe("string");
+			const parsed = JSON.parse(result);
+			expect(typeof parsed.ollama).toBe("boolean");
+		});
+	});
+});

package/src/memory-tools.ts

@@ -0,0 +1,273 @@
+/**
+ * Semantic Memory Plugin Tools - Embedded implementation
+ *
+ * Provides semantic memory operations using swarm-mail's MemoryStore + Ollama.
+ * Replaces external MCP-based semantic-memory calls with embedded storage.
+ *
+ * Key features:
+ * - Vector similarity search with Ollama embeddings
+ * - Full-text search fallback
+ * - Memory decay tracking (TODO: implement in MemoryStore)
+ * - Collection-based organization
+ *
+ * Tool signatures maintained for backward compatibility with existing prompts.
+ */
+
+import { tool } from "@opencode-ai/plugin";
+import { getSwarmMail } from "swarm-mail";
+import {
+	createMemoryAdapter,
+	type MemoryAdapter,
+	type StoreArgs,
+	type FindArgs,
+	type IdArgs,
+	type ListArgs,
+	type StoreResult,
+	type FindResult,
+	type StatsResult,
+	type HealthResult,
+	type OperationResult,
+} from "./memory";
+
+// Re-export types for external use
+export type {
+	MemoryAdapter,
+	StoreArgs,
+	FindArgs,
+	IdArgs,
+	ListArgs,
+	StoreResult,
+	FindResult,
+	StatsResult,
+	HealthResult,
+	OperationResult,
+};
+
+// ============================================================================
+// Types
+// ============================================================================
+
+/** Tool execution context from OpenCode plugin */
+interface ToolContext {
+	sessionID: string;
+}
+
+// ============================================================================
+// Memory Adapter Cache
+// ============================================================================
+
+let cachedAdapter: MemoryAdapter | null = null;
+let cachedProjectPath: string | null = null;
+
+/**
+ * Get or create memory adapter for the current project
+ *
+ * @param projectPath - Project path (uses CWD if not provided)
+ * @returns Memory adapter instance
+ */
+async function getMemoryAdapter(
+	projectPath?: string,
+): Promise<MemoryAdapter> {
+	const path = projectPath || process.cwd();
+
+	// Return cached adapter if same project
+	if (cachedAdapter && cachedProjectPath === path) {
+		return cachedAdapter;
+	}
+
+	// Create new adapter
+	const swarmMail = await getSwarmMail(path);
+	const db = await swarmMail.getDatabase();
+	cachedAdapter = await createMemoryAdapter(db);
+	cachedProjectPath = path;
+
+	return cachedAdapter;
+}
+
+/**
+ * Reset adapter cache (for testing)
+ */
+export function resetMemoryCache(): void {
+	cachedAdapter = null;
+	cachedProjectPath = null;
+}
+
+// Re-export createMemoryAdapter for external use
+export { createMemoryAdapter };
+
+// ============================================================================
+// Plugin Tools
+// ============================================================================
+
+/**
+ * Store a memory with semantic embedding
+ */
+export const semantic_memory_store = tool({
+	description:
+		"Store a memory with semantic embedding. Memories are searchable by semantic similarity and can be organized into collections.",
+	args: {
+		information: tool.schema
+			.string()
+			.describe("The information to store (required)"),
+		collection: tool.schema
+			.string()
+			.optional()
+			.describe("Collection name (defaults to 'default')"),
+		tags: tool.schema
+			.string()
+			.optional()
+			.describe("Comma-separated tags (e.g., 'auth,tokens,oauth')"),
+		metadata: tool.schema
+			.string()
+			.optional()
+			.describe("JSON string with additional metadata"),
+	},
+	async execute(args, ctx: ToolContext) {
+		const adapter = await getMemoryAdapter();
+		const result = await adapter.store(args);
+		return JSON.stringify(result, null, 2);
+	},
+});
+
+/**
+ * Find memories by semantic similarity or full-text search
+ */
+export const semantic_memory_find = tool({
+	description:
+		"Search memories by semantic similarity (vector search) or full-text search. Returns results ranked by relevance score.",
+	args: {
+		query: tool.schema.string().describe("Search query (required)"),
+		limit: tool.schema
+			.number()
+			.optional()
+			.describe("Maximum number of results (default: 10)"),
+		collection: tool.schema
+			.string()
+			.optional()
+			.describe("Filter by collection name"),
+		expand: tool.schema
+			.boolean()
+			.optional()
+			.describe("Return full content instead of truncated preview (default: false)"),
+		fts: tool.schema
+			.boolean()
+			.optional()
+			.describe("Use full-text search instead of vector search (default: false)"),
+	},
+	async execute(args, ctx: ToolContext) {
+		const adapter = await getMemoryAdapter();
+		const result = await adapter.find(args);
+		return JSON.stringify(result, null, 2);
+	},
+});
+
+/**
+ * Get a single memory by ID
+ */
+export const semantic_memory_get = tool({
+	description: "Retrieve a specific memory by its ID.",
+	args: {
+		id: tool.schema.string().describe("Memory ID (required)"),
+	},
+	async execute(args, ctx: ToolContext) {
+		const adapter = await getMemoryAdapter();
+		const memory = await adapter.get(args);
+		return memory ? JSON.stringify(memory, null, 2) : "Memory not found";
+	},
+});
+
+/**
+ * Remove a memory
+ */
+export const semantic_memory_remove = tool({
+	description: "Delete a memory by ID. Use this to remove outdated or incorrect memories.",
+	args: {
+		id: tool.schema.string().describe("Memory ID (required)"),
+	},
+	async execute(args, ctx: ToolContext) {
+		const adapter = await getMemoryAdapter();
+		const result = await adapter.remove(args);
+		return JSON.stringify(result, null, 2);
+	},
+});
+
+/**
+ * Validate a memory (reset decay timer)
+ */
+export const semantic_memory_validate = tool({
+	description:
+		"Validate that a memory is still accurate and reset its decay timer. Use when you confirm a memory is correct.",
+	args: {
+		id: tool.schema.string().describe("Memory ID (required)"),
+	},
+	async execute(args, ctx: ToolContext) {
+		const adapter = await getMemoryAdapter();
+		const result = await adapter.validate(args);
+		return JSON.stringify(result, null, 2);
+	},
+});
+
+/**
+ * List memories
+ */
+export const semantic_memory_list = tool({
+	description: "List all stored memories, optionally filtered by collection.",
+	args: {
+		collection: tool.schema
+			.string()
+			.optional()
+			.describe("Filter by collection name"),
+	},
+	async execute(args, ctx: ToolContext) {
+		const adapter = await getMemoryAdapter();
+		const memories = await adapter.list(args);
+		return JSON.stringify(memories, null, 2);
+	},
+});
+
+/**
+ * Get memory statistics
+ */
+export const semantic_memory_stats = tool({
+	description: "Get statistics about stored memories and embeddings.",
+	args: {},
+	async execute(args, ctx: ToolContext) {
+		const adapter = await getMemoryAdapter();
+		const stats = await adapter.stats();
+		return JSON.stringify(stats, null, 2);
+	},
+});
+
+/**
+ * Check Ollama health
+ */
+export const semantic_memory_check = tool({
+	description:
+		"Check if Ollama is running and available for embedding generation.",
+	args: {},
+	async execute(args, ctx: ToolContext) {
+		const adapter = await getMemoryAdapter();
+		const health = await adapter.checkHealth();
+		return JSON.stringify(health, null, 2);
+	},
+});
+
+// ============================================================================
+// Tool Registry
+// ============================================================================
+
+/**
+ * All semantic memory tools
+ *
+ * Register these in the plugin with spread operator: { ...memoryTools }
+ */
+export const memoryTools = {
+	"semantic-memory_store": semantic_memory_store,
+	"semantic-memory_find": semantic_memory_find,
+	"semantic-memory_get": semantic_memory_get,
+	"semantic-memory_remove": semantic_memory_remove,
+	"semantic-memory_validate": semantic_memory_validate,
+	"semantic-memory_list": semantic_memory_list,
+	"semantic-memory_stats": semantic_memory_stats,
+	"semantic-memory_check": semantic_memory_check,
+} as const;