swarmkit 0.0.1 → 0.0.2

package/dist/doctor/checks.js

@@ -0,0 +1,210 @@
+import { join } from "node:path";
+import { PACKAGES, getActiveIntegrations } from "../packages/registry.js";
+/** Config directories each package creates at the project level */
+const PROJECT_CONFIG_DIRS = {
+    "macro-agent": ".multiagent",
+    opentasks: ".opentasks",
+    minimem: ".minimem",
+    "cognitive-core": ".cognitive-core",
+    "skill-tree": ".skilltree",
+    "self-driving-repo": ".self-driving",
+};
+/** 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.
+ */
+export function checkProjectConfigs(ctx) {
+    if (!ctx.isProject)
+        return [];
+    const results = [];
+    for (const pkg of ctx.installedPackages) {
+        const configDir = PROJECT_CONFIG_DIRS[pkg];
+        if (!configDir)
+            continue; // Package has no project-level config
+        if (PACKAGES[pkg]?.globalOnly)
+            continue;
+        const fullPath = join(ctx.cwd, configDir);
+        if (ctx.exists(fullPath)) {
+            results.push({
+                name: `${pkg}-config`,
+                status: "pass",
+                message: `${configDir}/`,
+            });
+        }
+        else {
+            results.push({
+                name: `${pkg}-config`,
+                status: "warn",
+                message: `${configDir}/ 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,276 @@
+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: ["macro-agent", "minimem"],
+            getInstalledVersion: async (pkg) => {
+                const versions = {
+                    "macro-agent": "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("macro-agent");
+        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: ["macro-agent", "minimem"],
+            getInstalledVersion: async (pkg) => pkg === "macro-agent" ? "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: ["macro-agent", "opentasks"],
+            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: ["macro-agent"],
+        });
+        const results = checkProjectConfigs(ctx);
+        expect(results).toEqual([]);
+    });
+    it("passes when config directory exists", () => {
+        const ctx = createContext({
+            isProject: true,
+            installedPackages: ["macro-agent"],
+            exists: (path) => path.endsWith(".multiagent"),
+        });
+        const results = checkProjectConfigs(ctx);
+        expect(results).toHaveLength(1);
+        expect(results[0].status).toBe("pass");
+        expect(results[0].message).toContain(".multiagent");
+    });
+    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(".opentasks");
+        expect(results[0].fix).toContain("opentasks init");
+    });
+    it("skips globalOnly packages", () => {
+        const ctx = createContext({
+            isProject: true,
+            installedPackages: ["agent-iam"],
+            exists: () => false,
+        });
+        const results = checkProjectConfigs(ctx);
+        expect(results).toEqual([]);
+    });
+    it("checks multiple packages", () => {
+        const existingDirs = new Set(["/tmp/test-project/.multiagent"]);
+        const ctx = createContext({
+            isProject: true,
+            cwd: "/tmp/test-project",
+            installedPackages: ["macro-agent", "opentasks", "minimem"],
+            exists: (path) => existingDirs.has(path),
+        });
+        const results = checkProjectConfigs(ctx);
+        expect(results).toHaveLength(3);
+        expect(results[0].status).toBe("pass"); // macro-agent
+        expect(results[1].status).toBe("warn"); // opentasks
+        expect(results[2].status).toBe("warn"); // minimem
+    });
+});
+describe("checkIntegrations", () => {
+    it("passes when both packages in an integration are installed", async () => {
+        const ctx = createContext({
+            installedPackages: ["macro-agent", "opentasks"],
+            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("macro-agent");
+        expect(results[0].message).toContain("opentasks");
+    });
+    it("fails when one package in an integration is missing from PATH", async () => {
+        const ctx = createContext({
+            installedPackages: ["macro-agent", "opentasks"],
+            getInstalledVersion: async (pkg) => pkg === "macro-agent" ? "0.1.0" : null,
+        });
+        const results = await checkIntegrations(ctx);
+        expect(results).toHaveLength(1);
+        expect(results[0].status).toBe("fail");
+        expect(results[0].fix).toContain("opentasks");
+    });
+    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: ["macro-agent", "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>;

package/dist/hub/auth-flow.js

@@ -0,0 +1,118 @@
+import { createServer } from "node:http";
+import { URL } from "node:url";
+import { exchangeAuthCode, getHubUrl } from "./client.js";
+import { writeCredentials } from "./credentials.js";
+const CALLBACK_PORT_START = 9876;
+const CALLBACK_PORT_END = 9886;
+const CALLBACK_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * 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 async function runLoginFlow(port) {
+    const { code, shutdown } = await waitForCallback(port);
+    try {
+        const token = await exchangeAuthCode(code);
+        const hubUrl = getHubUrl();
+        writeCredentials({ token, apiUrl: hubUrl });
+        return { token, apiUrl: hubUrl };
+    }
+    finally {
+        await shutdown();
+    }
+}
+/** Build the URL the user should open in their browser */
+export function getLoginUrl(callbackPort) {
+    const callbackUrl = `http://localhost:${callbackPort}/callback`;
+    const hubBase = getHubUrl();
+    return `${hubBase}/auth/cli?return_to=${encodeURIComponent(callbackUrl)}`;
+}
+/** Find an available port in our range */
+export async function findAvailablePort() {
+    for (let port = CALLBACK_PORT_START; port <= CALLBACK_PORT_END; port++) {
+        const available = await isPortAvailable(port);
+        if (available)
+            return port;
+    }
+    throw new Error(`No available port found in range ${CALLBACK_PORT_START}-${CALLBACK_PORT_END}`);
+}
+function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.once("error", () => resolve(false));
+        server.once("listening", () => {
+            server.close(() => resolve(true));
+        });
+        server.listen(port, "127.0.0.1");
+    });
+}
+/** Start a local server and wait for the OAuth callback with an auth code */
+function waitForCallback(port) {
+    return new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            if (!req.url?.startsWith("/callback")) {
+                res.writeHead(404);
+                res.end("Not found");
+                return;
+            }
+            const url = new URL(req.url, `http://localhost:${port}`);
+            const code = url.searchParams.get("code");
+            const error = url.searchParams.get("error");
+            if (error) {
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end(errorPage(error));
+                clearTimeout(timer);
+                reject(new Error(`Authentication failed: ${error}`));
+                return;
+            }
+            if (!code) {
+                res.writeHead(400, { "Content-Type": "text/html" });
+                res.end(errorPage("No authorization code received"));
+                return;
+            }
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(successPage());
+            clearTimeout(timer);
+            resolve({
+                code,
+                shutdown: () => new Promise((res) => server.close(() => res())),
+            });
+        });
+        server.listen(port, "127.0.0.1");
+        const timer = setTimeout(() => {
+            server.close();
+            reject(new Error("Login timed out — no callback received within 5 minutes"));
+        }, CALLBACK_TIMEOUT_MS);
+    });
+}
+function successPage() {
+    return `<!DOCTYPE html>
+<html>
+<head><title>swarmkit — logged in</title></head>
+<body style="font-family: system-ui, sans-serif; text-align: center; padding: 60px 20px;">
+  <h1>Logged in to SwarmHub</h1>
+  <p>You can close this window and return to your terminal.</p>
+</body>
+</html>`;
+}
+function errorPage(message) {
+    return `<!DOCTYPE html>
+<html>
+<head><title>swarmkit — login failed</title></head>
+<body style="font-family: system-ui, sans-serif; text-align: center; padding: 60px 20px;">
+  <h1>Login Failed</h1>
+  <p>${escapeHtml(message)}</p>
+  <p>Please close this window and try again.</p>
+</body>
+</html>`;
+}
+function escapeHtml(str) {
+    return str
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}

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

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