opencode-swarm-plugin 0.43.0 → 0.44.1

package/src/memory-tools.test.ts

@@ -1,195 +0,0 @@
-/**
- * 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");
-		expect(toolNames).toContain("semantic-memory_upsert");
-	});
-
-	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");
-		});
-	});
-
-	describe("semantic-memory_upsert", () => {
-		test("returns valid ADD operation result", async () => {
-			const tool = memoryTools["semantic-memory_upsert"];
-			const result = await tool.execute(
-				{
-					information: "Test memory for plugin tool",
-					tags: "test,plugin",
-				},
-				{ sessionID: "test-session" } as any,
-			);
-
-			const parsed = JSON.parse(result);
-			
-			expect(parsed.operation).toBe("ADD");
-			expect(parsed.reason).toBeDefined();
-			expect(parsed.memoryId).toBeDefined();
-			expect(parsed.memoryId).toMatch(/^mem_/);
-		});
-
-		test("includes autoTags when enabled", async () => {
-			const tool = memoryTools["semantic-memory_upsert"];
-			const result = await tool.execute(
-				{
-					information: "TypeScript is a typed superset of JavaScript",
-					autoTag: true,
-				},
-				{ sessionID: "test-session" } as any,
-			);
-
-			const parsed = JSON.parse(result);
-			
-			expect(parsed.autoTags).toBeDefined();
-			expect(parsed.autoTags.tags).toBeInstanceOf(Array);
-			expect(parsed.autoTags.keywords).toBeInstanceOf(Array);
-			expect(parsed.autoTags.category).toBe("general");
-		});
-
-		test("includes linksCreated when autoLink enabled", async () => {
-			const tool = memoryTools["semantic-memory_upsert"];
-			const result = await tool.execute(
-				{
-					information: "React hooks enable functional components to use state",
-					autoLink: true,
-				},
-				{ sessionID: "test-session" } as any,
-			);
-
-			const parsed = JSON.parse(result);
-			
-			expect(parsed.linksCreated).toBeDefined();
-			expect(typeof parsed.linksCreated).toBe("number");
-		});
-
-		test("includes entitiesExtracted when extractEntities enabled", async () => {
-			const tool = memoryTools["semantic-memory_upsert"];
-			const result = await tool.execute(
-				{
-					information: "Next.js 15 was released by Vercel in October 2024",
-					extractEntities: true,
-				},
-				{ sessionID: "test-session" } as any,
-			);
-
-			const parsed = JSON.parse(result);
-			
-			expect(parsed.entitiesExtracted).toBeDefined();
-			expect(typeof parsed.entitiesExtracted).toBe("number");
-		});
-
-		test("throws error when information is missing", async () => {
-			const tool = memoryTools["semantic-memory_upsert"];
-			
-			await expect(async () => {
-				await tool.execute(
-					{
-						tags: "test",
-					} as any,
-					{ sessionID: "test-session" } as any,
-				);
-			}).toThrow("information is required");
-		});
-	});
-});

package/src/memory-tools.ts

@@ -1,344 +0,0 @@
-/**
- * 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 { getSwarmMailLibSQL } 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,
-	type UpsertArgs,
-	type UpsertResult,
-	type AutoTags,
-} from "./memory";
-
-// Re-export types for external use
-export type {
-	MemoryAdapter,
-	StoreArgs,
-	FindArgs,
-	IdArgs,
-	ListArgs,
-	StoreResult,
-	FindResult,
-	StatsResult,
-	HealthResult,
-	OperationResult,
-	UpsertArgs,
-	UpsertResult,
-	AutoTags,
-} from "./memory";
-
-// ============================================================================
-// 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
- */
-export 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 getSwarmMailLibSQL(path);
-	const dbAdapter = await swarmMail.getDatabase();
-	
-	// createMemoryAdapter now accepts DatabaseAdapter directly and converts internally
-	cachedAdapter = await createMemoryAdapter(dbAdapter);
-	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. Confidence affects decay rate: high confidence (1.0) = 135 day half-life, low confidence (0.0) = 45 day half-life. Supports auto-tagging, auto-linking, and entity extraction via LLM.",
-	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"),
-		confidence: tool.schema
-			.number()
-			.optional()
-			.describe("Confidence level (0.0-1.0) affecting decay rate. Higher = slower decay. Default 0.7"),
-		autoTag: tool.schema
-			.boolean()
-			.optional()
-			.describe("Auto-generate tags using LLM. Default false"),
-		autoLink: tool.schema
-			.boolean()
-			.optional()
-			.describe("Auto-link to related memories. Default false"),
-		extractEntities: tool.schema
-			.boolean()
-			.optional()
-			.describe("Extract entities (people, places, technologies). Default false"),
-	},
-	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);
-	},
-});
-
-/**
- * Smart upsert - ADD, UPDATE, DELETE, or NOOP based on existing memories
- */
-export const semantic_memory_upsert = tool({
-	description:
-		"Smart memory storage that decides whether to ADD, UPDATE, DELETE, or skip (NOOP) based on existing memories. Uses LLM to detect duplicates, refinements, and contradictions. Auto-generates tags, links, and entities when enabled.",
-	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"),
-		confidence: tool.schema
-			.number()
-			.optional()
-			.describe("Confidence level (0.0-1.0) affecting decay rate. Higher = slower decay. Default 0.7"),
-		autoTag: tool.schema
-			.boolean()
-			.optional()
-			.describe("Auto-generate tags using LLM. Default true"),
-		autoLink: tool.schema
-			.boolean()
-			.optional()
-			.describe("Auto-link to related memories. Default true"),
-		extractEntities: tool.schema
-			.boolean()
-			.optional()
-			.describe("Extract entities (people, places, technologies). Default false"),
-	},
-	async execute(args, ctx: ToolContext) {
-		const adapter = await getMemoryAdapter();
-		const result = await adapter.upsert(args);
-		return JSON.stringify(result, 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,
-	"semantic-memory_upsert": semantic_memory_upsert,
-} as const;