swarmkit 0.0.1 → 0.0.2

package/dist/packages/registry.test.js

@@ -0,0 +1,199 @@
+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("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("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("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["openteams"].npmName).toBeUndefined();
+        });
+        it("other packages are not globalOnly", () => {
+            expect(PACKAGES["macro-agent"].globalOnly).toBeUndefined();
+            expect(PACKAGES["opentasks"].globalOnly).toBeUndefined();
+        });
+    });
+    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([
+                "macro-agent",
+                "opentasks",
+                "minimem",
+                "agent-iam",
+            ]);
+        });
+        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("openswarm");
+            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)) {
+                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(["macro-agent"])).toEqual([]);
+        });
+        it("returns integration when both packages are installed", () => {
+            const result = getActiveIntegrations(["macro-agent", "opentasks"]);
+            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");
+        });
+        it("returns all 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);
+        });
+    });
+    describe("getNewIntegrations", () => {
+        it("returns integrations that would activate with a new package", () => {
+            const current = ["macro-agent"];
+            const result = getNewIntegrations(current, "opentasks");
+            expect(result).toHaveLength(1);
+            expect(result[0].packages).toEqual(["macro-agent", "opentasks"]);
+        });
+        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 = ["opentasks", "multi-agent-protocol", "agent-iam"];
+            const result = getNewIntegrations(current, "macro-agent");
+            expect(result.length).toBeGreaterThanOrEqual(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");
+            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
+            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("macro-agent")).toBe(true);
+            expect(isKnownPackage("minimem")).toBe(true);
+            expect(isKnownPackage("agent-iam")).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("macro-agent")).toBe("macro-agent");
+            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 12 package names", () => {
+            const names = getAllPackageNames();
+            expect(names).toHaveLength(12);
+            expect(names).toContain("macro-agent");
+            expect(names).toContain("minimem");
+            expect(names).toContain("self-driving-repo");
+            expect(names).toContain("openteams");
+            expect(names).toContain("sessionlog");
+        });
+    });
+});

package/dist/packages/setup.d.ts

@@ -0,0 +1,48 @@
+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>;
+}
+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;
+}
+/** Config directories each package creates at the project level */
+export declare const PROJECT_CONFIG_DIRS: 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).
+ */
+export declare const PROJECT_INIT_ORDER: string[];
+/** Check whether a package is already initialized in a project */
+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>;

package/dist/packages/setup.js

@@ -0,0 +1,309 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
+import { basename, join } from "node:path";
+import { homedir } from "node:os";
+const execFileAsync = promisify(execFile);
+// ─── Project-level setup ─────────────────────────────────────────────────────
+/** Config directories each package creates at the project level */
+export const PROJECT_CONFIG_DIRS = {
+    opentasks: ".opentasks",
+    minimem: ".minimem",
+    "cognitive-core": ".cognitive-core",
+    "macro-agent": ".multiagent",
+    "self-driving-repo": ".self-driving",
+};
+/**
+ * Project-level packages in correct init order.
+ * Order matters: minimem before cognitive-core (runtime detection),
+ * opentasks before macro-agent (task backend wiring).
+ */
+export const PROJECT_INIT_ORDER = [
+    "opentasks",
+    "minimem",
+    "cognitive-core",
+    "macro-agent",
+    "self-driving-repo",
+];
+/** Check whether a package is already initialized in a project */
+export function isProjectInit(cwd, pkg) {
+    const dir = PROJECT_CONFIG_DIRS[pkg];
+    return dir ? existsSync(join(cwd, dir)) : false;
+}
+/** Initialize a single project-level package */
+export async function initProjectPackage(pkg, ctx) {
+    switch (pkg) {
+        case "opentasks":
+            return shellInit("opentasks", ["init", "--name", getProjectName(ctx.cwd)], ctx.cwd);
+        case "minimem":
+            return initMinimem(ctx);
+        case "cognitive-core":
+            return shellInit("cognitive-core", ["init"], ctx.cwd);
+        case "macro-agent":
+            return initMacroAgent(ctx);
+        case "self-driving-repo":
+            return shellInit("sdr", ["init", "-t", "triage-only"], ctx.cwd);
+        default:
+            return { package: pkg, success: false, message: "Unknown package" };
+    }
+}
+// ─── Global-level setup ──────────────────────────────────────────────────────
+/** Config directories for global packages (relative to homedir) */
+export const GLOBAL_CONFIG_DIRS = {
+    "agent-iam": ".agent-credentials",
+    "skill-tree": ".skill-tree",
+    openswarm: ".openswarm",
+    openhive: ".openhive",
+};
+/** Check whether a global package is already configured */
+export function isGlobalInit(pkg) {
+    const dir = GLOBAL_CONFIG_DIRS[pkg];
+    if (!dir)
+        return false;
+    return existsSync(join(homedir(), dir));
+}
+/** Initialize a single global package */
+export async function initGlobalPackage(pkg, ctx, openhiveOpts) {
+    switch (pkg) {
+        case "agent-iam":
+            return initAgentIam(ctx);
+        case "skill-tree":
+            return initSkillTree();
+        case "openswarm":
+            return initOpenswarm(ctx);
+        case "openhive":
+            return openhiveOpts
+                ? initOpenhive(openhiveOpts)
+                : {
+                    package: "openhive",
+                    success: false,
+                    message: "No openhive options provided",
+                };
+        case "openteams":
+            return { package: "openteams", success: true, message: "no setup required" };
+        case "sessionlog":
+            return { package: "sessionlog", success: true, message: "no setup required" };
+        default:
+            return { package: pkg, success: false, message: "Unknown package" };
+    }
+}
+// ─── Package-specific init functions ─────────────────────────────────────────
+/** Build a clean env for child processes (strips test-runner vars like VITEST) */
+function cleanEnv() {
+    const env = { ...process.env };
+    delete env.VITEST;
+    delete env.VITEST_POOL_ID;
+    delete env.VITEST_WORKER_ID;
+    return env;
+}
+/** Shell out to a package's CLI init command */
+async function shellInit(command, args, cwd) {
+    const pkg = command === "sdr" ? "self-driving-repo" : command;
+    try {
+        await execFileAsync(command, args, { cwd, timeout: 30_000, env: cleanEnv() });
+        return { package: pkg, success: true };
+    }
+    catch (err) {
+        return { package: pkg, success: false, message: formatError(err) };
+    }
+}
+async function initMinimem(ctx) {
+    try {
+        await execFileAsync("minimem", ["init"], {
+            cwd: ctx.cwd,
+            timeout: 30_000,
+            env: cleanEnv(),
+        });
+        // Patch embedding provider if configured
+        if (ctx.embeddingProvider && ctx.embeddingProvider !== "local") {
+            const configPath = join(ctx.cwd, ".minimem", "config.json");
+            if (existsSync(configPath)) {
+                try {
+                    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+                    config.embedding = config.embedding || {};
+                    config.embedding.provider = ctx.embeddingProvider;
+                    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+                }
+                catch {
+                    // Non-fatal — user can configure manually
+                }
+            }
+        }
+        return { package: "minimem", success: true };
+    }
+    catch (err) {
+        return { package: "minimem", success: false, message: formatError(err) };
+    }
+}
+async function initMacroAgent(ctx) {
+    try {
+        const configDir = join(ctx.cwd, ".multiagent");
+        mkdirSync(configDir, { recursive: true });
+        const config = {
+            team: "default",
+            port: 3001,
+            host: "localhost",
+        };
+        // Wire up opentasks if selected
+        if (ctx.packages.includes("opentasks")) {
+            config.task = {
+                backend: "opentasks",
+                opentasks: { auto_start: true },
+            };
+        }
+        writeFileSync(join(configDir, "config.json"), JSON.stringify(config, null, 2) + "\n");
+        return { package: "macro-agent", success: true };
+    }
+    catch (err) {
+        return {
+            package: "macro-agent",
+            success: false,
+            message: formatError(err),
+        };
+    }
+}
+async function initAgentIam(ctx) {
+    try {
+        const credDir = join(homedir(), ".agent-credentials");
+        if (!existsSync(credDir)) {
+            mkdirSync(credDir, { recursive: true, mode: 0o700 });
+        }
+        // Register stored API keys with agent-iam
+        const env = { ...cleanEnv(), HOME: homedir() };
+        for (const [provider, key] of Object.entries(ctx.apiKeys)) {
+            if (["anthropic", "openai", "gemini"].includes(provider)) {
+                try {
+                    await execFileAsync("agent-iam", [
+                        "apikey",
+                        "add",
+                        "--name",
+                        provider,
+                        "--provider",
+                        provider,
+                        "--key",
+                        key,
+                    ], { timeout: 15_000, env });
+                }
+                catch {
+                    // Non-fatal — agent-iam CLI may not be fully installed yet
+                }
+            }
+        }
+        return { package: "agent-iam", success: true };
+    }
+    catch (err) {
+        return {
+            package: "agent-iam",
+            success: false,
+            message: formatError(err),
+        };
+    }
+}
+async function initSkillTree() {
+    const configPath = join(homedir(), ".skill-tree", "config.yaml");
+    if (existsSync(configPath)) {
+        return {
+            package: "skill-tree",
+            success: true,
+            message: "already configured",
+        };
+    }
+    try {
+        const env = { ...cleanEnv(), HOME: homedir() };
+        await execFileAsync("skill-tree", ["config", "init"], {
+            timeout: 15_000,
+            env,
+        });
+        return { package: "skill-tree", success: true };
+    }
+    catch (err) {
+        return {
+            package: "skill-tree",
+            success: false,
+            message: formatError(err),
+        };
+    }
+}
+async function initOpenswarm(ctx) {
+    const configDir = join(homedir(), ".openswarm");
+    const configPath = join(configDir, "server.json");
+    if (existsSync(configPath)) {
+        return {
+            package: "openswarm",
+            success: true,
+            message: "already configured",
+        };
+    }
+    try {
+        mkdirSync(configDir, { recursive: true });
+        const config = {
+            host: "localhost",
+            port: 3000,
+            auth: { mode: "none" },
+            storage: { type: "memory" },
+            logging: { level: "info" },
+        };
+        // Configure macro-agent adapter if installed
+        if (ctx.packages.includes("macro-agent")) {
+            config.adapter = { id: "macro-agent" };
+        }
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+        return { package: "openswarm", success: true };
+    }
+    catch (err) {
+        return {
+            package: "openswarm",
+            success: false,
+            message: formatError(err),
+        };
+    }
+}
+async function initOpenhive(opts) {
+    try {
+        const args = [
+            "init",
+            "--name",
+            opts.name,
+            "--port",
+            String(opts.port),
+            "--auth-mode",
+            opts.authMode,
+            "--verification",
+            opts.verification,
+        ];
+        if (opts.dataDir) {
+            args.unshift("--data-dir", opts.dataDir);
+        }
+        const env = { ...cleanEnv(), HOME: homedir() };
+        await execFileAsync("openhive", args, { timeout: 60_000, env });
+        return { package: "openhive", success: true };
+    }
+    catch (err) {
+        return {
+            package: "openhive",
+            success: false,
+            message: formatError(err),
+        };
+    }
+}
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function getProjectName(cwd) {
+    const pkgPath = join(cwd, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            if (typeof pkg.name === "string" && pkg.name)
+                return pkg.name;
+        }
+        catch {
+            // Fall through
+        }
+    }
+    return basename(cwd) || "project";
+}
+function formatError(err) {
+    if (err instanceof Error) {
+        return err.message.split("\n")[0];
+    }
+    return String(err);
+}

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

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