swarmkit 0.0.1 → 0.0.3

package/dist/commands/init/phases/configure.js

@@ -0,0 +1,85 @@
+import { select, password } from "@inquirer/prompts";
+import chalk from "chalk";
+import { readConfig, writeConfig } from "../../../config/global.js";
+import { writeKey } from "../../../config/keys.js";
+import * as ui from "../../../utils/ui.js";
+/** Packages that use embeddings */
+const EMBEDDING_CONSUMERS = ["minimem", "cognitive-core", "skill-tree"];
+export async function configureKeys(state) {
+    const updated = { ...state };
+    // Check if any installed package uses embeddings
+    const needsEmbeddings = state.selectedPackages.some((p) => EMBEDDING_CONSUMERS.includes(p));
+    if (needsEmbeddings) {
+        console.log();
+        const embeddingChoice = await select({
+            message: "Embedding provider (used by " +
+                state.selectedPackages
+                    .filter((p) => EMBEDDING_CONSUMERS.includes(p))
+                    .join(", ") +
+                "):",
+            choices: [
+                { name: "OpenAI  (requires OPENAI_API_KEY)", value: "openai" },
+                {
+                    name: "Gemini  (free tier available)",
+                    value: "gemini",
+                },
+                { name: "Local   (no API key, uses local models)", value: "local" },
+                { name: "Skip    (configure later)", value: null },
+            ],
+        });
+        if (embeddingChoice) {
+            updated.embeddingProvider = embeddingChoice;
+            // Collect embedding API key if needed
+            if (embeddingChoice === "openai") {
+                const key = await password({
+                    message: "OpenAI API key:",
+                    mask: "*",
+                });
+                if (key) {
+                    updated.apiKeys["openai"] = key;
+                    writeKey("openai", key);
+                    ui.success("OpenAI API key stored");
+                }
+            }
+            else if (embeddingChoice === "gemini") {
+                const key = await password({
+                    message: "Gemini API key:",
+                    mask: "*",
+                });
+                if (key) {
+                    updated.apiKeys["gemini"] = key;
+                    writeKey("gemini", key);
+                    ui.success("Gemini API key stored");
+                }
+            }
+            // Save embedding preference
+            const config = readConfig();
+            config.embeddingProvider = embeddingChoice;
+            if (embeddingChoice === "openai") {
+                config.embeddingModel = "text-embedding-3-small";
+            }
+            writeConfig(config);
+        }
+    }
+    // Always ask for Anthropic key (needed for agents)
+    console.log();
+    const hasAnthropicKey = !!process.env["ANTHROPIC_API_KEY"];
+    if (hasAnthropicKey) {
+        ui.info(`Anthropic API key detected from environment ${chalk.dim("(ANTHROPIC_API_KEY)")}`);
+    }
+    else {
+        const anthropicKey = await password({
+            message: "Anthropic API key (for running agents):",
+            mask: "*",
+        });
+        if (anthropicKey) {
+            updated.apiKeys["anthropic"] = anthropicKey;
+            writeKey("anthropic", anthropicKey);
+            ui.success("Anthropic API key stored");
+        }
+        else {
+            ui.info("Skipped — you can set ANTHROPIC_API_KEY later.");
+        }
+    }
+    return updated;
+}

package/dist/commands/init/phases/global-setup.d.ts

@@ -0,0 +1,2 @@
+import type { WizardState } from "../state.js";
+export declare function initGlobal(state: WizardState): Promise<void>;

package/dist/commands/init/phases/global-setup.js

@@ -0,0 +1,81 @@
+import { input, select } from "@inquirer/prompts";
+import chalk from "chalk";
+import { GLOBAL_CONFIG_DIRS, isGlobalInit, initGlobalPackage, } from "../../../packages/setup.js";
+import * as ui from "../../../utils/ui.js";
+/** Global packages in setup order */
+const GLOBAL_SETUP_ORDER = ["skill-tree", "openhive"];
+export async function initGlobal(state) {
+    const globalPackages = GLOBAL_SETUP_ORDER.filter((pkg) => state.selectedPackages.includes(pkg));
+    if (globalPackages.length === 0)
+        return;
+    const uninitialized = globalPackages.filter((pkg) => !isGlobalInit(pkg));
+    if (uninitialized.length === 0) {
+        ui.blank();
+        ui.info("All global packages already configured.");
+        return;
+    }
+    ui.heading("  Global package setup");
+    const ctx = {
+        packages: state.selectedPackages,
+        embeddingProvider: state.embeddingProvider,
+        apiKeys: state.apiKeys,
+    };
+    for (const pkg of uninitialized) {
+        let openhiveOpts;
+        // Openhive: intercept into the wizard for inline configuration
+        if (pkg === "openhive") {
+            console.log();
+            ui.info("Configuring OpenHive...");
+            console.log();
+            const name = await input({
+                message: "OpenHive instance name:",
+                default: "OpenHive",
+            });
+            const port = await input({
+                message: "OpenHive port:",
+                default: "3000",
+            });
+            const verification = await select({
+                message: "Registration mode:",
+                choices: [
+                    { name: "Open — anyone can register", value: "open" },
+                    {
+                        name: "Invite — require an invite code",
+                        value: "invite",
+                    },
+                    {
+                        name: "Manual — admin approves each",
+                        value: "manual",
+                    },
+                ],
+            });
+            const authMode = await select({
+                message: "Auth mode:",
+                choices: [
+                    { name: "Local — no login, single-user", value: "local" },
+                    {
+                        name: "Token — email/password registration",
+                        value: "token",
+                    },
+                ],
+            });
+            openhiveOpts = {
+                name,
+                port: parseInt(port, 10) || 3000,
+                authMode,
+                verification,
+            };
+        }
+        const result = await initGlobalPackage(pkg, ctx, openhiveOpts);
+        const configDir = GLOBAL_CONFIG_DIRS[pkg] ?? "";
+        const suffix = result.message
+            ? ` ${chalk.dim(`(${result.message})`)}`
+            : "";
+        if (result.success) {
+            ui.success(`${pkg} ${chalk.dim("→")} ~/${configDir}/${suffix}`);
+        }
+        else {
+            ui.fail(`${pkg}: ${result.message ?? "setup failed"}`);
+        }
+    }
+}

package/dist/commands/init/phases/packages.d.ts

@@ -0,0 +1,2 @@
+import type { WizardState } from "../state.js";
+export declare function installSelectedPackages(state: WizardState): Promise<void>;

package/dist/commands/init/phases/packages.js

@@ -0,0 +1,30 @@
+import chalk from "chalk";
+import { installPackages } from "../../../packages/installer.js";
+import { addInstalledPackages } from "../../../config/global.js";
+import * as ui from "../../../utils/ui.js";
+export async function installSelectedPackages(state) {
+    const { selectedPackages } = state;
+    console.log();
+    console.log(`  Installing ${chalk.bold(selectedPackages.length.toString())} packages...`);
+    console.log();
+    const results = await installPackages(selectedPackages);
+    let failures = 0;
+    for (const result of results) {
+        if (result.success) {
+            ui.success(`${result.package} ${result.version ? chalk.dim("v" + result.version) : ""}`);
+        }
+        else {
+            ui.fail(`${result.package} — ${result.error}`);
+            failures++;
+        }
+    }
+    // Record successful installations
+    const installed = results.filter((r) => r.success).map((r) => r.package);
+    if (installed.length > 0) {
+        addInstalledPackages(installed);
+    }
+    if (failures > 0) {
+        ui.blank();
+        ui.warn(`${failures} package${failures === 1 ? "" : "s"} failed to install. Run \`swarmkit doctor\` to diagnose.`);
+    }
+}

package/dist/commands/init/phases/project.d.ts

@@ -0,0 +1,2 @@
+import type { WizardState } from "../state.js";
+export declare function initProject(state: WizardState): Promise<void>;

package/dist/commands/init/phases/project.js

@@ -0,0 +1,56 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { confirm } from "@inquirer/prompts";
+import chalk from "chalk";
+import { PACKAGES } from "../../../packages/registry.js";
+import { PROJECT_INIT_ORDER, projectConfigDirs, isProjectInit, initProjectPackage, } from "../../../packages/setup.js";
+import * as ui from "../../../utils/ui.js";
+export async function initProject(state) {
+    const cwd = process.cwd();
+    // Only offer project init if we're in a directory that looks like a project
+    const isProject = existsSync(join(cwd, ".git")) || existsSync(join(cwd, "package.json"));
+    if (!isProject) {
+        ui.blank();
+        ui.info("Run `swarmkit init` inside a project directory to initialize per-project configs.");
+        return;
+    }
+    const configDirs = projectConfigDirs(state.usePrefix);
+    // Filter to packages that have project-level config, in init order
+    const projectPackages = PROJECT_INIT_ORDER.filter((pkg) => state.selectedPackages.includes(pkg) &&
+        !PACKAGES[pkg]?.globalOnly &&
+        pkg in configDirs);
+    if (projectPackages.length === 0)
+        return;
+    // Check which are already initialized
+    const uninitialized = projectPackages.filter((pkg) => !isProjectInit(cwd, pkg));
+    if (uninitialized.length === 0) {
+        ui.blank();
+        ui.info("All packages already initialized in this project.");
+        return;
+    }
+    console.log();
+    const shouldInit = await confirm({
+        message: `Initialize ${uninitialized.length} package${uninitialized.length === 1 ? "" : "s"} in ${chalk.dim(cwd)}?`,
+        default: true,
+    });
+    if (!shouldInit)
+        return;
+    const ctx = {
+        cwd,
+        packages: state.selectedPackages,
+        embeddingProvider: state.embeddingProvider,
+        apiKeys: state.apiKeys,
+        usePrefix: state.usePrefix,
+    };
+    ui.blank();
+    for (const pkg of uninitialized) {
+        const result = await initProjectPackage(pkg, ctx);
+        const configDir = configDirs[pkg] ?? "";
+        if (result.success) {
+            ui.success(`${pkg} ${chalk.dim("→")} ${configDir}/`);
+        }
+        else {
+            ui.fail(`${pkg}: ${result.message ?? "initialization failed"}`);
+        }
+    }
+}

package/dist/commands/init/phases/use-case.d.ts

@@ -0,0 +1,2 @@
+import type { WizardState } from "../state.js";
+export declare function selectUseCase(state: WizardState): Promise<WizardState>;

package/dist/commands/init/phases/use-case.js

@@ -0,0 +1,41 @@
+import { select, checkbox } from "@inquirer/prompts";
+import { BUNDLES, PACKAGES, getAllPackageNames } from "../../../packages/registry.js";
+export async function selectUseCase(state) {
+    const bundleChoice = await select({
+        message: "What are you building?",
+        choices: [
+            ...Object.values(BUNDLES).map((b) => ({
+                name: `${b.label}  (${b.name} bundle — ${b.packages.length} packages)`,
+                value: b.name,
+            })),
+            {
+                name: "Let me pick individually",
+                value: "custom",
+            },
+        ],
+    });
+    if (bundleChoice === "custom") {
+        const selected = await checkbox({
+            message: "Select packages to install:",
+            choices: getAllPackageNames().map((name) => ({
+                name: `${name}  ${PACKAGES[name].description}`,
+                value: name,
+            })),
+        });
+        if (selected.length === 0) {
+            console.log("\n  No packages selected.\n");
+            process.exit(0);
+        }
+        return {
+            ...state,
+            bundle: "custom",
+            selectedPackages: selected,
+        };
+    }
+    const bundle = BUNDLES[bundleChoice];
+    return {
+        ...state,
+        bundle: bundleChoice,
+        selectedPackages: [...bundle.packages],
+    };
+}

package/dist/commands/init/state.d.ts

@@ -0,0 +1,13 @@
+export interface WizardState {
+    /** Selected bundle name, or "custom" */
+    bundle: string;
+    /** Packages to install */
+    selectedPackages: string[];
+    /** Embedding provider choice */
+    embeddingProvider: "openai" | "gemini" | "local" | null;
+    /** Collected API keys (provider -> key) */
+    apiKeys: Record<string, string>;
+    /** Whether to nest project configs under .swarm/ (default true) */
+    usePrefix: boolean;
+}
+export declare function createEmptyState(): WizardState;

package/dist/commands/init/state.js

@@ -0,0 +1,9 @@
+export function createEmptyState() {
+    return {
+        bundle: "",
+        selectedPackages: [],
+        embeddingProvider: null,
+        apiKeys: {},
+        usePrefix: true,
+    };
+}

package/dist/commands/init/state.test.d.ts

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

package/dist/commands/init/state.test.js

@@ -0,0 +1,21 @@
+import { describe, it, expect } from "vitest";
+import { createEmptyState } from "./state.js";
+describe("WizardState", () => {
+    describe("createEmptyState", () => {
+        it("returns a state with empty defaults", () => {
+            const state = createEmptyState();
+            expect(state.bundle).toBe("");
+            expect(state.selectedPackages).toEqual([]);
+            expect(state.embeddingProvider).toBeNull();
+            expect(state.apiKeys).toEqual({});
+            expect(state.usePrefix).toBe(true);
+        });
+        it("returns a new object each time", () => {
+            const a = createEmptyState();
+            const b = createEmptyState();
+            expect(a).not.toBe(b);
+            expect(a.selectedPackages).not.toBe(b.selectedPackages);
+            expect(a.apiKeys).not.toBe(b.apiKeys);
+        });
+    });
+});

package/dist/commands/init/wizard.d.ts

@@ -0,0 +1,4 @@
+export interface WizardOptions {
+    noPrefix?: boolean;
+}
+export declare function runWizard(opts?: WizardOptions): Promise<void>;

package/dist/commands/init/wizard.js

@@ -0,0 +1,108 @@
+import chalk from "chalk";
+import { select } from "@inquirer/prompts";
+import { isFirstRun, readConfig, writeConfig, ensureConfigDir } from "../../config/global.js";
+import * as ui from "../../utils/ui.js";
+import { getActiveIntegrations } from "../../packages/registry.js";
+import { isClaudeCliAvailable } from "../../packages/installer.js";
+import { isInstalledPlugin, registerPlugin } from "../../packages/plugin.js";
+import { createEmptyState } from "./state.js";
+import { selectUseCase } from "./phases/use-case.js";
+import { installSelectedPackages } from "./phases/packages.js";
+import { configureKeys } from "./phases/configure.js";
+import { initProject } from "./phases/project.js";
+import { initGlobal } from "./phases/global-setup.js";
+export async function runWizard(opts) {
+    console.log();
+    console.log(`  ${chalk.bold("swarmkit")} ${chalk.dim("— multi-agent infrastructure toolkit")}`);
+    console.log();
+    if (isFirstRun()) {
+        await runFirstTimeSetup(opts);
+    }
+    else {
+        await runProjectSetup(opts);
+    }
+}
+async function runFirstTimeSetup(opts) {
+    ensureConfigDir();
+    // Step 1: Use case / bundle selection
+    let state = await selectUseCase(createEmptyState());
+    if (opts?.noPrefix) {
+        state.usePrefix = false;
+    }
+    // Step 2: Install packages
+    await installSelectedPackages(state);
+    // Step 2.5: Plugin activation (for any Claude Code plugins)
+    await activatePlugins(state);
+    // Step 3: Configure (embedding provider, API keys)
+    state = await configureKeys(state);
+    // Step 4: Global package setup (skill-tree, openhive)
+    await initGlobal(state);
+    // Step 5: Project init (if in a project directory)
+    await initProject(state);
+    // Persist prefix preference
+    const config = readConfig();
+    config.usePrefix = state.usePrefix;
+    writeConfig(config);
+    // Summary
+    printSummary(state);
+}
+async function runProjectSetup(opts) {
+    const config = readConfig();
+    ui.info(`Global config found. ${config.installedPackages.length} packages installed.`);
+    const state = createEmptyState();
+    state.selectedPackages = [...config.installedPackages];
+    state.usePrefix = opts?.noPrefix === true ? false : (config.usePrefix ?? true);
+    await initProject(state);
+}
+async function activatePlugins(state) {
+    if (!(await isClaudeCliAvailable()))
+        return;
+    for (const pkg of state.selectedPackages) {
+        if (!(await isInstalledPlugin(pkg)))
+            continue;
+        console.log();
+        ui.info(`${pkg} is a Claude Code plugin.`);
+        const choice = await select({
+            message: `Activate ${pkg} as a Claude Code plugin?`,
+            choices: [
+                {
+                    name: "Project (this repository only)",
+                    value: "project",
+                },
+                {
+                    name: "User (all projects)",
+                    value: "user",
+                },
+                {
+                    name: "Skip (activate later)",
+                    value: "skip",
+                },
+            ],
+        });
+        if (choice === "skip") {
+            ui.info("Skipped. Activate later with: claude plugin add <path> --scope project|user");
+            continue;
+        }
+        try {
+            await registerPlugin(pkg, choice);
+            ui.success(`Plugin activated (${choice} scope).`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ui.fail(`Plugin activation failed: ${msg}`);
+        }
+    }
+}
+function printSummary(state) {
+    const integrations = getActiveIntegrations(state.selectedPackages);
+    if (integrations.length > 0) {
+        ui.heading("  Active integrations:");
+        for (const integration of integrations) {
+            const [a, b] = integration.packages;
+            ui.bullet(`  ${a} ${chalk.dim("↔")} ${b}  ${chalk.dim(integration.description)}`);
+        }
+    }
+    ui.blank();
+    console.log(`  ${chalk.green("Done.")} Run ${chalk.bold("`swarmkit status`")} to see your setup.`);
+    ui.blank();
+}

package/dist/commands/init.d.ts

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

package/dist/commands/init.js

@@ -0,0 +1,11 @@
+export function registerInitCommand(program) {
+    program
+        .command("init")
+        .description("Interactive setup wizard")
+        .option("--no-prefix", "Use flat layout (e.g. .opentasks/) instead of nesting under .swarm/")
+        .action(async (opts) => {
+        // Dynamic import to avoid loading @inquirer/prompts for other commands
+        const { runWizard } = await import("./init/wizard.js");
+        await runWizard({ noPrefix: opts.prefix === false });
+    });
+}

package/dist/commands/login.d.ts

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

package/dist/commands/login.js

@@ -0,0 +1,91 @@
+import chalk from "chalk";
+import { isLoggedIn } from "../hub/credentials.js";
+import { getMe, HubApiError } from "../hub/client.js";
+import { findAvailablePort, getLoginUrl, runLoginFlow, } from "../hub/auth-flow.js";
+import * as ui from "../utils/ui.js";
+export function registerLoginCommand(program) {
+    program
+        .command("login")
+        .description("Log in to SwarmHub")
+        .option("--hub <url>", "SwarmHub URL (default: https://hub.swarmkit.ai)")
+        .action(async (opts) => {
+        // Set env var so getHubUrl() picks it up for this session
+        if (opts.hub) {
+            process.env.SWARMKIT_HUB_URL = opts.hub;
+        }
+        if (isLoggedIn()) {
+            try {
+                const user = await getMe();
+                ui.blank();
+                ui.info(`Already logged in as ${chalk.bold(user.name)} (${user.email})`);
+                ui.info("Run `swarmkit logout` first to switch accounts.");
+                ui.blank();
+                return;
+            }
+            catch {
+                // Token expired or invalid — proceed with login
+            }
+        }
+        let port;
+        try {
+            port = await findAvailablePort();
+        }
+        catch {
+            ui.blank();
+            ui.fail("Could not find an available port for the callback server.");
+            ui.blank();
+            return;
+        }
+        const loginUrl = getLoginUrl(port);
+        ui.blank();
+        ui.info("Opening browser to authenticate with SwarmHub...");
+        const opened = await openBrowser(loginUrl);
+        if (!opened) {
+            ui.blank();
+            ui.info("Open this URL in your browser to log in:");
+            ui.blank();
+            console.log(`    ${loginUrl}`);
+        }
+        ui.blank();
+        ui.info("Waiting for authentication...");
+        try {
+            await runLoginFlow(port);
+            const user = await getMe();
+            ui.blank();
+            ui.success(`Logged in as ${chalk.bold(user.name)} (${user.email})`);
+            ui.blank();
+        }
+        catch (err) {
+            ui.blank();
+            if (err instanceof HubApiError) {
+                ui.fail(`Login failed: ${err.message}`);
+            }
+            else if (err instanceof Error) {
+                ui.fail(err.message);
+            }
+            else {
+                ui.fail("Login failed.");
+            }
+            ui.blank();
+        }
+    });
+}
+async function openBrowser(url) {
+    try {
+        const { exec } = await import("node:child_process");
+        const { platform } = await import("node:os");
+        const cmd = platform() === "darwin"
+            ? "open"
+            : platform() === "win32"
+                ? "start"
+                : "xdg-open";
+        return new Promise((resolve) => {
+            exec(`${cmd} ${JSON.stringify(url)}`, (err) => {
+                resolve(!err);
+            });
+        });
+    }
+    catch {
+        return false;
+    }
+}

package/dist/commands/logout.d.ts

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

package/dist/commands/logout.js

@@ -0,0 +1,19 @@
+import { isLoggedIn, deleteCredentials } from "../hub/credentials.js";
+import * as ui from "../utils/ui.js";
+export function registerLogoutCommand(program) {
+    program
+        .command("logout")
+        .description("Log out of SwarmHub")
+        .action(() => {
+        if (!isLoggedIn()) {
+            ui.blank();
+            ui.info("Not currently logged in.");
+            ui.blank();
+            return;
+        }
+        deleteCredentials();
+        ui.blank();
+        ui.success("Logged out of SwarmHub.");
+        ui.blank();
+    });
+}

package/dist/commands/remove.d.ts

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