opencode-swarm-plugin 0.21.0 → 0.22.0

package/src/swarm.integration.test.ts

@@ -1356,4 +1356,128 @@ describe("Swarm Prompt V2 (with Swarm Mail/Beads)", () => {
       expect(SUBTASK_PROMPT_V2).toContain("CRITICAL");
     });
   });
+
+  describe("swarm_complete automatic memory capture", () => {
+    let beadsAvailable = false;
+
+    beforeAll(async () => {
+      beadsAvailable = await isBeadsAvailable();
+    });
+
+    it.skipIf(!beadsAvailable)(
+      "includes memory_capture object in response",
+      async () => {
+        // Create a real bead for the test
+        const createResult =
+          await Bun.$`bd create "Test memory capture" -t task --json`
+            .quiet()
+            .nothrow();
+
+        if (createResult.exitCode !== 0) {
+          console.warn(
+            "Could not create bead:",
+            createResult.stderr.toString(),
+          );
+          return;
+        }
+
+        const bead = JSON.parse(createResult.stdout.toString());
+
+        try {
+          const result = await swarm_complete.execute(
+            {
+              project_key: "/tmp/test-memory-capture",
+              agent_name: "test-agent",
+              bead_id: bead.id,
+              summary: "Implemented auto-capture feature",
+              files_touched: ["src/swarm-orchestrate.ts"],
+              skip_verification: true,
+            },
+            mockContext,
+          );
+
+          const parsed = JSON.parse(result);
+
+          // Verify memory capture was attempted
+          expect(parsed).toHaveProperty("memory_capture");
+          expect(parsed.memory_capture).toHaveProperty("attempted", true);
+          expect(parsed.memory_capture).toHaveProperty("stored");
+          expect(parsed.memory_capture).toHaveProperty("information");
+          expect(parsed.memory_capture).toHaveProperty("metadata");
+
+          // Information should contain bead ID and summary
+          expect(parsed.memory_capture.information).toContain(bead.id);
+          expect(parsed.memory_capture.information).toContain(
+            "Implemented auto-capture feature",
+          );
+
+          // Metadata should contain relevant tags
+          expect(parsed.memory_capture.metadata).toContain("swarm");
+          expect(parsed.memory_capture.metadata).toContain("success");
+        } catch (error) {
+          // Clean up bead if test fails
+          await Bun.$`bd close ${bead.id} --reason "Test cleanup"`
+            .quiet()
+            .nothrow();
+          throw error;
+        }
+      },
+    );
+
+    it.skipIf(!beadsAvailable)(
+      "attempts to store in semantic-memory when available",
+      async () => {
+        const createResult =
+          await Bun.$`bd create "Test semantic-memory storage" -t task --json`
+            .quiet()
+            .nothrow();
+
+        if (createResult.exitCode !== 0) {
+          console.warn(
+            "Could not create bead:",
+            createResult.stderr.toString(),
+          );
+          return;
+        }
+
+        const bead = JSON.parse(createResult.stdout.toString());
+
+        try {
+          const result = await swarm_complete.execute(
+            {
+              project_key: "/tmp/test-memory-storage",
+              agent_name: "test-agent",
+              bead_id: bead.id,
+              summary: "Fixed critical bug in auth flow",
+              files_touched: ["src/auth.ts", "src/middleware.ts"],
+              skip_verification: true,
+            },
+            mockContext,
+          );
+
+          const parsed = JSON.parse(result);
+
+          // If semantic-memory is available, stored should be true
+          // If not, error should explain why
+          if (parsed.memory_capture.stored) {
+            expect(parsed.memory_capture.note).toContain(
+              "automatically stored in semantic-memory",
+            );
+          } else {
+            expect(parsed.memory_capture.error).toBeDefined();
+            expect(
+              parsed.memory_capture.error.includes("not available") ||
+                parsed.memory_capture.error.includes("failed"),
+            ).toBe(true);
+          }
+        } catch (error) {
+          // Clean up bead if test fails
+          await Bun.$`bd close ${bead.id} --reason "Test cleanup"`
+            .quiet()
+            .nothrow();
+          throw error;
+        }
+      },
+    );
+  });
 });

package/vitest.integration.config.ts

@@ -9,5 +9,11 @@ export default defineConfig({
     sequence: {
       concurrent: false,
     },
+    env: {
+      // Enable test-specific collections to isolate test data from production
+      TEST_MEMORY_COLLECTIONS: "true",
+    },
+    // Global setup/teardown hooks
+    globalSetup: "./vitest.integration.setup.ts",
   },
 });

package/vitest.integration.setup.ts

@@ -0,0 +1,48 @@
+/**
+ * Global setup/teardown for integration tests
+ *
+ * Ensures test-specific semantic-memory collections are cleaned up
+ * after all integration tests complete.
+ */
+
+export async function setup() {
+  console.log("[vitest] Integration test setup: TEST_MEMORY_COLLECTIONS=true");
+  // Setup runs before tests - environment variables are already set via vitest config
+}
+
+export async function teardown() {
+  console.log(
+    "[vitest] Integration test teardown: cleaning up test collections",
+  );
+
+  // Clean up test collections
+  const testCollections = [
+    "swarm-feedback-test",
+    "swarm-patterns-test",
+    "swarm-maturity-test",
+    "swarm-maturity-test-feedback",
+  ];
+
+  for (const collection of testCollections) {
+    try {
+      // Attempt to remove test collection data
+      // Note: semantic-memory doesn't have a built-in "delete collection" command,
+      // so we'll use the remove command with a wildcard or rely on TTL/manual cleanup
+      console.log(`[vitest] Attempting to clean collection: ${collection}`);
+
+      // List items and remove them (semantic-memory may not support bulk delete)
+      // This is a best-effort cleanup - some backends may require manual cleanup
+      // For now, we'll just log that cleanup should happen
+      console.log(
+        `[vitest] Note: Collection "${collection}" may need manual cleanup via semantic-memory CLI`,
+      );
+    } catch (error) {
+      console.warn(
+        `[vitest] Failed to clean collection ${collection}:`,
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+  }
+
+  console.log("[vitest] Integration test teardown complete");
+}