swarmkit 0.0.1 → 0.0.3

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

@@ -0,0 +1,37 @@
+export interface PackageDefinition {
+    /** npm package name */
+    name: string;
+    /** npm package name if different from `name` (e.g. scoped packages) */
+    npmName?: string;
+    /** Short description */
+    description: string;
+    /** Layer in the stack */
+    category: "orchestration" | "protocol" | "tasks" | "interface" | "learning" | "observability";
+    /** No per-project config — global only */
+    globalOnly?: boolean;
+}
+export interface BundleDefinition {
+    name: string;
+    label: string;
+    description: string;
+    packages: string[];
+}
+export interface Integration {
+    packages: [string, string];
+    description: string;
+}
+export declare const PACKAGES: Record<string, PackageDefinition>;
+export declare const BUNDLES: Record<string, BundleDefinition>;
+export declare const INTEGRATIONS: Integration[];
+/** Get all package names in a bundle */
+export declare function getBundlePackages(bundleName: string): string[];
+/** Get active integrations for a set of installed packages */
+export declare function getActiveIntegrations(installedPackages: string[]): Integration[];
+/** Get integrations that would activate if a new package were added */
+export declare function getNewIntegrations(currentPackages: string[], newPackage: string): Integration[];
+/** Get integrations that would break if a package were removed */
+export declare function getLostIntegrations(currentPackages: string[], removedPackage: string): Integration[];
+/** Get the npm package name for a registry key (resolves npmName override) */
+export declare function getNpmName(registryKey: string): string;
+export declare function isKnownPackage(name: string): boolean;
+export declare function getAllPackageNames(): string[];

package/dist/packages/registry.js

@@ -0,0 +1,154 @@
+export const PACKAGES = {
+    "self-driving-repo": {
+        name: "self-driving-repo",
+        description: "Event-driven workflow engine for autonomous GitHub SDLC",
+        category: "orchestration",
+    },
+    "multi-agent-protocol": {
+        name: "multi-agent-protocol",
+        npmName: "@multi-agent-protocol/sdk",
+        description: "JSON-RPC protocol for observing and coordinating agent systems",
+        category: "protocol",
+    },
+    opentasks: {
+        name: "opentasks",
+        description: "Cross-system graph for tasks, specs, and relationships",
+        category: "tasks",
+    },
+    "cognitive-core": {
+        name: "cognitive-core",
+        description: "Learning system — trajectories to playbooks to guidance",
+        category: "learning",
+    },
+    minimem: {
+        name: "minimem",
+        description: "File-based memory with hybrid vector + full-text search",
+        category: "learning",
+    },
+    "skill-tree": {
+        name: "skill-tree",
+        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",
+    },
+    sessionlog: {
+        name: "sessionlog",
+        description: "Git-integrated session capture with rewind and search",
+        category: "observability",
+    },
+    "claude-code-swarm": {
+        name: "claude-code-swarm",
+        description: "Claude Code plugin for agent team orchestration with openteams templates",
+        category: "orchestration",
+    },
+};
+export const BUNDLES = {
+    solo: {
+        name: "solo",
+        label: "Local agent development",
+        description: "Single developer running local agents",
+        packages: ["opentasks", "minimem"],
+    },
+    team: {
+        name: "team",
+        label: "Multi-agent team with learning",
+        description: "Agents that learn and share skills across a team",
+        packages: [
+            "opentasks",
+            "minimem",
+            "cognitive-core",
+            "skill-tree",
+        ],
+    },
+    platform: {
+        name: "platform",
+        label: "Full platform with learning and workflows",
+        description: "Complete platform with learning, skills, and GitHub automation",
+        packages: [
+            "opentasks",
+            "minimem",
+            "cognitive-core",
+            "skill-tree",
+            "self-driving-repo",
+            "openhive",
+        ],
+    },
+    github: {
+        name: "github",
+        label: "Autonomous GitHub workflows",
+        description: "Event-driven agents for GitHub SDLC automation",
+        packages: ["self-driving-repo", "opentasks"],
+    },
+};
+export const INTEGRATIONS = [
+    {
+        packages: ["cognitive-core", "minimem"],
+        description: "cognitive-core uses minimem as search layer",
+    },
+    {
+        packages: ["cognitive-core", "skill-tree"],
+        description: "skill-tree delegates to cognitive-core for batch learning",
+    },
+    {
+        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 */
+export function getBundlePackages(bundleName) {
+    const bundle = BUNDLES[bundleName];
+    if (!bundle)
+        return [];
+    return [...bundle.packages];
+}
+/** Get active integrations for a set of installed packages */
+export function getActiveIntegrations(installedPackages) {
+    const installed = new Set(installedPackages);
+    return INTEGRATIONS.filter((i) => installed.has(i.packages[0]) && installed.has(i.packages[1]));
+}
+/** Get integrations that would activate if a new package were added */
+export function getNewIntegrations(currentPackages, newPackage) {
+    const current = new Set(currentPackages);
+    return INTEGRATIONS.filter((i) => {
+        const [a, b] = i.packages;
+        return ((a === newPackage && current.has(b)) ||
+            (b === newPackage && current.has(a)));
+    });
+}
+/** Get integrations that would break if a package were removed */
+export function getLostIntegrations(currentPackages, removedPackage) {
+    const remaining = new Set(currentPackages.filter((p) => p !== removedPackage));
+    return INTEGRATIONS.filter((i) => {
+        const [a, b] = i.packages;
+        return ((a === removedPackage && remaining.has(b)) ||
+            (b === removedPackage && remaining.has(a)));
+    });
+}
+/** Get the npm package name for a registry key (resolves npmName override) */
+export function getNpmName(registryKey) {
+    const pkg = PACKAGES[registryKey];
+    return pkg?.npmName ?? registryKey;
+}
+export function isKnownPackage(name) {
+    return name in PACKAGES;
+}
+export function getAllPackageNames() {
+    return Object.keys(PACKAGES);
+}

package/dist/packages/registry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/packages/registry.test.js

@@ -0,0 +1,188 @@
+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 10 packages", () => {
+            expect(Object.keys(PACKAGES)).toHaveLength(10);
+        });
+        it("every package has name, description, and category", () => {
+            for (const [key, pkg] of Object.entries(PACKAGES)) {
+                expect(pkg.name).toBe(key);
+                expect(pkg.description).toBeTruthy();
+                expect(pkg.category).toBeTruthy();
+            }
+        });
+        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["opentasks"].npmName).toBeUndefined();
+            expect(PACKAGES["openteams"].npmName).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", () => {
+        it("contains 4 bundles", () => {
+            expect(Object.keys(BUNDLES)).toHaveLength(4);
+            expect(Object.keys(BUNDLES)).toEqual(expect.arrayContaining(["solo", "team", "platform", "github"]));
+        });
+        it("solo bundle has the right packages", () => {
+            expect(BUNDLES.solo.packages).toEqual([
+                "opentasks",
+                "minimem",
+            ]);
+        });
+        it("team bundle is a superset of solo", () => {
+            for (const pkg of BUNDLES.solo.packages) {
+                expect(BUNDLES.team.packages).toContain(pkg);
+            }
+            expect(BUNDLES.team.packages).toContain("cognitive-core");
+            expect(BUNDLES.team.packages).toContain("skill-tree");
+        });
+        it("platform bundle is a superset of team", () => {
+            for (const pkg of BUNDLES.team.packages) {
+                expect(BUNDLES.platform.packages).toContain(pkg);
+            }
+            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");
+        });
+        it("all bundle packages reference known packages", () => {
+            for (const bundle of Object.values(BUNDLES)) {
+                for (const pkg of bundle.packages) {
+                    expect(PACKAGES[pkg]).toBeDefined();
+                }
+            }
+        });
+    });
+    describe("INTEGRATIONS", () => {
+        it("all integrations reference known packages", () => {
+            for (const integration of INTEGRATIONS) {
+                expect(PACKAGES[integration.packages[0]]).toBeDefined();
+                expect(PACKAGES[integration.packages[1]]).toBeDefined();
+            }
+        });
+        it("all integrations have descriptions", () => {
+            for (const integration of INTEGRATIONS) {
+                expect(integration.description).toBeTruthy();
+            }
+        });
+    });
+    describe("getBundlePackages", () => {
+        it("returns packages for a known bundle", () => {
+            expect(getBundlePackages("solo")).toEqual(BUNDLES.solo.packages);
+        });
+        it("returns empty array for unknown bundle", () => {
+            expect(getBundlePackages("nonexistent")).toEqual([]);
+        });
+        it("returns a copy (not the original array)", () => {
+            const packages = getBundlePackages("solo");
+            packages.push("extra");
+            expect(getBundlePackages("solo")).not.toContain("extra");
+        });
+    });
+    describe("getActiveIntegrations", () => {
+        it("returns nothing for empty package list", () => {
+            expect(getActiveIntegrations([])).toEqual([]);
+        });
+        it("returns nothing for single package", () => {
+            expect(getActiveIntegrations(["opentasks"])).toEqual([]);
+        });
+        it("returns integration when both packages are installed", () => {
+            const result = getActiveIntegrations(["cognitive-core", "minimem"]);
+            expect(result).toHaveLength(1);
+            expect(result[0].packages).toEqual(["cognitive-core", "minimem"]);
+        });
+        it("returns multiple integrations for the platform bundle", () => {
+            const result = getActiveIntegrations(BUNDLES.platform.packages);
+            expect(result.length).toBeGreaterThanOrEqual(2);
+        });
+    });
+    describe("getNewIntegrations", () => {
+        it("returns integrations that would activate with a new package", () => {
+            const current = ["cognitive-core"];
+            const result = getNewIntegrations(current, "minimem");
+            expect(result).toHaveLength(1);
+            expect(result[0].packages).toEqual(["cognitive-core", "minimem"]);
+        });
+        it("returns nothing if no new integrations would activate", () => {
+            const current = ["minimem"];
+            const result = getNewIntegrations(current, "opentasks");
+            expect(result).toEqual([]);
+        });
+        it("returns multiple integrations when package connects to several", () => {
+            const current = ["minimem", "skill-tree"];
+            const result = getNewIntegrations(current, "cognitive-core");
+            expect(result).toHaveLength(2);
+        });
+        it("works regardless of package order in integration definition", () => {
+            // 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 = ["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", () => {
+            const current = ["minimem", "opentasks"];
+            const result = getLostIntegrations(current, "minimem");
+            expect(result).toEqual([]);
+        });
+    });
+    describe("isKnownPackage", () => {
+        it("returns true for known packages", () => {
+            expect(isKnownPackage("opentasks")).toBe(true);
+            expect(isKnownPackage("minimem")).toBe(true);
+            expect(isKnownPackage("openhive")).toBe(true);
+        });
+        it("returns false for unknown packages", () => {
+            expect(isKnownPackage("not-a-package")).toBe(false);
+            expect(isKnownPackage("")).toBe(false);
+        });
+    });
+    describe("getNpmName", () => {
+        it("returns npmName when set", () => {
+            expect(getNpmName("multi-agent-protocol")).toBe("@multi-agent-protocol/sdk");
+        });
+        it("returns registry key when npmName is not set", () => {
+            expect(getNpmName("opentasks")).toBe("opentasks");
+            expect(getNpmName("openteams")).toBe("openteams");
+            expect(getNpmName("sessionlog")).toBe("sessionlog");
+        });
+        it("returns the input for unknown packages", () => {
+            expect(getNpmName("not-a-package")).toBe("not-a-package");
+        });
+    });
+    describe("getAllPackageNames", () => {
+        it("returns all 10 package names", () => {
+            const names = getAllPackageNames();
+            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

@@ -0,0 +1,55 @@
+export interface InitContext {
+    /** Project root directory */
+    cwd: string;
+    /** All selected packages (used for cross-package wiring) */
+    packages: string[];
+    /** Embedding provider chosen during wizard */
+    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 */
+    packages: string[];
+    /** Embedding provider */
+    embeddingProvider: "openai" | "gemini" | "local" | null;
+    /** Stored API keys */
+    apiKeys: Record<string, string>;
+}
+export interface OpenhiveOptions {
+    name: string;
+    port: number;
+    authMode: string;
+    verification: string;
+    dataDir?: string;
+}
+export interface SetupResult {
+    package: string;
+    success: boolean;
+    message?: string;
+}
+/** 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).
+ */
+export declare const PROJECT_INIT_ORDER: string[];
+/** 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>;
+/** Config directories for global packages (relative to homedir) */
+export declare const GLOBAL_CONFIG_DIRS: Record<string, string>;
+/** Check whether a global package is already configured */
+export declare function isGlobalInit(pkg: string): boolean;
+/** Initialize a single global package */
+export declare function initGlobalPackage(pkg: string, ctx: GlobalContext, openhiveOpts?: OpenhiveOptions): Promise<SetupResult>;