swarmkit 0.0.2 → 0.0.4

package/dist/packages/plugin.test.js

@@ -0,0 +1,99 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+// Mock child_process.execFile
+const mockExecFile = vi.fn();
+vi.mock("node:child_process", () => ({
+    execFile: mockExecFile,
+}));
+vi.mock("node:util", async () => {
+    const actual = await vi.importActual("node:util");
+    return {
+        ...actual,
+        promisify: () => mockExecFile,
+    };
+});
+// Mock fs.existsSync for isInstalledPlugin
+const mockExistsSync = vi.fn();
+vi.mock("node:fs", async () => {
+    const actual = await vi.importActual("node:fs");
+    return {
+        ...actual,
+        existsSync: (...args) => mockExistsSync(...args),
+    };
+});
+const { isInstalledPlugin, registerPlugin } = await import("./plugin.js");
+describe("plugin", () => {
+    beforeEach(() => {
+        mockExecFile.mockReset();
+        mockExistsSync.mockReset();
+    });
+    describe("isInstalledPlugin", () => {
+        it("returns true when .claude-plugin/plugin.json exists", async () => {
+            // getGlobalPackagePath
+            mockExecFile.mockResolvedValueOnce({
+                stdout: "/usr/local/lib/node_modules\n/usr/local/lib/node_modules/claude-code-swarm\n",
+            });
+            mockExistsSync.mockReturnValue(true);
+            const result = await isInstalledPlugin("claude-code-swarm");
+            expect(result).toBe(true);
+            expect(mockExistsSync).toHaveBeenCalledWith(expect.stringContaining(".claude-plugin/plugin.json"));
+        });
+        it("returns false when package is not installed", async () => {
+            mockExecFile.mockRejectedValueOnce(new Error("not found"));
+            const result = await isInstalledPlugin("not-installed");
+            expect(result).toBe(false);
+        });
+        it("returns false when package exists but has no .claude-plugin/", async () => {
+            mockExecFile.mockResolvedValueOnce({
+                stdout: "/usr/local/lib/node_modules\n/usr/local/lib/node_modules/minimem\n",
+            });
+            mockExistsSync.mockReturnValue(false);
+            const result = await isInstalledPlugin("minimem");
+            expect(result).toBe(false);
+        });
+    });
+    describe("registerPlugin", () => {
+        it("calls claude plugin add with user scope by default", async () => {
+            // getGlobalPackagePath
+            mockExecFile.mockResolvedValueOnce({
+                stdout: "/usr/local/lib/node_modules\n/usr/local/lib/node_modules/claude-code-swarm\n",
+            });
+            // claude plugin add
+            mockExecFile.mockResolvedValueOnce({ stdout: "Plugin added\n" });
+            await registerPlugin("claude-code-swarm");
+            expect(mockExecFile).toHaveBeenCalledWith("claude", ["plugin", "add", "/usr/local/lib/node_modules/claude-code-swarm", "--scope", "user"], { timeout: 30_000 });
+        });
+        it("passes project scope to claude plugin add", async () => {
+            // getGlobalPackagePath
+            mockExecFile.mockResolvedValueOnce({
+                stdout: "/usr/local/lib/node_modules\n/usr/local/lib/node_modules/claude-code-swarm\n",
+            });
+            // claude plugin add
+            mockExecFile.mockResolvedValueOnce({ stdout: "" });
+            await registerPlugin("claude-code-swarm", "project");
+            expect(mockExecFile).toHaveBeenCalledWith("claude", ["plugin", "add", "/usr/local/lib/node_modules/claude-code-swarm", "--scope", "project"], { timeout: 30_000 });
+        });
+        it("passes local scope to claude plugin add", async () => {
+            // getGlobalPackagePath
+            mockExecFile.mockResolvedValueOnce({
+                stdout: "/usr/local/lib/node_modules\n/usr/local/lib/node_modules/claude-code-swarm\n",
+            });
+            // claude plugin add
+            mockExecFile.mockResolvedValueOnce({ stdout: "" });
+            await registerPlugin("claude-code-swarm", "local");
+            expect(mockExecFile).toHaveBeenCalledWith("claude", ["plugin", "add", "/usr/local/lib/node_modules/claude-code-swarm", "--scope", "local"], { timeout: 30_000 });
+        });
+        it("throws when global path cannot be resolved", async () => {
+            mockExecFile.mockRejectedValueOnce(new Error("not found"));
+            await expect(registerPlugin("not-installed")).rejects.toThrow("Could not resolve global install path");
+        });
+        it("throws when claude plugin add fails", async () => {
+            // getGlobalPackagePath
+            mockExecFile.mockResolvedValueOnce({
+                stdout: "/usr/local/lib/node_modules\n/usr/local/lib/node_modules/claude-code-swarm\n",
+            });
+            // claude plugin add fails
+            mockExecFile.mockRejectedValueOnce(new Error("registration failed"));
+            await expect(registerPlugin("claude-code-swarm")).rejects.toThrow("registration failed");
+        });
+    });
+});

package/dist/packages/registry.d.ts

@@ -6,7 +6,7 @@ export interface PackageDefinition {
     /** Short description */
     description: string;
     /** Layer in the stack */
-    category: "orchestration" | "protocol" | "tasks" | "security" | "interface" | "learning" | "observability";
+    category: "orchestration" | "protocol" | "tasks" | "interface" | "learning" | "observability";
     /** No per-project config — global only */
     globalOnly?: boolean;
 }

package/dist/packages/registry.js

@@ -1,9 +1,4 @@
 export const PACKAGES = {
-    "macro-agent": {
-        name: "macro-agent",
-        description: "Multi-agent orchestration for hierarchical Claude Code agents",
-        category: "orchestration",
-    },
     "self-driving-repo": {
         name: "self-driving-repo",
         description: "Event-driven workflow engine for autonomous GitHub SDLC",
@@ -20,22 +15,6 @@ export const PACKAGES = {
         description: "Cross-system graph for tasks, specs, and relationships",
         category: "tasks",
     },
-    "agent-iam": {
-        name: "agent-iam",
-        description: "Capability-based credential broker for AI agents",
-        category: "security",
-        globalOnly: true,
-    },
-    openswarm: {
-        name: "openswarm",
-        description: "Multi-agent terminal UI and MAP server host",
-        category: "interface",
-    },
-    openhive: {
-        name: "openhive",
-        description: "Self-hostable social network and coordination hub for agents",
-        category: "interface",
-    },
     "cognitive-core": {
         name: "cognitive-core",
         description: "Learning system — trajectories to playbooks to guidance",
@@ -51,17 +30,25 @@ export const PACKAGES = {
         description: "Versioned skill extraction, evolution, and serving",
         category: "learning",
     },
+    openhive: {
+        name: "openhive",
+        description: "Self-hostable social network and coordination hub for agents",
+        category: "interface",
+    },
     openteams: {
         name: "openteams",
         description: "Team topology definitions and agent role generation",
         category: "orchestration",
-        globalOnly: true,
     },
     sessionlog: {
         name: "sessionlog",
         description: "Git-integrated session capture with rewind and search",
         category: "observability",
-        globalOnly: true,
+    },
+    "claude-code-swarm": {
+        name: "claude-code-swarm",
+        description: "Claude Code plugin for agent team orchestration with openteams templates",
+        category: "orchestration",
     },
 };
 export const BUNDLES = {
@@ -69,33 +56,29 @@ export const BUNDLES = {
         name: "solo",
         label: "Local agent development",
         description: "Single developer running local agents",
-        packages: ["macro-agent", "opentasks", "minimem", "agent-iam"],
+        packages: ["opentasks", "minimem"],
     },
     team: {
         name: "team",
         label: "Multi-agent team with learning",
         description: "Agents that learn and share skills across a team",
         packages: [
-            "macro-agent",
             "opentasks",
             "minimem",
-            "agent-iam",
             "cognitive-core",
             "skill-tree",
         ],
     },
     platform: {
         name: "platform",
-        label: "Full self-hosted platform",
-        description: "Complete platform with UI, agent hub, and learning",
+        label: "Full platform with learning and workflows",
+        description: "Complete platform with learning, skills, and GitHub automation",
         packages: [
-            "macro-agent",
             "opentasks",
             "minimem",
-            "agent-iam",
             "cognitive-core",
             "skill-tree",
-            "openswarm",
+            "self-driving-repo",
             "openhive",
         ],
     },
@@ -103,26 +86,10 @@ export const BUNDLES = {
         name: "github",
         label: "Autonomous GitHub workflows",
         description: "Event-driven agents for GitHub SDLC automation",
-        packages: ["self-driving-repo", "opentasks", "agent-iam"],
+        packages: ["self-driving-repo", "opentasks"],
     },
 };
 export const INTEGRATIONS = [
-    {
-        packages: ["macro-agent", "opentasks"],
-        description: "macro-agent uses opentasks as task backend",
-    },
-    {
-        packages: ["macro-agent", "multi-agent-protocol"],
-        description: "macro-agent implements MAP for agent observation",
-    },
-    {
-        packages: ["openswarm", "macro-agent"],
-        description: "openswarm's macro-agent plugin provides TUI management",
-    },
-    {
-        packages: ["openhive", "openswarm"],
-        description: "openhive hosts openswarm instances and acts as MAP Hub",
-    },
     {
         packages: ["cognitive-core", "minimem"],
         description: "cognitive-core uses minimem as search layer",
@@ -132,8 +99,16 @@ export const INTEGRATIONS = [
         description: "skill-tree delegates to cognitive-core for batch learning",
     },
     {
-        packages: ["agent-iam", "macro-agent"],
-        description: "macro-agent uses agent-iam for agent credential management",
+        packages: ["claude-code-swarm", "openteams"],
+        description: "claude-code-swarm uses openteams for team topology definitions",
+    },
+    {
+        packages: ["claude-code-swarm", "multi-agent-protocol"],
+        description: "claude-code-swarm uses MAP for external agent observability",
+    },
+    {
+        packages: ["claude-code-swarm", "sessionlog"],
+        description: "claude-code-swarm bridges sessionlog data to MAP via trajectory protocol",
     },
 ];
 /** Get all package names in a bundle */

package/dist/packages/registry.test.js

@@ -2,8 +2,8 @@ import { describe, it, expect } from "vitest";
 import { PACKAGES, BUNDLES, INTEGRATIONS, getBundlePackages, getActiveIntegrations, getNewIntegrations, getLostIntegrations, getNpmName, isKnownPackage, getAllPackageNames, } from "./registry.js";
 describe("registry", () => {
     describe("PACKAGES", () => {
-        it("contains all 12 packages", () => {
-            expect(Object.keys(PACKAGES)).toHaveLength(12);
+        it("contains all 10 packages", () => {
+            expect(Object.keys(PACKAGES)).toHaveLength(10);
         });
         it("every package has name, description, and category", () => {
             for (const [key, pkg] of Object.entries(PACKAGES)) {
@@ -12,23 +12,25 @@ describe("registry", () => {
                 expect(pkg.category).toBeTruthy();
             }
         });
-        it("agent-iam is marked globalOnly", () => {
-            expect(PACKAGES["agent-iam"].globalOnly).toBe(true);
-        });
-        it("openteams and sessionlog are marked globalOnly", () => {
-            expect(PACKAGES["openteams"].globalOnly).toBe(true);
-            expect(PACKAGES["sessionlog"].globalOnly).toBe(true);
+        it("no packages are marked globalOnly", () => {
+            for (const pkg of Object.values(PACKAGES)) {
+                expect(pkg.globalOnly).toBeUndefined();
+            }
         });
         it("multi-agent-protocol has npmName override", () => {
             expect(PACKAGES["multi-agent-protocol"].npmName).toBe("@multi-agent-protocol/sdk");
         });
         it("most packages do not have npmName", () => {
-            expect(PACKAGES["macro-agent"].npmName).toBeUndefined();
+            expect(PACKAGES["opentasks"].npmName).toBeUndefined();
             expect(PACKAGES["openteams"].npmName).toBeUndefined();
         });
-        it("other packages are not globalOnly", () => {
-            expect(PACKAGES["macro-agent"].globalOnly).toBeUndefined();
-            expect(PACKAGES["opentasks"].globalOnly).toBeUndefined();
+        it("openteams and sessionlog have project-level config", () => {
+            expect(PACKAGES["openteams"].globalOnly).toBeUndefined();
+            expect(PACKAGES["sessionlog"].globalOnly).toBeUndefined();
+        });
+        it("claude-code-swarm is an orchestration package", () => {
+            expect(PACKAGES["claude-code-swarm"]).toBeDefined();
+            expect(PACKAGES["claude-code-swarm"].category).toBe("orchestration");
         });
     });
     describe("BUNDLES", () => {
@@ -38,10 +40,8 @@ describe("registry", () => {
         });
         it("solo bundle has the right packages", () => {
             expect(BUNDLES.solo.packages).toEqual([
-                "macro-agent",
                 "opentasks",
                 "minimem",
-                "agent-iam",
             ]);
         });
         it("team bundle is a superset of solo", () => {
@@ -55,13 +55,12 @@ describe("registry", () => {
             for (const pkg of BUNDLES.team.packages) {
                 expect(BUNDLES.platform.packages).toContain(pkg);
             }
-            expect(BUNDLES.platform.packages).toContain("openswarm");
+            expect(BUNDLES.platform.packages).toContain("self-driving-repo");
             expect(BUNDLES.platform.packages).toContain("openhive");
         });
         it("github bundle has self-driving-repo", () => {
             expect(BUNDLES.github.packages).toContain("self-driving-repo");
             expect(BUNDLES.github.packages).toContain("opentasks");
-            expect(BUNDLES.github.packages).toContain("agent-iam");
         });
         it("all bundle packages reference known packages", () => {
             for (const bundle of Object.values(BUNDLES)) {
@@ -102,34 +101,24 @@ describe("registry", () => {
             expect(getActiveIntegrations([])).toEqual([]);
         });
         it("returns nothing for single package", () => {
-            expect(getActiveIntegrations(["macro-agent"])).toEqual([]);
+            expect(getActiveIntegrations(["opentasks"])).toEqual([]);
         });
         it("returns integration when both packages are installed", () => {
-            const result = getActiveIntegrations(["macro-agent", "opentasks"]);
+            const result = getActiveIntegrations(["cognitive-core", "minimem"]);
             expect(result).toHaveLength(1);
-            expect(result[0].packages).toEqual(["macro-agent", "opentasks"]);
-        });
-        it("returns multiple integrations for the solo bundle", () => {
-            const result = getActiveIntegrations(BUNDLES.solo.packages);
-            expect(result.length).toBeGreaterThanOrEqual(2);
-            // Should include macro-agent+opentasks and agent-iam+macro-agent
-            const pairs = result.map((i) => i.packages.join("+"));
-            expect(pairs).toContain("macro-agent+opentasks");
-            expect(pairs).toContain("agent-iam+macro-agent");
+            expect(result[0].packages).toEqual(["cognitive-core", "minimem"]);
         });
-        it("returns all integrations for the platform bundle", () => {
+        it("returns multiple integrations for the platform bundle", () => {
             const result = getActiveIntegrations(BUNDLES.platform.packages);
-            // platform has all packages except self-driving-repo and multi-agent-protocol
-            // so it should activate most integrations
-            expect(result.length).toBeGreaterThanOrEqual(5);
+            expect(result.length).toBeGreaterThanOrEqual(2);
         });
     });
     describe("getNewIntegrations", () => {
         it("returns integrations that would activate with a new package", () => {
-            const current = ["macro-agent"];
-            const result = getNewIntegrations(current, "opentasks");
+            const current = ["cognitive-core"];
+            const result = getNewIntegrations(current, "minimem");
             expect(result).toHaveLength(1);
-            expect(result[0].packages).toEqual(["macro-agent", "opentasks"]);
+            expect(result[0].packages).toEqual(["cognitive-core", "minimem"]);
         });
         it("returns nothing if no new integrations would activate", () => {
             const current = ["minimem"];
@@ -137,22 +126,22 @@ describe("registry", () => {
             expect(result).toEqual([]);
         });
         it("returns multiple integrations when package connects to several", () => {
-            const current = ["opentasks", "multi-agent-protocol", "agent-iam"];
-            const result = getNewIntegrations(current, "macro-agent");
-            expect(result.length).toBeGreaterThanOrEqual(2);
+            const current = ["minimem", "skill-tree"];
+            const result = getNewIntegrations(current, "cognitive-core");
+            expect(result).toHaveLength(2);
         });
         it("works regardless of package order in integration definition", () => {
-            // openswarm+macro-agent is defined as ["openswarm", "macro-agent"]
-            const current = ["macro-agent"];
-            const result = getNewIntegrations(current, "openswarm");
+            // cognitive-core+minimem is defined as ["cognitive-core", "minimem"]
+            const current = ["minimem"];
+            const result = getNewIntegrations(current, "cognitive-core");
             expect(result).toHaveLength(1);
         });
     });
     describe("getLostIntegrations", () => {
         it("returns integrations that would break when removing a package", () => {
-            const current = ["macro-agent", "opentasks", "agent-iam"];
-            const result = getLostIntegrations(current, "macro-agent");
-            // Removing macro-agent breaks macro-agent+opentasks and agent-iam+macro-agent
+            const current = ["cognitive-core", "minimem", "skill-tree"];
+            const result = getLostIntegrations(current, "cognitive-core");
+            // Removing cognitive-core breaks cognitive-core+minimem and cognitive-core+skill-tree
             expect(result).toHaveLength(2);
         });
         it("returns nothing if removing a package with no active integrations", () => {
@@ -163,9 +152,9 @@ describe("registry", () => {
     });
     describe("isKnownPackage", () => {
         it("returns true for known packages", () => {
-            expect(isKnownPackage("macro-agent")).toBe(true);
+            expect(isKnownPackage("opentasks")).toBe(true);
             expect(isKnownPackage("minimem")).toBe(true);
-            expect(isKnownPackage("agent-iam")).toBe(true);
+            expect(isKnownPackage("openhive")).toBe(true);
         });
         it("returns false for unknown packages", () => {
             expect(isKnownPackage("not-a-package")).toBe(false);
@@ -177,7 +166,7 @@ describe("registry", () => {
             expect(getNpmName("multi-agent-protocol")).toBe("@multi-agent-protocol/sdk");
         });
         it("returns registry key when npmName is not set", () => {
-            expect(getNpmName("macro-agent")).toBe("macro-agent");
+            expect(getNpmName("opentasks")).toBe("opentasks");
             expect(getNpmName("openteams")).toBe("openteams");
             expect(getNpmName("sessionlog")).toBe("sessionlog");
         });
@@ -186,14 +175,14 @@ describe("registry", () => {
         });
     });
     describe("getAllPackageNames", () => {
-        it("returns all 12 package names", () => {
+        it("returns all 10 package names", () => {
             const names = getAllPackageNames();
-            expect(names).toHaveLength(12);
-            expect(names).toContain("macro-agent");
+            expect(names).toHaveLength(10);
             expect(names).toContain("minimem");
             expect(names).toContain("self-driving-repo");
             expect(names).toContain("openteams");
             expect(names).toContain("sessionlog");
+            expect(names).toContain("claude-code-swarm");
         });
     });
 });

package/dist/packages/setup.d.ts

@@ -7,6 +7,8 @@ export interface InitContext {
     embeddingProvider: "openai" | "gemini" | "local" | null;
     /** Stored API keys (provider → key) */
     apiKeys: Record<string, string>;
+    /** Whether to nest project configs under .swarm/ (default true) */
+    usePrefix: boolean;
 }
 export interface GlobalContext {
     /** All selected packages */
@@ -28,15 +30,20 @@ export interface SetupResult {
     success: boolean;
     message?: string;
 }
-/** Config directories each package creates at the project level */
+/** Root directory for all swarmkit project-level config */
+export declare const PROJECT_ROOT = ".swarm";
+/** Config directories with .swarm/ prefix (default layout) */
 export declare const PROJECT_CONFIG_DIRS: Record<string, string>;
+/** Config directories without prefix (flat layout, --no-prefix) */
+export declare const FLAT_PROJECT_CONFIG_DIRS: Record<string, string>;
+/** Get config dirs for the given mode */
+export declare function projectConfigDirs(usePrefix: boolean): Record<string, string>;
 /**
  * Project-level packages in correct init order.
- * Order matters: minimem before cognitive-core (runtime detection),
- * opentasks before macro-agent (task backend wiring).
+ * Order matters: minimem before cognitive-core (runtime detection).
  */
 export declare const PROJECT_INIT_ORDER: string[];
-/** Check whether a package is already initialized in a project */
+/** Check whether a package is already initialized in a project (checks both layouts) */
 export declare function isProjectInit(cwd: string, pkg: string): boolean;
 /** Initialize a single project-level package */
 export declare function initProjectPackage(pkg: string, ctx: InitContext): Promise<SetupResult>;