swarmkit 0.0.6 → 0.0.8

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

@@ -1,5 +1,4 @@
 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";
@@ -61,25 +60,5 @@ export async function configureKeys(state) {
             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

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

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

@@ -1,14 +1,15 @@
-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 GLOBAL_SETUP_ORDER = ["skill-tree", "openhive", "claude-code-swarm"];
+export async function initGlobal(state, force = false) {
     const globalPackages = GLOBAL_SETUP_ORDER.filter((pkg) => state.selectedPackages.includes(pkg));
     if (globalPackages.length === 0)
         return;
-    const uninitialized = globalPackages.filter((pkg) => !isGlobalInit(pkg));
+    const uninitialized = force
+        ? globalPackages
+        : globalPackages.filter((pkg) => !isGlobalInit(pkg));
     if (uninitialized.length === 0) {
         ui.blank();
         ui.info("All global packages already configured.");
@@ -19,51 +20,23 @@ export async function initGlobal(state) {
         packages: state.selectedPackages,
         embeddingProvider: state.embeddingProvider,
         apiKeys: state.apiKeys,
+        packageConfigs: state.packageConfigs,
     };
     for (const pkg of uninitialized) {
+        // Skip packages whose CLI wizard already ran in the config phase
+        if (state.packageConfigs[pkg]?.usedCliWizard) {
+            ui.success(`${pkg} ${chalk.dim("(configured via wizard)")}`);
+            continue;
+        }
         let openhiveOpts;
-        // Openhive: intercept into the wizard for inline configuration
+        // Build OpenhiveOptions from packageConfigs (collected in the config phase)
         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",
-                    },
-                ],
-            });
+            const values = state.packageConfigs.openhive?.values ?? {};
             openhiveOpts = {
-                name,
-                port: parseInt(port, 10) || 3000,
-                authMode,
-                verification,
+                name: values.name ?? "OpenHive",
+                port: parseInt(String(values.port ?? "3000"), 10) || 3000,
+                authMode: values.authMode ?? "local",
+                verification: values.verification ?? "open",
             };
         }
         const result = await initGlobalPackage(pkg, ctx, openhiveOpts);
@@ -73,6 +46,11 @@ export async function initGlobal(state) {
             : "";
         if (result.success) {
             ui.success(`${pkg} ${chalk.dim("→")} ~/${configDir}/${suffix}`);
+            state.configsWritten.push({
+                package: pkg,
+                path: `~/${configDir}/`,
+                description: `Global ${pkg} config`,
+            });
         }
         else {
             ui.fail(`${pkg}: ${result.message ?? "setup failed"}`);

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

@@ -0,0 +1,16 @@
+import type { WizardState } from "../state.js";
+/**
+ * Phase: Integration wiring.
+ *
+ * Walks through active integrations between selected packages:
+ * - Auto-detected integrations (requiresWiring: false) are shown as info
+ * - Wirable integrations get interactive config prompts
+ */
+export declare function configureIntegrations(state: WizardState): Promise<WizardState>;
+/**
+ * Apply collected integration wiring values to package config files on disk.
+ *
+ * Each configOption in INTEGRATIONS specifies a targetPackage and configPath.
+ * This function reads the target config file, patches the value, and writes it back.
+ */
+export declare function applyIntegrationWiring(state: WizardState): void;

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

@@ -0,0 +1,172 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { confirm, input, select } from "@inquirer/prompts";
+import chalk from "chalk";
+import { getActiveIntegrations } from "../../../packages/registry.js";
+import { projectConfigDirs, GLOBAL_CONFIG_DIRS, } from "../../../packages/setup.js";
+import { homedir } from "node:os";
+import * as ui from "../../../utils/ui.js";
+/**
+ * Phase: Integration wiring.
+ *
+ * Walks through active integrations between selected packages:
+ * - Auto-detected integrations (requiresWiring: false) are shown as info
+ * - Wirable integrations get interactive config prompts
+ */
+export async function configureIntegrations(state) {
+    const updated = { ...state, integrationWiring: [...state.integrationWiring] };
+    const activeIntegrations = getActiveIntegrations(updated.selectedPackages);
+    if (activeIntegrations.length === 0)
+        return updated;
+    const autoDetected = activeIntegrations.filter((i) => !i.requiresWiring);
+    const wirable = activeIntegrations.filter((i) => i.requiresWiring && i.configOptions && i.configOptions.length > 0);
+    ui.heading("  Integration wiring");
+    // Show auto-detected integrations
+    if (autoDetected.length > 0) {
+        for (const integration of autoDetected) {
+            const [a, b] = integration.packages;
+            ui.success(`${a} ${chalk.dim("↔")} ${b}  ${chalk.dim(integration.description)} ${chalk.dim("(auto-detected)")}`);
+        }
+    }
+    // Walk through wirable integrations
+    if (wirable.length > 0 && !updated.quick) {
+        for (const integration of wirable) {
+            const [a, b] = integration.packages;
+            const key = `${a}:${b}`;
+            console.log();
+            console.log(`  ${chalk.bold(a)} ${chalk.dim("↔")} ${chalk.bold(b)}`);
+            ui.info(integration.description);
+            const enable = await confirm({
+                message: `Configure this integration?`,
+                default: true,
+            });
+            const wiring = {
+                key,
+                enabled: enable,
+                values: {},
+            };
+            if (enable && integration.configOptions) {
+                for (const option of integration.configOptions) {
+                    const value = await promptConfigOption(option);
+                    wiring.values[option.key] = value;
+                }
+            }
+            updated.integrationWiring.push(wiring);
+        }
+    }
+    else if (wirable.length > 0) {
+        // Quick mode — show what's available but skip config
+        for (const integration of wirable) {
+            const [a, b] = integration.packages;
+            ui.info(`${a} ${chalk.dim("↔")} ${b}  ${chalk.dim(integration.description)} ${chalk.dim("(configure later)")}`);
+        }
+    }
+    return updated;
+}
+/**
+ * Apply collected integration wiring values to package config files on disk.
+ *
+ * Each configOption in INTEGRATIONS specifies a targetPackage and configPath.
+ * This function reads the target config file, patches the value, and writes it back.
+ */
+export function applyIntegrationWiring(state) {
+    if (state.integrationWiring.length === 0)
+        return;
+    const cwd = process.cwd();
+    const activeIntegrations = getActiveIntegrations(state.selectedPackages);
+    for (const wiring of state.integrationWiring) {
+        if (!wiring.enabled)
+            continue;
+        // Find the matching integration definition to get configOptions
+        const integration = activeIntegrations.find((i) => {
+            const [a, b] = i.packages;
+            return `${a}:${b}` === wiring.key;
+        });
+        if (!integration?.configOptions)
+            continue;
+        // Apply each config option that has a collected value
+        for (const option of integration.configOptions) {
+            const value = wiring.values[option.key];
+            if (value === undefined)
+                continue;
+            applyWiringValue(option.targetPackage, option.configPath, value, cwd, state.usePrefix);
+        }
+    }
+}
+/**
+ * Write a single value to a package's config file on disk.
+ */
+function applyWiringValue(pkg, configPath, value, cwd, usePrefix) {
+    const filePath = resolveConfigFile(pkg, cwd, usePrefix);
+    if (!filePath)
+        return;
+    try {
+        const config = existsSync(filePath)
+            ? JSON.parse(readFileSync(filePath, "utf-8"))
+            : {};
+        setNestedValue(config, configPath, value);
+        writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n");
+    }
+    catch {
+        // Non-fatal — integration wiring is best-effort
+    }
+}
+function resolveConfigFile(pkg, cwd, usePrefix) {
+    const configDirs = projectConfigDirs(usePrefix);
+    const configFile = pkg === "sessionlog" ? "settings.json" : "config.json";
+    // Check project config
+    const projectDir = configDirs[pkg];
+    if (projectDir) {
+        const projectPath = join(cwd, projectDir, configFile);
+        if (existsSync(projectPath))
+            return projectPath;
+    }
+    // Check global config
+    const globalDir = GLOBAL_CONFIG_DIRS[pkg];
+    if (globalDir) {
+        const globalPath = join(homedir(), globalDir, "config.json");
+        if (existsSync(globalPath))
+            return globalPath;
+    }
+    return null;
+}
+function setNestedValue(obj, keyPath, value) {
+    const parts = keyPath.split(".");
+    let target = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        if (typeof target[parts[i]] !== "object" || target[parts[i]] === null) {
+            target[parts[i]] = {};
+        }
+        target = target[parts[i]];
+    }
+    const finalKey = parts[parts.length - 1];
+    if (typeof value === "string" && /^\d+(\.\d+)?$/.test(value)) {
+        target[finalKey] = parseFloat(value);
+    }
+    else {
+        target[finalKey] = value;
+    }
+}
+/** Prompt the user for a single integration config option */
+async function promptConfigOption(option) {
+    switch (option.type) {
+        case "confirm":
+            return confirm({
+                message: option.label,
+                default: option.default,
+            });
+        case "select":
+            return select({
+                message: option.label,
+                choices: option.choices ?? [],
+                default: option.default,
+            });
+        case "input":
+            return input({
+                message: option.label,
+                default: option.default,
+            });
+        default:
+            return option.default;
+    }
+}

package/dist/commands/init/phases/package-config.d.ts

@@ -0,0 +1,10 @@
+import type { WizardState } from "../state.js";
+/**
+ * Phase: Per-package interactive configuration.
+ *
+ * For each selected package that has setup config:
+ * - If quick mode, skip entirely (defaults will be used)
+ * - If package has a cliWizard, offer to delegate to it
+ * - If package has inlineOptions (and no wizard or wizard declined), walk through prompts
+ */
+export declare function configurePackages(state: WizardState): Promise<WizardState>;

package/dist/commands/init/phases/package-config.js

@@ -0,0 +1,117 @@
+import { confirm, input, select, password } from "@inquirer/prompts";
+import chalk from "chalk";
+import { PACKAGES } from "../../../packages/registry.js";
+import { runPackageWizard, relocateAfterWizard, PREFIX_ENV_VARS, PROJECT_ROOT, } from "../../../packages/setup.js";
+import * as ui from "../../../utils/ui.js";
+import { join } from "node:path";
+/**
+ * Phase: Per-package interactive configuration.
+ *
+ * For each selected package that has setup config:
+ * - If quick mode, skip entirely (defaults will be used)
+ * - If package has a cliWizard, offer to delegate to it
+ * - If package has inlineOptions (and no wizard or wizard declined), walk through prompts
+ */
+export async function configurePackages(state) {
+    const updated = { ...state, packageConfigs: { ...state.packageConfigs } };
+    const configurablePackages = updated.selectedPackages.filter((pkg) => PACKAGES[pkg]?.setup);
+    if (configurablePackages.length === 0 || updated.quick) {
+        return updated;
+    }
+    ui.heading("  Package configuration");
+    ui.info("Configure each package, or accept defaults.");
+    const cwd = process.cwd();
+    for (const pkgName of configurablePackages) {
+        const pkg = PACKAGES[pkgName];
+        const setupConfig = pkg.setup;
+        const config = { values: {}, usedCliWizard: false };
+        console.log();
+        console.log(`  ${chalk.bold(pkgName)}  ${chalk.dim(pkg.description)}`);
+        // Try CLI wizard first if available
+        if (setupConfig.cliWizard) {
+            const useWizard = await confirm({
+                message: `Run ${pkgName}'s interactive setup wizard?`,
+                default: false,
+            });
+            if (useWizard) {
+                // Build prefix-aware env vars for project-level packages
+                const wizardConfig = { ...setupConfig.cliWizard };
+                if (updated.usePrefix && PREFIX_ENV_VARS[pkgName]) {
+                    const envVar = PREFIX_ENV_VARS[pkgName];
+                    const prefixDir = PROJECT_ROOT + "/" +
+                        (pkgName === "opentasks" ? "opentasks" :
+                            pkgName === "self-driving-repo" ? "self-driving" :
+                                pkgName === "openteams" ? "openteams" :
+                                    pkgName === "cognitive-core" ? "cognitive-core" : pkgName);
+                    wizardConfig.env = {
+                        ...wizardConfig.env,
+                        // Some packages need absolute paths, others relative
+                        [envVar]: pkgName === "cognitive-core"
+                            ? join(cwd, prefixDir)
+                            : prefixDir,
+                    };
+                }
+                const result = await runPackageWizard(pkgName, wizardConfig, updated, { cwd });
+                if (result.success) {
+                    // Relocate from flat to prefixed location if needed
+                    relocateAfterWizard(cwd, pkgName, updated.usePrefix);
+                    config.usedCliWizard = true;
+                    ui.success(`${pkgName} wizard completed.`);
+                    updated.packageConfigs[pkgName] = config;
+                    continue;
+                }
+                else {
+                    ui.warn(`${pkgName} wizard failed: ${result.message ?? "unknown error"}`);
+                    ui.info("Falling back to inline configuration.");
+                }
+            }
+        }
+        // Inline options
+        if (setupConfig.inlineOptions && setupConfig.inlineOptions.length > 0) {
+            const customize = await confirm({
+                message: `Customize ${pkgName} settings?`,
+                default: false,
+            });
+            if (customize) {
+                for (const option of setupConfig.inlineOptions) {
+                    // Check conditional visibility
+                    if (option.when && !option.when(updated.selectedPackages)) {
+                        continue;
+                    }
+                    const value = await promptOption(option);
+                    config.values[option.key] = value;
+                }
+            }
+        }
+        updated.packageConfigs[pkgName] = config;
+    }
+    return updated;
+}
+/** Prompt the user for a single inline option */
+async function promptOption(option) {
+    switch (option.type) {
+        case "confirm":
+            return confirm({
+                message: option.label,
+                default: option.default,
+            });
+        case "select":
+            return select({
+                message: option.label,
+                choices: option.choices ?? [],
+                default: option.default,
+            });
+        case "input":
+            return input({
+                message: option.label,
+                default: option.default,
+            });
+        case "password":
+            return password({
+                message: option.label,
+                mask: "*",
+            });
+        default:
+            return option.default;
+    }
+}

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

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