swarmkit 0.0.1 → 0.0.2

package/dist/packages/installer.js

@@ -0,0 +1,127 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { getNpmName } from "./registry.js";
+const execFileAsync = promisify(execFile);
+/**
+ * Install packages globally via npm.
+ */
+export async function installPackages(packages) {
+    const results = [];
+    for (const pkg of packages) {
+        const npmName = getNpmName(pkg);
+        try {
+            await execFileAsync("npm", ["install", "-g", npmName], {
+                timeout: 120_000,
+            });
+            const version = await getInstalledVersion(pkg);
+            results.push({ package: pkg, success: true, version: version ?? undefined });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            results.push({ package: pkg, success: false, error: formatNpmError(message) });
+        }
+    }
+    return results;
+}
+/**
+ * Uninstall a package globally via npm.
+ */
+export async function uninstallPackage(packageName) {
+    const npmName = getNpmName(packageName);
+    await execFileAsync("npm", ["uninstall", "-g", npmName], {
+        timeout: 60_000,
+    });
+}
+/**
+ * Get the currently installed global version of a package, or null if not installed.
+ */
+export async function getInstalledVersion(packageName) {
+    const npmName = getNpmName(packageName);
+    try {
+        const { stdout } = await execFileAsync("npm", ["list", "-g", npmName, "--json", "--depth=0"], { timeout: 15_000 });
+        const data = JSON.parse(stdout);
+        return data.dependencies?.[npmName]?.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the latest published version of a package from the registry.
+ */
+export async function getLatestVersion(packageName) {
+    const npmName = getNpmName(packageName);
+    try {
+        const { stdout } = await execFileAsync("npm", ["view", npmName, "version"], { timeout: 15_000 });
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Update installed packages to their latest versions.
+ */
+export async function updatePackages(packages) {
+    const results = [];
+    for (const pkg of packages) {
+        const previousVersion = await getInstalledVersion(pkg);
+        const latestVersion = await getLatestVersion(pkg);
+        if (!latestVersion) {
+            results.push({
+                package: pkg,
+                previousVersion,
+                newVersion: null,
+                updated: false,
+                error: "Could not fetch latest version",
+            });
+            continue;
+        }
+        if (previousVersion === latestVersion) {
+            results.push({
+                package: pkg,
+                previousVersion,
+                newVersion: latestVersion,
+                updated: false,
+            });
+            continue;
+        }
+        const npmName = getNpmName(pkg);
+        try {
+            await execFileAsync("npm", ["install", "-g", `${npmName}@latest`], {
+                timeout: 120_000,
+            });
+            const newVersion = await getInstalledVersion(pkg);
+            results.push({
+                package: pkg,
+                previousVersion,
+                newVersion,
+                updated: true,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            results.push({
+                package: pkg,
+                previousVersion,
+                newVersion: null,
+                updated: false,
+                error: formatNpmError(message),
+            });
+        }
+    }
+    return results;
+}
+function formatNpmError(message) {
+    if (message.includes("EACCES") || message.includes("permission")) {
+        return "Permission denied — try running with sudo or configure npm prefix";
+    }
+    if (message.includes("ENOTFOUND") || message.includes("network")) {
+        return "Network error — check your internet connection";
+    }
+    if (message.includes("404") || message.includes("Not Found")) {
+        return "Package not found in npm registry";
+    }
+    // Return first line of error to keep it concise
+    return message.split("\n")[0];
+}

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

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

package/dist/packages/installer.test.js

@@ -0,0 +1,200 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+// Mock child_process.execFile
+const mockExecFile = vi.fn();
+vi.mock("node:child_process", () => ({
+    execFile: mockExecFile,
+}));
+// Mock promisify to return our mock
+vi.mock("node:util", async () => {
+    const actual = await vi.importActual("node:util");
+    return {
+        ...actual,
+        promisify: () => mockExecFile,
+    };
+});
+const { installPackages, uninstallPackage, getInstalledVersion, getLatestVersion, updatePackages, } = await import("./installer.js");
+describe("installer", () => {
+    beforeEach(() => {
+        mockExecFile.mockReset();
+    });
+    describe("getInstalledVersion", () => {
+        it("returns version when package is installed", async () => {
+            mockExecFile.mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    dependencies: { minimem: { version: "0.1.0" } },
+                }),
+            });
+            const version = await getInstalledVersion("minimem");
+            expect(version).toBe("0.1.0");
+            expect(mockExecFile).toHaveBeenCalledWith("npm", ["list", "-g", "minimem", "--json", "--depth=0"], { timeout: 15_000 });
+        });
+        it("returns null when package is not installed", async () => {
+            mockExecFile.mockRejectedValueOnce(new Error("not found"));
+            const version = await getInstalledVersion("not-installed");
+            expect(version).toBeNull();
+        });
+        it("returns null when dependencies field is missing", async () => {
+            mockExecFile.mockResolvedValueOnce({ stdout: JSON.stringify({}) });
+            const version = await getInstalledVersion("minimem");
+            expect(version).toBeNull();
+        });
+    });
+    describe("getLatestVersion", () => {
+        it("returns version from npm registry", async () => {
+            mockExecFile.mockResolvedValueOnce({ stdout: "0.2.0\n" });
+            const version = await getLatestVersion("minimem");
+            expect(version).toBe("0.2.0");
+            expect(mockExecFile).toHaveBeenCalledWith("npm", ["view", "minimem", "version"], { timeout: 15_000 });
+        });
+        it("returns null on network error", async () => {
+            mockExecFile.mockRejectedValueOnce(new Error("ENOTFOUND"));
+            const version = await getLatestVersion("minimem");
+            expect(version).toBeNull();
+        });
+        it("returns null for empty stdout", async () => {
+            mockExecFile.mockResolvedValueOnce({ stdout: "" });
+            const version = await getLatestVersion("minimem");
+            expect(version).toBeNull();
+        });
+    });
+    describe("installPackages", () => {
+        it("installs a single package successfully", async () => {
+            // First call: npm install -g
+            mockExecFile.mockResolvedValueOnce({ stdout: "", stderr: "" });
+            // Second call: npm list -g (getInstalledVersion)
+            mockExecFile.mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    dependencies: { minimem: { version: "0.1.0" } },
+                }),
+            });
+            const results = await installPackages(["minimem"]);
+            expect(results).toHaveLength(1);
+            expect(results[0]).toEqual({
+                package: "minimem",
+                success: true,
+                version: "0.1.0",
+            });
+        });
+        it("reports failure on install error", async () => {
+            mockExecFile.mockRejectedValueOnce(new Error("EACCES permission denied"));
+            const results = await installPackages(["minimem"]);
+            expect(results).toHaveLength(1);
+            expect(results[0].success).toBe(false);
+            expect(results[0].error).toContain("Permission denied");
+        });
+        it("installs multiple packages sequentially", async () => {
+            // Package 1: success
+            mockExecFile.mockResolvedValueOnce({ stdout: "" });
+            mockExecFile.mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    dependencies: { minimem: { version: "0.1.0" } },
+                }),
+            });
+            // Package 2: success
+            mockExecFile.mockResolvedValueOnce({ stdout: "" });
+            mockExecFile.mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    dependencies: { opentasks: { version: "0.0.3" } },
+                }),
+            });
+            const results = await installPackages(["minimem", "opentasks"]);
+            expect(results).toHaveLength(2);
+            expect(results[0].success).toBe(true);
+            expect(results[1].success).toBe(true);
+        });
+        it("handles mixed success and failure", async () => {
+            // Package 1: success
+            mockExecFile.mockResolvedValueOnce({ stdout: "" });
+            mockExecFile.mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    dependencies: { minimem: { version: "0.1.0" } },
+                }),
+            });
+            // Package 2: failure
+            mockExecFile.mockRejectedValueOnce(new Error("404 Not Found"));
+            const results = await installPackages(["minimem", "bad-package"]);
+            expect(results[0].success).toBe(true);
+            expect(results[1].success).toBe(false);
+            expect(results[1].error).toContain("not found");
+        });
+    });
+    describe("uninstallPackage", () => {
+        it("calls npm uninstall -g", async () => {
+            mockExecFile.mockResolvedValueOnce({ stdout: "" });
+            await uninstallPackage("minimem");
+            expect(mockExecFile).toHaveBeenCalledWith("npm", ["uninstall", "-g", "minimem"], { timeout: 60_000 });
+        });
+        it("throws on failure", async () => {
+            mockExecFile.mockRejectedValueOnce(new Error("failed"));
+            await expect(uninstallPackage("minimem")).rejects.toThrow("failed");
+        });
+    });
+    describe("updatePackages", () => {
+        it("reports package as up to date when versions match", async () => {
+            // getInstalledVersion
+            mockExecFile.mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    dependencies: { minimem: { version: "0.1.0" } },
+                }),
+            });
+            // getLatestVersion
+            mockExecFile.mockResolvedValueOnce({ stdout: "0.1.0\n" });
+            const results = await updatePackages(["minimem"]);
+            expect(results).toHaveLength(1);
+            expect(results[0].updated).toBe(false);
+            expect(results[0].previousVersion).toBe("0.1.0");
+            expect(results[0].newVersion).toBe("0.1.0");
+        });
+        it("updates package when newer version is available", async () => {
+            // getInstalledVersion (before)
+            mockExecFile.mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    dependencies: { minimem: { version: "0.1.0" } },
+                }),
+            });
+            // getLatestVersion
+            mockExecFile.mockResolvedValueOnce({ stdout: "0.2.0\n" });
+            // npm install -g minimem@latest
+            mockExecFile.mockResolvedValueOnce({ stdout: "" });
+            // getInstalledVersion (after)
+            mockExecFile.mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    dependencies: { minimem: { version: "0.2.0" } },
+                }),
+            });
+            const results = await updatePackages(["minimem"]);
+            expect(results).toHaveLength(1);
+            expect(results[0].updated).toBe(true);
+            expect(results[0].previousVersion).toBe("0.1.0");
+            expect(results[0].newVersion).toBe("0.2.0");
+        });
+        it("reports error when latest version cannot be fetched", async () => {
+            // getInstalledVersion
+            mockExecFile.mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    dependencies: { minimem: { version: "0.1.0" } },
+                }),
+            });
+            // getLatestVersion fails
+            mockExecFile.mockRejectedValueOnce(new Error("network error"));
+            const results = await updatePackages(["minimem"]);
+            expect(results[0].updated).toBe(false);
+            expect(results[0].error).toBe("Could not fetch latest version");
+        });
+        it("reports error when install fails during update", async () => {
+            // getInstalledVersion
+            mockExecFile.mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    dependencies: { minimem: { version: "0.1.0" } },
+                }),
+            });
+            // getLatestVersion
+            mockExecFile.mockResolvedValueOnce({ stdout: "0.2.0\n" });
+            // npm install fails
+            mockExecFile.mockRejectedValueOnce(new Error("EACCES permission denied"));
+            const results = await updatePackages(["minimem"]);
+            expect(results[0].updated).toBe(false);
+            expect(results[0].error).toContain("Permission denied");
+        });
+    });
+});

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" | "security" | "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,179 @@
+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",
+        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",
+    },
+    "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",
+        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",
+    },
+    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,
+    },
+};
+export const BUNDLES = {
+    solo: {
+        name: "solo",
+        label: "Local agent development",
+        description: "Single developer running local agents",
+        packages: ["macro-agent", "opentasks", "minimem", "agent-iam"],
+    },
+    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",
+        packages: [
+            "macro-agent",
+            "opentasks",
+            "minimem",
+            "agent-iam",
+            "cognitive-core",
+            "skill-tree",
+            "openswarm",
+            "openhive",
+        ],
+    },
+    github: {
+        name: "github",
+        label: "Autonomous GitHub workflows",
+        description: "Event-driven agents for GitHub SDLC automation",
+        packages: ["self-driving-repo", "opentasks", "agent-iam"],
+    },
+};
+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",
+    },
+    {
+        packages: ["cognitive-core", "skill-tree"],
+        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",
+    },
+];
+/** 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 {};