swarmkit 0.0.1 → 0.0.3

package/dist/doctor/checks.d.ts

@@ -0,0 +1,31 @@
+import type { CheckResult, CheckContext } from "./types.js";
+/**
+ * Verify each registered package is actually installed and in PATH.
+ */
+export declare function checkPackages(ctx: CheckContext): Promise<CheckResult[]>;
+/**
+ * Check that required API keys are available (stored or in env).
+ */
+export declare function checkCredentials(ctx: CheckContext): CheckResult[];
+/**
+ * Check that project-level config directories exist for installed packages.
+ * Only runs when cwd is a project directory. Checks both .swarm/ and flat layouts.
+ */
+export declare function checkProjectConfigs(ctx: CheckContext): CheckResult[];
+/**
+ * Check that active integrations have both packages installed.
+ * Reports on the state of known integration pairs.
+ */
+export declare function checkIntegrations(ctx: CheckContext): Promise<CheckResult[]>;
+/**
+ * Check that the global swarmkit config exists.
+ */
+export declare function checkGlobalConfig(ctx: CheckContext): CheckResult;
+export interface DoctorReport {
+    packages: CheckResult[];
+    credentials: CheckResult[];
+    projectConfigs: CheckResult[];
+    integrations: CheckResult[];
+    globalConfig: CheckResult;
+}
+export declare function runAllChecks(ctx: CheckContext): Promise<DoctorReport>;

package/dist/doctor/checks.js

@@ -0,0 +1,226 @@
+import { join } from "node:path";
+import { PACKAGES, getActiveIntegrations } from "../packages/registry.js";
+/** Config directories — prefixed layout (.swarm/) */
+const PREFIXED_CONFIG_DIRS = {
+    opentasks: ".swarm/opentasks",
+    minimem: ".swarm/minimem",
+    "cognitive-core": ".swarm/cognitive-core",
+    "skill-tree": ".swarm/skilltree",
+    "self-driving-repo": ".swarm/self-driving",
+    openteams: ".swarm/openteams",
+    sessionlog: ".swarm/sessionlog",
+    "claude-code-swarm": ".swarm/claude-swarm",
+};
+/** Config directories — flat layout (legacy / --no-prefix) */
+const FLAT_CONFIG_DIRS = {
+    opentasks: ".opentasks",
+    minimem: ".minimem",
+    "cognitive-core": ".cognitive-core",
+    "skill-tree": ".skilltree",
+    "self-driving-repo": ".self-driving",
+    openteams: ".openteams",
+    sessionlog: ".sessionlog",
+    "claude-code-swarm": ".claude-swarm",
+};
+/** Embedding provider → required key name */
+const EMBEDDING_KEY_MAP = {
+    openai: "openai",
+    gemini: "gemini",
+};
+/** Packages that need an embedding provider to work fully */
+const EMBEDDING_CONSUMERS = ["minimem", "cognitive-core", "skill-tree"];
+// ── Package checks ──────────────────────────────────────────────
+/**
+ * Verify each registered package is actually installed and in PATH.
+ */
+export async function checkPackages(ctx) {
+    const results = [];
+    for (const pkg of ctx.installedPackages) {
+        const version = await ctx.getInstalledVersion(pkg);
+        if (version) {
+            results.push({
+                name: pkg,
+                status: "pass",
+                message: `${pkg} ${version}`,
+            });
+        }
+        else {
+            results.push({
+                name: pkg,
+                status: "fail",
+                message: `${pkg} not found in PATH`,
+                fix: `swarmkit add ${pkg}`,
+            });
+        }
+    }
+    return results;
+}
+// ── Credential checks ───────────────────────────────────────────
+/**
+ * Check that required API keys are available (stored or in env).
+ */
+export function checkCredentials(ctx) {
+    const results = [];
+    // Anthropic key — needed for running agents
+    const hasAnthropicStored = ctx.storedKeys.includes("anthropic");
+    const hasAnthropicEnv = !!ctx.env["ANTHROPIC_API_KEY"];
+    if (hasAnthropicStored || hasAnthropicEnv) {
+        const source = hasAnthropicEnv ? "environment" : "stored";
+        results.push({
+            name: "anthropic-key",
+            status: "pass",
+            message: `Anthropic API key (${source})`,
+        });
+    }
+    else {
+        results.push({
+            name: "anthropic-key",
+            status: "warn",
+            message: "Anthropic API key not found — agents will not be able to run",
+            fix: "swarmkit init (or set ANTHROPIC_API_KEY)",
+        });
+    }
+    // Embedding key — needed if embedding provider is configured
+    const needsEmbeddings = ctx.installedPackages.some((p) => EMBEDDING_CONSUMERS.includes(p));
+    if (needsEmbeddings && ctx.embeddingProvider) {
+        const requiredKey = EMBEDDING_KEY_MAP[ctx.embeddingProvider];
+        if (ctx.embeddingProvider === "local") {
+            results.push({
+                name: "embedding-key",
+                status: "pass",
+                message: "Embeddings using local models (no key needed)",
+            });
+        }
+        else if (requiredKey) {
+            const hasKeyStored = ctx.storedKeys.includes(requiredKey);
+            const envVarName = requiredKey === "openai" ? "OPENAI_API_KEY" : "GEMINI_API_KEY";
+            const hasKeyEnv = !!ctx.env[envVarName];
+            if (hasKeyStored || hasKeyEnv) {
+                const source = hasKeyEnv ? "environment" : "stored";
+                results.push({
+                    name: "embedding-key",
+                    status: "pass",
+                    message: `${ctx.embeddingProvider} embedding key (${source})`,
+                });
+            }
+            else {
+                results.push({
+                    name: "embedding-key",
+                    status: "warn",
+                    message: `${ctx.embeddingProvider} API key not found — embeddings will fall back to BM25-only`,
+                    fix: "swarmkit init (or set " + envVarName + ")",
+                });
+            }
+        }
+    }
+    else if (needsEmbeddings && !ctx.embeddingProvider) {
+        results.push({
+            name: "embedding-provider",
+            status: "warn",
+            message: "No embedding provider configured — semantic search disabled",
+            fix: "swarmkit init",
+        });
+    }
+    return results;
+}
+// ── Project config checks ───────────────────────────────────────
+/**
+ * Check that project-level config directories exist for installed packages.
+ * Only runs when cwd is a project directory. Checks both .swarm/ and flat layouts.
+ */
+export function checkProjectConfigs(ctx) {
+    if (!ctx.isProject)
+        return [];
+    const results = [];
+    for (const pkg of ctx.installedPackages) {
+        const prefixedDir = PREFIXED_CONFIG_DIRS[pkg];
+        const flatDir = FLAT_CONFIG_DIRS[pkg];
+        if (!prefixedDir)
+            continue; // Package has no project-level config
+        if (PACKAGES[pkg]?.globalOnly)
+            continue;
+        const hasPrefixed = ctx.exists(join(ctx.cwd, prefixedDir));
+        const hasFlat = flatDir ? ctx.exists(join(ctx.cwd, flatDir)) : false;
+        if (hasPrefixed || hasFlat) {
+            const found = hasPrefixed ? prefixedDir : flatDir;
+            results.push({
+                name: `${pkg}-config`,
+                status: "pass",
+                message: `${found}/`,
+            });
+        }
+        else {
+            results.push({
+                name: `${pkg}-config`,
+                status: "warn",
+                message: `${prefixedDir}/ not found`,
+                fix: `swarmkit init (or ${pkg} init)`,
+            });
+        }
+    }
+    return results;
+}
+// ── Integration checks ──────────────────────────────────────────
+/**
+ * Check that active integrations have both packages installed.
+ * Reports on the state of known integration pairs.
+ */
+export async function checkIntegrations(ctx) {
+    const integrations = getActiveIntegrations(ctx.installedPackages);
+    const results = [];
+    for (const integration of integrations) {
+        const [a, b] = integration.packages;
+        const versionA = await ctx.getInstalledVersion(a);
+        const versionB = await ctx.getInstalledVersion(b);
+        if (versionA && versionB) {
+            results.push({
+                name: `${a}+${b}`,
+                status: "pass",
+                message: `${a} ↔ ${b}`,
+            });
+        }
+        else {
+            const missing = !versionA ? a : b;
+            results.push({
+                name: `${a}+${b}`,
+                status: "fail",
+                message: `${a} ↔ ${b} — ${missing} not found`,
+                fix: `swarmkit add ${missing}`,
+            });
+        }
+    }
+    return results;
+}
+// ── Global config check ─────────────────────────────────────────
+/**
+ * Check that the global swarmkit config exists.
+ */
+export function checkGlobalConfig(ctx) {
+    const configPath = join(ctx.env["HOME"] ?? "", ".swarmkit", "config.json");
+    if (ctx.exists(configPath)) {
+        return {
+            name: "global-config",
+            status: "pass",
+            message: "~/.swarmkit/config.json",
+        };
+    }
+    return {
+        name: "global-config",
+        status: "fail",
+        message: "~/.swarmkit/config.json not found",
+        fix: "swarmkit init",
+    };
+}
+export async function runAllChecks(ctx) {
+    const [packages, integrations] = await Promise.all([
+        checkPackages(ctx),
+        checkIntegrations(ctx),
+    ]);
+    return {
+        packages,
+        credentials: checkCredentials(ctx),
+        projectConfigs: checkProjectConfigs(ctx),
+        integrations,
+        globalConfig: checkGlobalConfig(ctx),
+    };
+}

package/dist/doctor/checks.test.d.ts

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

package/dist/doctor/checks.test.js

@@ -0,0 +1,301 @@
+import { describe, it, expect } from "vitest";
+import { checkPackages, checkCredentials, checkProjectConfigs, checkIntegrations, checkGlobalConfig, runAllChecks, } from "./checks.js";
+function createContext(overrides = {}) {
+    return {
+        installedPackages: [],
+        embeddingProvider: undefined,
+        storedKeys: [],
+        cwd: "/tmp/test-project",
+        isProject: false,
+        getInstalledVersion: async () => null,
+        exists: () => false,
+        env: {},
+        ...overrides,
+    };
+}
+describe("checkPackages", () => {
+    it("passes when all packages are installed", async () => {
+        const ctx = createContext({
+            installedPackages: ["opentasks", "minimem"],
+            getInstalledVersion: async (pkg) => {
+                const versions = {
+                    opentasks: "0.1.0",
+                    minimem: "0.2.0",
+                };
+                return versions[pkg] ?? null;
+            },
+        });
+        const results = await checkPackages(ctx);
+        expect(results).toHaveLength(2);
+        expect(results[0].status).toBe("pass");
+        expect(results[0].message).toContain("opentasks");
+        expect(results[0].message).toContain("0.1.0");
+        expect(results[1].status).toBe("pass");
+    });
+    it("fails when a package is not found", async () => {
+        const ctx = createContext({
+            installedPackages: ["opentasks", "minimem"],
+            getInstalledVersion: async (pkg) => pkg === "opentasks" ? "0.1.0" : null,
+        });
+        const results = await checkPackages(ctx);
+        expect(results[0].status).toBe("pass");
+        expect(results[1].status).toBe("fail");
+        expect(results[1].message).toContain("not found");
+        expect(results[1].fix).toBe("swarmkit add minimem");
+    });
+    it("returns empty for no packages", async () => {
+        const ctx = createContext();
+        const results = await checkPackages(ctx);
+        expect(results).toEqual([]);
+    });
+});
+describe("checkCredentials", () => {
+    it("passes when anthropic key is stored", () => {
+        const ctx = createContext({ storedKeys: ["anthropic"] });
+        const results = checkCredentials(ctx);
+        const anthropic = results.find((r) => r.name === "anthropic-key");
+        expect(anthropic?.status).toBe("pass");
+        expect(anthropic?.message).toContain("stored");
+    });
+    it("passes when anthropic key is in env", () => {
+        const ctx = createContext({ env: { ANTHROPIC_API_KEY: "sk-ant-test" } });
+        const results = checkCredentials(ctx);
+        const anthropic = results.find((r) => r.name === "anthropic-key");
+        expect(anthropic?.status).toBe("pass");
+        expect(anthropic?.message).toContain("environment");
+    });
+    it("warns when anthropic key is missing", () => {
+        const ctx = createContext();
+        const results = checkCredentials(ctx);
+        const anthropic = results.find((r) => r.name === "anthropic-key");
+        expect(anthropic?.status).toBe("warn");
+        expect(anthropic?.fix).toBeTruthy();
+    });
+    it("checks embedding key when provider is openai and consumers installed", () => {
+        const ctx = createContext({
+            installedPackages: ["minimem"],
+            embeddingProvider: "openai",
+            storedKeys: ["openai"],
+        });
+        const results = checkCredentials(ctx);
+        const embedding = results.find((r) => r.name === "embedding-key");
+        expect(embedding?.status).toBe("pass");
+    });
+    it("warns when embedding key is missing for configured provider", () => {
+        const ctx = createContext({
+            installedPackages: ["minimem"],
+            embeddingProvider: "openai",
+            storedKeys: [],
+        });
+        const results = checkCredentials(ctx);
+        const embedding = results.find((r) => r.name === "embedding-key");
+        expect(embedding?.status).toBe("warn");
+        expect(embedding?.message).toContain("BM25-only");
+    });
+    it("passes embedding key from env", () => {
+        const ctx = createContext({
+            installedPackages: ["minimem"],
+            embeddingProvider: "openai",
+            env: { OPENAI_API_KEY: "sk-test" },
+        });
+        const results = checkCredentials(ctx);
+        const embedding = results.find((r) => r.name === "embedding-key");
+        expect(embedding?.status).toBe("pass");
+        expect(embedding?.message).toContain("environment");
+    });
+    it("passes for local embedding provider (no key needed)", () => {
+        const ctx = createContext({
+            installedPackages: ["minimem"],
+            embeddingProvider: "local",
+        });
+        const results = checkCredentials(ctx);
+        const embedding = results.find((r) => r.name === "embedding-key");
+        expect(embedding?.status).toBe("pass");
+        expect(embedding?.message).toContain("local");
+    });
+    it("warns when embedding consumers installed but no provider configured", () => {
+        const ctx = createContext({
+            installedPackages: ["cognitive-core"],
+            embeddingProvider: undefined,
+        });
+        const results = checkCredentials(ctx);
+        const embedding = results.find((r) => r.name === "embedding-provider");
+        expect(embedding?.status).toBe("warn");
+    });
+    it("skips embedding check when no embedding consumers installed", () => {
+        const ctx = createContext({
+            installedPackages: ["opentasks", "self-driving-repo"],
+            embeddingProvider: undefined,
+        });
+        const results = checkCredentials(ctx);
+        const embedding = results.find((r) => r.name === "embedding-key" || r.name === "embedding-provider");
+        expect(embedding).toBeUndefined();
+    });
+    it("checks gemini key via GEMINI_API_KEY env var", () => {
+        const ctx = createContext({
+            installedPackages: ["minimem"],
+            embeddingProvider: "gemini",
+            env: { GEMINI_API_KEY: "test-key" },
+        });
+        const results = checkCredentials(ctx);
+        const embedding = results.find((r) => r.name === "embedding-key");
+        expect(embedding?.status).toBe("pass");
+    });
+});
+describe("checkProjectConfigs", () => {
+    it("returns empty when not in a project", () => {
+        const ctx = createContext({
+            isProject: false,
+            installedPackages: ["opentasks"],
+        });
+        const results = checkProjectConfigs(ctx);
+        expect(results).toEqual([]);
+    });
+    it("passes when prefixed config directory exists", () => {
+        const ctx = createContext({
+            isProject: true,
+            installedPackages: ["opentasks"],
+            exists: (path) => path.endsWith(".swarm/opentasks"),
+        });
+        const results = checkProjectConfigs(ctx);
+        expect(results).toHaveLength(1);
+        expect(results[0].status).toBe("pass");
+        expect(results[0].message).toContain(".swarm/opentasks");
+    });
+    it("passes when flat config directory exists", () => {
+        const ctx = createContext({
+            isProject: true,
+            installedPackages: ["opentasks"],
+            exists: (path) => path.endsWith(".opentasks"),
+        });
+        const results = checkProjectConfigs(ctx);
+        expect(results).toHaveLength(1);
+        expect(results[0].status).toBe("pass");
+        expect(results[0].message).toContain(".opentasks");
+    });
+    it("warns when config directory is missing", () => {
+        const ctx = createContext({
+            isProject: true,
+            installedPackages: ["opentasks"],
+            exists: () => false,
+        });
+        const results = checkProjectConfigs(ctx);
+        expect(results).toHaveLength(1);
+        expect(results[0].status).toBe("warn");
+        expect(results[0].message).toContain(".swarm/opentasks");
+        expect(results[0].fix).toContain("opentasks init");
+    });
+    it("passes for claude-code-swarm with prefixed config", () => {
+        const ctx = createContext({
+            isProject: true,
+            installedPackages: ["claude-code-swarm"],
+            exists: (path) => path.endsWith(".swarm/claude-swarm"),
+        });
+        const results = checkProjectConfigs(ctx);
+        expect(results).toHaveLength(1);
+        expect(results[0].status).toBe("pass");
+        expect(results[0].message).toContain(".swarm/claude-swarm");
+    });
+    it("skips packages without project config dirs", () => {
+        const ctx = createContext({
+            isProject: true,
+            installedPackages: ["multi-agent-protocol"],
+            exists: () => false,
+        });
+        const results = checkProjectConfigs(ctx);
+        expect(results).toEqual([]);
+    });
+    it("checks multiple packages (mixed layouts)", () => {
+        const existingDirs = new Set([
+            "/tmp/test-project/.swarm/opentasks",
+            "/tmp/test-project/.minimem",
+        ]);
+        const ctx = createContext({
+            isProject: true,
+            cwd: "/tmp/test-project",
+            installedPackages: ["opentasks", "minimem", "cognitive-core"],
+            exists: (path) => existingDirs.has(path),
+        });
+        const results = checkProjectConfigs(ctx);
+        expect(results).toHaveLength(3);
+        expect(results[0].status).toBe("pass"); // opentasks (prefixed)
+        expect(results[1].status).toBe("pass"); // minimem (flat)
+        expect(results[2].status).toBe("warn"); // cognitive-core (missing)
+    });
+});
+describe("checkIntegrations", () => {
+    it("passes when both packages in an integration are installed", async () => {
+        const ctx = createContext({
+            installedPackages: ["cognitive-core", "minimem"],
+            getInstalledVersion: async () => "0.1.0",
+        });
+        const results = await checkIntegrations(ctx);
+        expect(results).toHaveLength(1);
+        expect(results[0].status).toBe("pass");
+        expect(results[0].message).toContain("cognitive-core");
+        expect(results[0].message).toContain("minimem");
+    });
+    it("fails when one package in an integration is missing from PATH", async () => {
+        const ctx = createContext({
+            installedPackages: ["cognitive-core", "minimem"],
+            getInstalledVersion: async (pkg) => pkg === "cognitive-core" ? "0.1.0" : null,
+        });
+        const results = await checkIntegrations(ctx);
+        expect(results).toHaveLength(1);
+        expect(results[0].status).toBe("fail");
+        expect(results[0].fix).toContain("minimem");
+    });
+    it("returns empty when no integrations are active", async () => {
+        const ctx = createContext({
+            installedPackages: ["minimem"],
+            getInstalledVersion: async () => "0.1.0",
+        });
+        const results = await checkIntegrations(ctx);
+        expect(results).toEqual([]);
+    });
+});
+describe("checkGlobalConfig", () => {
+    it("passes when config file exists", () => {
+        const ctx = createContext({
+            env: { HOME: "/home/testuser" },
+            exists: (path) => path === "/home/testuser/.swarmkit/config.json",
+        });
+        const result = checkGlobalConfig(ctx);
+        expect(result.status).toBe("pass");
+    });
+    it("fails when config file is missing", () => {
+        const ctx = createContext({
+            env: { HOME: "/home/testuser" },
+            exists: () => false,
+        });
+        const result = checkGlobalConfig(ctx);
+        expect(result.status).toBe("fail");
+        expect(result.fix).toBe("swarmkit init");
+    });
+});
+describe("runAllChecks", () => {
+    it("returns a complete report", async () => {
+        const ctx = createContext({
+            installedPackages: ["opentasks", "minimem"],
+            embeddingProvider: "openai",
+            storedKeys: ["anthropic", "openai"],
+            isProject: true,
+            env: { HOME: "/home/testuser" },
+            getInstalledVersion: async () => "0.1.0",
+            exists: () => true,
+        });
+        const report = await runAllChecks(ctx);
+        expect(report.packages).toHaveLength(2);
+        expect(report.credentials.length).toBeGreaterThan(0);
+        expect(report.projectConfigs.length).toBeGreaterThan(0);
+        expect(report.globalConfig).toBeDefined();
+        expect(report.globalConfig.status).toBe("pass");
+    });
+    it("returns empty sections when no packages installed", async () => {
+        const ctx = createContext({ env: { HOME: "/tmp" } });
+        const report = await runAllChecks(ctx);
+        expect(report.packages).toEqual([]);
+        expect(report.integrations).toEqual([]);
+        expect(report.projectConfigs).toEqual([]);
+    });
+});

package/dist/doctor/types.d.ts

@@ -0,0 +1,29 @@
+export type CheckStatus = "pass" | "fail" | "warn";
+export interface CheckResult {
+    /** What was checked */
+    name: string;
+    /** Pass, fail, or warning */
+    status: CheckStatus;
+    /** Human-readable description of the result */
+    message: string;
+    /** Suggested fix command, if applicable */
+    fix?: string;
+}
+export interface CheckContext {
+    /** Packages registered in swarmkit config */
+    installedPackages: string[];
+    /** Embedding provider from config */
+    embeddingProvider?: string;
+    /** API key providers that have stored keys */
+    storedKeys: string[];
+    /** Current working directory */
+    cwd: string;
+    /** Whether cwd looks like a project (has .git or package.json) */
+    isProject: boolean;
+    /** Resolve installed version — injectable for testing */
+    getInstalledVersion: (pkg: string) => Promise<string | null>;
+    /** Check if a file/directory exists — injectable for testing */
+    exists: (path: string) => boolean;
+    /** Environment variables */
+    env: Record<string, string | undefined>;
+}

package/dist/doctor/types.js

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

package/dist/hub/auth-flow.d.ts

@@ -0,0 +1,16 @@
+export interface LoginResult {
+    token: string;
+    apiUrl: string;
+}
+/**
+ * Run the login flow on a given port:
+ * 1. Start a local HTTP server to receive the OAuth callback
+ * 2. Wait for the auth code callback
+ * 3. Exchange the code for a JWT
+ * 4. Store credentials locally
+ */
+export declare function runLoginFlow(port: number): Promise<LoginResult>;
+/** Build the URL the user should open in their browser */
+export declare function getLoginUrl(callbackPort: number): string;
+/** Find an available port in our range */
+export declare function findAvailablePort(): Promise<number>;