swarmkit 0.0.1 → 0.0.3

package/dist/commands/remove.js

@@ -0,0 +1,55 @@
+import chalk from "chalk";
+import { readConfig, removeInstalledPackage } from "../config/global.js";
+import { getLostIntegrations } from "../packages/registry.js";
+import { uninstallPackage, getInstalledVersion } from "../packages/installer.js";
+import { isInstalledPlugin } from "../packages/plugin.js";
+import * as ui from "../utils/ui.js";
+export function registerRemoveCommand(program) {
+    program
+        .command("remove <package>")
+        .description("Uninstall a swarmkit package (preserves project data)")
+        .action(async (packageName) => {
+        const config = readConfig();
+        // Check if tracked by swarmkit
+        if (!config.installedPackages.includes(packageName)) {
+            ui.fail(`${packageName} is not in the swarmkit package list.`);
+            ui.info("Run `swarmkit status` to see installed packages.");
+            process.exitCode = 1;
+            return;
+        }
+        // Show what will break
+        const lostIntegrations = getLostIntegrations(config.installedPackages, packageName);
+        if (lostIntegrations.length > 0) {
+            console.log();
+            console.log(`  ${chalk.bold("Affected integrations:")}`);
+            for (const integration of lostIntegrations) {
+                const other = integration.packages.find((p) => p !== packageName);
+                ui.warn(`${other} — ${integration.description}`);
+            }
+            console.log();
+        }
+        // Check if it's a plugin before uninstalling (while we can still resolve the path)
+        const wasPlugin = await isInstalledPlugin(packageName);
+        // Uninstall
+        console.log(`  Uninstalling ${chalk.bold(packageName)}...`);
+        const version = await getInstalledVersion(packageName);
+        try {
+            await uninstallPackage(packageName);
+            ui.success(`${packageName}${version ? " v" + version : ""} uninstalled`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ui.fail(`Failed to uninstall: ${msg}`);
+            process.exitCode = 1;
+            return;
+        }
+        // Update registry
+        removeInstalledPackage(packageName);
+        ui.blank();
+        ui.info("Project data directories are preserved. Delete them manually if no longer needed.");
+        if (wasPlugin) {
+            ui.info(`If activated as a Claude Code plugin, also run: claude plugin uninstall ${packageName}`);
+        }
+        ui.blank();
+    });
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerStatusCommand(program: Command): void;

package/dist/commands/status.js

@@ -0,0 +1,87 @@
+import chalk from "chalk";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { join, dirname } from "node:path";
+import { readConfig } from "../config/global.js";
+import { listKeys } from "../config/keys.js";
+import { PACKAGES, getActiveIntegrations } from "../packages/registry.js";
+import { getInstalledVersion } from "../packages/installer.js";
+import * as ui from "../utils/ui.js";
+export function registerStatusCommand(program) {
+    program
+        .command("status")
+        .description("Show installed packages and configuration")
+        .action(async () => {
+        const config = readConfig();
+        const { installedPackages } = config;
+        console.log();
+        console.log(`  ${chalk.bold("swarmkit")} ${chalk.dim("v" + getVersion())}`);
+        // Packages
+        if (installedPackages.length === 0) {
+            ui.blank();
+            ui.info("No packages installed. Run `swarmkit init` to get started.");
+            ui.blank();
+            return;
+        }
+        ui.heading("  Packages:");
+        const rows = [];
+        for (const pkg of installedPackages) {
+            const version = await getInstalledVersion(pkg);
+            const def = PACKAGES[pkg];
+            if (version) {
+                rows.push([
+                    pkg,
+                    chalk.dim(version),
+                    chalk.green("installed"),
+                    chalk.dim(def?.description ?? ""),
+                ]);
+            }
+            else {
+                rows.push([
+                    pkg,
+                    chalk.dim("—"),
+                    chalk.red("not found"),
+                    chalk.dim(def?.description ?? ""),
+                ]);
+            }
+        }
+        ui.table(rows);
+        // Integrations
+        const integrations = getActiveIntegrations(installedPackages);
+        if (integrations.length > 0) {
+            ui.heading("  Integrations:");
+            for (const integration of integrations) {
+                const [a, b] = integration.packages;
+                ui.bullet(`  ${a} ${chalk.dim("↔")} ${b}  ${chalk.dim(integration.description)}`);
+            }
+        }
+        // Embeddings
+        if (config.embeddingProvider) {
+            ui.heading("  Embeddings:");
+            const model = config.embeddingModel ?? "default";
+            ui.bullet(`  ${config.embeddingProvider} (${model})`);
+        }
+        // API Keys
+        const keys = listKeys();
+        if (keys.length > 0) {
+            ui.heading("  API Keys:");
+            const keyRows = [];
+            for (const key of keys) {
+                keyRows.push([key, chalk.green("set")]);
+            }
+            ui.table(keyRows);
+        }
+        ui.blank();
+    });
+}
+function getVersion() {
+    try {
+        const __dirname = dirname(fileURLToPath(import.meta.url));
+        const pkgPath = join(__dirname, "..", "..", "package.json");
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        return pkg.version;
+    }
+    catch {
+        return "0.0.1";
+    }
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerUpdateCommand(program: Command): void;

package/dist/commands/update.js

@@ -0,0 +1,54 @@
+import chalk from "chalk";
+import { readConfig } from "../config/global.js";
+import { updatePackages } from "../packages/installer.js";
+import * as ui from "../utils/ui.js";
+export function registerUpdateCommand(program) {
+    program
+        .command("update")
+        .description("Update all installed packages to latest versions")
+        .action(async () => {
+        const config = readConfig();
+        const { installedPackages } = config;
+        if (installedPackages.length === 0) {
+            ui.info("No packages installed. Run `swarmkit init` to get started.");
+            return;
+        }
+        console.log();
+        console.log(`  Checking for updates...`);
+        console.log();
+        const results = await updatePackages(installedPackages);
+        const rows = [];
+        let updatedCount = 0;
+        for (const result of results) {
+            if (result.error) {
+                rows.push([result.package, chalk.red("error"), chalk.dim(result.error)]);
+            }
+            else if (result.updated) {
+                updatedCount++;
+                rows.push([
+                    result.package,
+                    chalk.dim(result.previousVersion ?? "?") +
+                        " → " +
+                        chalk.green(result.newVersion ?? "?"),
+                    chalk.green("updated"),
+                ]);
+            }
+            else {
+                rows.push([
+                    result.package,
+                    chalk.dim(result.previousVersion ?? "?"),
+                    chalk.dim("up to date"),
+                ]);
+            }
+        }
+        ui.table(rows);
+        ui.blank();
+        if (updatedCount > 0) {
+            ui.info(`${updatedCount} package${updatedCount === 1 ? "" : "s"} updated.`);
+        }
+        else {
+            ui.info("All packages are up to date.");
+        }
+        ui.blank();
+    });
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerWhoamiCommand(program: Command): void;

package/dist/commands/whoami.js

@@ -0,0 +1,40 @@
+import chalk from "chalk";
+import { isLoggedIn } from "../hub/credentials.js";
+import { getMe, getHubUrl, HubApiError } from "../hub/client.js";
+import * as ui from "../utils/ui.js";
+export function registerWhoamiCommand(program) {
+    program
+        .command("whoami")
+        .description("Show the currently authenticated SwarmHub user")
+        .action(async () => {
+        if (!isLoggedIn()) {
+            ui.blank();
+            ui.info("Not logged in. Run `swarmkit login` to authenticate.");
+            ui.blank();
+            return;
+        }
+        try {
+            const user = await getMe();
+            ui.blank();
+            ui.table([
+                [chalk.dim("User"), chalk.bold(user.name)],
+                [chalk.dim("Email"), user.email],
+                [chalk.dim("Hub"), getHubUrl()],
+            ]);
+            ui.blank();
+        }
+        catch (err) {
+            ui.blank();
+            if (err instanceof HubApiError && err.statusCode === 401) {
+                ui.fail("Session expired. Run `swarmkit login` to re-authenticate.");
+            }
+            else if (err instanceof HubApiError) {
+                ui.fail(`SwarmHub error: ${err.message}`);
+            }
+            else {
+                ui.fail("Could not reach SwarmHub.");
+            }
+            ui.blank();
+        }
+    });
+}

package/dist/config/global.d.ts

@@ -0,0 +1,26 @@
+export interface GlobalConfig {
+    /** Packages installed by swarmkit */
+    installedPackages: string[];
+    /** Embedding provider preference */
+    embeddingProvider?: "openai" | "gemini" | "local";
+    /** Embedding model (provider-specific) */
+    embeddingModel?: string;
+    /** Whether project configs are nested under .swarm/ (default true) */
+    usePrefix?: boolean;
+}
+/** Get the swarmkit config directory path (~/.swarmkit/) */
+export declare function getConfigDir(): string;
+/** Get the config file path (~/.swarmkit/config.json) */
+export declare function getConfigPath(): string;
+/** Ensure the config directory exists with correct permissions */
+export declare function ensureConfigDir(): void;
+/** Check if this is the first time running swarmkit */
+export declare function isFirstRun(): boolean;
+/** Read the global config, returning defaults if it doesn't exist */
+export declare function readConfig(): GlobalConfig;
+/** Write the global config */
+export declare function writeConfig(config: GlobalConfig): void;
+/** Add packages to the installed list (deduplicates) */
+export declare function addInstalledPackages(packages: string[]): void;
+/** Remove a package from the installed list */
+export declare function removeInstalledPackage(packageName: string): void;

package/dist/config/global.js

@@ -0,0 +1,71 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const DEFAULT_CONFIG = {
+    installedPackages: [],
+};
+/** Get the swarmkit config directory path (~/.swarmkit/) */
+export function getConfigDir() {
+    return join(homedir(), ".swarmkit");
+}
+/** Get the config file path (~/.swarmkit/config.json) */
+export function getConfigPath() {
+    return join(getConfigDir(), "config.json");
+}
+/** Ensure the config directory exists with correct permissions */
+export function ensureConfigDir() {
+    const dir = getConfigDir();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    const keysDir = join(dir, "keys");
+    if (!existsSync(keysDir)) {
+        mkdirSync(keysDir, { recursive: true, mode: 0o700 });
+    }
+}
+/** Check if this is the first time running swarmkit */
+export function isFirstRun() {
+    return !existsSync(getConfigPath());
+}
+/** Read the global config, returning defaults if it doesn't exist */
+export function readConfig() {
+    const path = getConfigPath();
+    if (!existsSync(path)) {
+        return { ...DEFAULT_CONFIG };
+    }
+    try {
+        const raw = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        return {
+            ...DEFAULT_CONFIG,
+            ...parsed,
+        };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+/** Write the global config */
+export function writeConfig(config) {
+    ensureConfigDir();
+    const path = getConfigPath();
+    writeFileSync(path, JSON.stringify(config, null, 2) + "\n", {
+        mode: 0o600,
+    });
+}
+/** Add packages to the installed list (deduplicates) */
+export function addInstalledPackages(packages) {
+    const config = readConfig();
+    const existing = new Set(config.installedPackages);
+    for (const pkg of packages) {
+        existing.add(pkg);
+    }
+    config.installedPackages = [...existing].sort();
+    writeConfig(config);
+}
+/** Remove a package from the installed list */
+export function removeInstalledPackage(packageName) {
+    const config = readConfig();
+    config.installedPackages = config.installedPackages.filter((p) => p !== packageName);
+    writeConfig(config);
+}

package/dist/config/global.test.d.ts

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

package/dist/config/global.test.js

@@ -0,0 +1,167 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { mkdtempSync, rmSync, existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+// Mock os.homedir to use a temp directory
+let tempHome;
+vi.mock("node:os", async () => {
+    const actual = await vi.importActual("node:os");
+    return {
+        ...actual,
+        homedir: () => tempHome,
+    };
+});
+// Import after mock is set up
+const { getConfigDir, getConfigPath, ensureConfigDir, isFirstRun, readConfig, writeConfig, addInstalledPackages, removeInstalledPackage, } = await import("./global.js");
+describe("config/global", () => {
+    beforeEach(() => {
+        tempHome = mkdtempSync(join(tmpdir(), "swarmkit-test-"));
+    });
+    afterEach(() => {
+        rmSync(tempHome, { recursive: true, force: true });
+    });
+    describe("getConfigDir", () => {
+        it("returns ~/.swarmkit", () => {
+            expect(getConfigDir()).toBe(join(tempHome, ".swarmkit"));
+        });
+    });
+    describe("getConfigPath", () => {
+        it("returns ~/.swarmkit/config.json", () => {
+            expect(getConfigPath()).toBe(join(tempHome, ".swarmkit", "config.json"));
+        });
+    });
+    describe("ensureConfigDir", () => {
+        it("creates the config directory if it does not exist", () => {
+            ensureConfigDir();
+            expect(existsSync(join(tempHome, ".swarmkit"))).toBe(true);
+        });
+        it("creates the keys subdirectory", () => {
+            ensureConfigDir();
+            expect(existsSync(join(tempHome, ".swarmkit", "keys"))).toBe(true);
+        });
+        it("sets directory permissions to 0700", () => {
+            ensureConfigDir();
+            const stats = statSync(join(tempHome, ".swarmkit"));
+            expect(stats.mode & 0o777).toBe(0o700);
+        });
+        it("is idempotent", () => {
+            ensureConfigDir();
+            ensureConfigDir();
+            expect(existsSync(join(tempHome, ".swarmkit"))).toBe(true);
+        });
+    });
+    describe("isFirstRun", () => {
+        it("returns true when config does not exist", () => {
+            expect(isFirstRun()).toBe(true);
+        });
+        it("returns false after writing config", () => {
+            writeConfig({ installedPackages: [] });
+            expect(isFirstRun()).toBe(false);
+        });
+    });
+    describe("readConfig", () => {
+        it("returns defaults when no config exists", () => {
+            const config = readConfig();
+            expect(config.installedPackages).toEqual([]);
+            expect(config.embeddingProvider).toBeUndefined();
+        });
+        it("reads written config", () => {
+            writeConfig({
+                installedPackages: ["opentasks"],
+                embeddingProvider: "openai",
+                embeddingModel: "text-embedding-3-small",
+            });
+            const config = readConfig();
+            expect(config.installedPackages).toEqual(["opentasks"]);
+            expect(config.embeddingProvider).toBe("openai");
+            expect(config.embeddingModel).toBe("text-embedding-3-small");
+        });
+        it("returns defaults for corrupt config file", async () => {
+            ensureConfigDir();
+            const { writeFileSync } = await import("node:fs");
+            writeFileSync(getConfigPath(), "not json");
+            const config = readConfig();
+            expect(config.installedPackages).toEqual([]);
+        });
+        it("merges partial config with defaults", async () => {
+            ensureConfigDir();
+            const { writeFileSync } = await import("node:fs");
+            writeFileSync(getConfigPath(), JSON.stringify({ embeddingProvider: "gemini" }));
+            const config = readConfig();
+            expect(config.installedPackages).toEqual([]);
+            expect(config.embeddingProvider).toBe("gemini");
+        });
+    });
+    describe("writeConfig", () => {
+        it("creates the config directory if needed", () => {
+            writeConfig({ installedPackages: [] });
+            expect(existsSync(join(tempHome, ".swarmkit"))).toBe(true);
+        });
+        it("writes valid JSON", () => {
+            writeConfig({ installedPackages: ["minimem"] });
+            const raw = readFileSync(getConfigPath(), "utf-8");
+            const parsed = JSON.parse(raw);
+            expect(parsed.installedPackages).toEqual(["minimem"]);
+        });
+        it("sets file permissions to 0600", () => {
+            writeConfig({ installedPackages: [] });
+            const stats = statSync(getConfigPath());
+            expect(stats.mode & 0o777).toBe(0o600);
+        });
+    });
+    describe("addInstalledPackages", () => {
+        it("adds packages to an empty list", () => {
+            writeConfig({ installedPackages: [] });
+            addInstalledPackages(["opentasks", "minimem"]);
+            const config = readConfig();
+            expect(config.installedPackages).toEqual(["minimem", "opentasks"]);
+        });
+        it("deduplicates packages", () => {
+            writeConfig({ installedPackages: ["opentasks"] });
+            addInstalledPackages(["opentasks", "minimem"]);
+            const config = readConfig();
+            expect(config.installedPackages).toEqual(["minimem", "opentasks"]);
+        });
+        it("sorts packages alphabetically", () => {
+            addInstalledPackages(["minimem", "cognitive-core", "opentasks"]);
+            const config = readConfig();
+            expect(config.installedPackages).toEqual([
+                "cognitive-core",
+                "minimem",
+                "opentasks",
+            ]);
+        });
+        it("preserves other config fields", () => {
+            writeConfig({
+                installedPackages: [],
+                embeddingProvider: "openai",
+            });
+            addInstalledPackages(["minimem"]);
+            const config = readConfig();
+            expect(config.embeddingProvider).toBe("openai");
+        });
+    });
+    describe("removeInstalledPackage", () => {
+        it("removes a package from the list", () => {
+            writeConfig({ installedPackages: ["opentasks", "minimem"] });
+            removeInstalledPackage("minimem");
+            const config = readConfig();
+            expect(config.installedPackages).toEqual(["opentasks"]);
+        });
+        it("does nothing if package is not in list", () => {
+            writeConfig({ installedPackages: ["opentasks"] });
+            removeInstalledPackage("minimem");
+            const config = readConfig();
+            expect(config.installedPackages).toEqual(["opentasks"]);
+        });
+        it("preserves other config fields", () => {
+            writeConfig({
+                installedPackages: ["minimem"],
+                embeddingProvider: "gemini",
+            });
+            removeInstalledPackage("minimem");
+            const config = readConfig();
+            expect(config.embeddingProvider).toBe("gemini");
+        });
+    });
+});

package/dist/config/keys.d.ts

@@ -0,0 +1,10 @@
+/** Read an API key by provider name, or null if not stored */
+export declare function readKey(provider: string): string | null;
+/** Write an API key for a provider (stored with 0600 permissions) */
+export declare function writeKey(provider: string, key: string): void;
+/** Delete a stored API key */
+export declare function deleteKey(provider: string): void;
+/** List all stored provider names */
+export declare function listKeys(): string[];
+/** Check if a key is set for a provider */
+export declare function hasKey(provider: string): boolean;

package/dist/config/keys.js

@@ -0,0 +1,47 @@
+import { existsSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getConfigDir, ensureConfigDir } from "./global.js";
+function getKeysDir() {
+    return join(getConfigDir(), "keys");
+}
+/** Read an API key by provider name, or null if not stored */
+export function readKey(provider) {
+    const path = join(getKeysDir(), provider);
+    if (!existsSync(path))
+        return null;
+    try {
+        return readFileSync(path, "utf-8").trim();
+    }
+    catch {
+        return null;
+    }
+}
+/** Write an API key for a provider (stored with 0600 permissions) */
+export function writeKey(provider, key) {
+    ensureConfigDir();
+    const path = join(getKeysDir(), provider);
+    writeFileSync(path, key + "\n", { mode: 0o600 });
+}
+/** Delete a stored API key */
+export function deleteKey(provider) {
+    const path = join(getKeysDir(), provider);
+    if (existsSync(path)) {
+        unlinkSync(path);
+    }
+}
+/** List all stored provider names */
+export function listKeys() {
+    const dir = getKeysDir();
+    if (!existsSync(dir))
+        return [];
+    try {
+        return readdirSync(dir).filter((f) => !f.startsWith(".")).sort();
+    }
+    catch {
+        return [];
+    }
+}
+/** Check if a key is set for a provider */
+export function hasKey(provider) {
+    return readKey(provider) !== null;
+}

package/dist/config/keys.test.d.ts

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

package/dist/config/keys.test.js

@@ -0,0 +1,87 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { mkdtempSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+let tempHome;
+vi.mock("node:os", async () => {
+    const actual = await vi.importActual("node:os");
+    return {
+        ...actual,
+        homedir: () => tempHome,
+    };
+});
+const { readKey, writeKey, deleteKey, listKeys, hasKey } = await import("./keys.js");
+describe("config/keys", () => {
+    beforeEach(() => {
+        tempHome = mkdtempSync(join(tmpdir(), "swarmkit-keys-test-"));
+    });
+    afterEach(() => {
+        rmSync(tempHome, { recursive: true, force: true });
+    });
+    describe("writeKey / readKey", () => {
+        it("writes and reads a key", () => {
+            writeKey("openai", "sk-test-key-123");
+            expect(readKey("openai")).toBe("sk-test-key-123");
+        });
+        it("trims whitespace when reading", () => {
+            writeKey("openai", "sk-test-key-123");
+            // writeKey appends a newline, readKey should trim it
+            expect(readKey("openai")).toBe("sk-test-key-123");
+        });
+        it("returns null for nonexistent key", () => {
+            expect(readKey("nonexistent")).toBeNull();
+        });
+        it("overwrites existing key", () => {
+            writeKey("openai", "old-key");
+            writeKey("openai", "new-key");
+            expect(readKey("openai")).toBe("new-key");
+        });
+        it("sets file permissions to 0600", () => {
+            writeKey("openai", "sk-test-key");
+            const keyPath = join(tempHome, ".swarmkit", "keys", "openai");
+            const stats = statSync(keyPath);
+            expect(stats.mode & 0o777).toBe(0o600);
+        });
+    });
+    describe("deleteKey", () => {
+        it("deletes an existing key", () => {
+            writeKey("openai", "sk-test-key");
+            expect(readKey("openai")).toBe("sk-test-key");
+            deleteKey("openai");
+            expect(readKey("openai")).toBeNull();
+        });
+        it("does nothing for nonexistent key", () => {
+            // Should not throw
+            deleteKey("nonexistent");
+        });
+    });
+    describe("listKeys", () => {
+        it("returns empty array when no keys exist", () => {
+            expect(listKeys()).toEqual([]);
+        });
+        it("lists all stored keys", () => {
+            writeKey("openai", "key1");
+            writeKey("anthropic", "key2");
+            writeKey("gemini", "key3");
+            const keys = listKeys();
+            expect(keys).toEqual(["anthropic", "gemini", "openai"]);
+        });
+        it("excludes dotfiles", async () => {
+            writeKey("openai", "key1");
+            // Manually create a dotfile
+            const { writeFileSync } = await import("node:fs");
+            writeFileSync(join(tempHome, ".swarmkit", "keys", ".DS_Store"), "");
+            const keys = listKeys();
+            expect(keys).toEqual(["openai"]);
+        });
+    });
+    describe("hasKey", () => {
+        it("returns false when key does not exist", () => {
+            expect(hasKey("openai")).toBe(false);
+        });
+        it("returns true when key exists", () => {
+            writeKey("openai", "sk-test");
+            expect(hasKey("openai")).toBe(true);
+        });
+    });
+});