swarmkit 0.0.6 → 0.0.7

package/dist/packages/setup.js

@@ -1,9 +1,99 @@
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
 import { basename, join } from "node:path";
 import { homedir } from "node:os";
 const execFileAsync = promisify(execFile);
+/**
+ * Run a package's own setup wizard.
+ *
+ * In interactive mode (default): uses `stdio: 'inherit'` so the package's
+ * prompts take over the terminal.
+ *
+ * In non-interactive mode: uses `stdio: 'pipe'` with `nonInteractiveArgs`
+ * (falling back to `args`), suitable for --quick mode, CI, and testing.
+ */
+export async function runPackageWizard(pkg, wizardConfig, state, opts) {
+    // Backwards compat: opts used to be just cwd string
+    const options = typeof opts === "string"
+        ? { cwd: opts }
+        : opts ?? {};
+    const interactive = options.interactive ?? true;
+    const env = {
+        ...cleanEnv(),
+        HOME: homedir(),
+    };
+    // Pass swarmkit context via env vars
+    if (state.embeddingProvider) {
+        env.SWARMKIT_EMBEDDING_PROVIDER = state.embeddingProvider;
+    }
+    if (state.usePrefix !== undefined) {
+        env.SWARMKIT_USE_PREFIX = String(state.usePrefix);
+    }
+    if (state.apiKeys.openai) {
+        env.OPENAI_API_KEY = state.apiKeys.openai;
+    }
+    if (state.apiKeys.gemini) {
+        env.GEMINI_API_KEY = state.apiKeys.gemini;
+    }
+    // Merge package-specific env overrides
+    if (wizardConfig.env) {
+        Object.assign(env, wizardConfig.env);
+    }
+    const timeout = wizardConfig.timeout ?? 120_000;
+    const args = (!interactive && wizardConfig.nonInteractiveArgs)
+        ? wizardConfig.nonInteractiveArgs
+        : wizardConfig.args;
+    const stdio = interactive ? "inherit" : "pipe";
+    return new Promise((resolve) => {
+        const child = spawn(wizardConfig.command, args, {
+            stdio,
+            env,
+            cwd: options.cwd,
+            timeout,
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve({ package: pkg, success: true });
+            }
+            else {
+                resolve({
+                    package: pkg,
+                    success: false,
+                    message: `exited with code ${code}`,
+                });
+            }
+        });
+        child.on("error", (err) => {
+            resolve({
+                package: pkg,
+                success: false,
+                message: formatError(err),
+            });
+        });
+    });
+}
+/**
+ * Env var overrides that tell each package's CLI to create config in the
+ * .swarm/<pkg>/ prefix layout instead of the default flat location.
+ * Used by both initProjectPackage (via shellInit) and runPackageWizard.
+ */
+export const PREFIX_ENV_VARS = {
+    opentasks: "OPENTASKS_PROJECT_DIR",
+    "cognitive-core": "COGNITIVE_CORE_HOME",
+    "self-driving-repo": "SDR_CONFIG_DIR",
+    openteams: "OPENTEAMS_PROJECT_DIR",
+};
+/**
+ * Flat dir name → prefixed dir name for relocation after CLI wizard runs.
+ * Packages that create at .<name>/ need relocation to .swarm/<name>/.
+ */
+export const RELOCATE_MAP = {
+    opentasks: [".opentasks", "opentasks"],
+    "cognitive-core": [".cognitive-core", "cognitive-core"],
+    "self-driving-repo": [".self-driving", "self-driving"],
+    openteams: [".openteams", "openteams"],
+};
 // ─── Project-level setup ─────────────────────────────────────────────────────
 /** Root directory for all swarmkit project-level config */
 export const PROJECT_ROOT = ".swarm";
@@ -33,6 +123,23 @@ export const FLAT_PROJECT_CONFIG_DIRS = {
 export function projectConfigDirs(usePrefix) {
     return usePrefix ? PROJECT_CONFIG_DIRS : FLAT_PROJECT_CONFIG_DIRS;
 }
+/**
+ * After a CLI wizard runs for a project-level package, relocate its output
+ * from the flat location to the .swarm/ prefix location if needed.
+ */
+export function relocateAfterWizard(cwd, pkg, usePrefix) {
+    if (!usePrefix)
+        return;
+    const entry = RELOCATE_MAP[pkg];
+    if (!entry)
+        return;
+    const root = join(cwd, PROJECT_ROOT);
+    if (!existsSync(root)) {
+        mkdirSync(root, { recursive: true });
+    }
+    const [legacyName, targetName] = entry;
+    relocate(cwd, legacyName, targetName);
+}
 /**
  * Project-level packages in correct init order.
  * Order matters: minimem before cognitive-core (runtime detection).
@@ -137,6 +244,7 @@ export async function initProjectPackage(pkg, ctx) {
 export const GLOBAL_CONFIG_DIRS = {
     "skill-tree": ".skill-tree",
     openhive: ".openhive",
+    "claude-code-swarm": ".claude-swarm",
 };
 /** Check whether a global package is already configured */
 export function isGlobalInit(pkg) {
@@ -163,7 +271,7 @@ export async function initGlobalPackage(pkg, ctx, openhiveOpts) {
         case "sessionlog":
             return { package: "sessionlog", success: true, message: "no setup required" };
         case "claude-code-swarm":
-            return { package: "claude-code-swarm", success: true, message: "no setup required" };
+            return initClaudeSwarmGlobal(ctx);
         default:
             return { package: pkg, success: false, message: "Unknown package" };
     }
@@ -203,20 +311,26 @@ async function initMinimem(ctx) {
     if (!existsSync(join(absTarget, "config.json"))) {
         initMinimemInline(absTarget);
     }
-    // Patch embedding provider if the wizard chose one
-    const provider = ctx.embeddingProvider && ctx.embeddingProvider !== "local"
-        ? ctx.embeddingProvider
-        : null;
-    if (provider) {
-        const configPath = join(absTarget, "config.json");
-        try {
-            const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    // Patch config with wizard choices
+    const configPath = join(absTarget, "config.json");
+    try {
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        // Patch embedding provider if the wizard chose one
+        const provider = ctx.embeddingProvider && ctx.embeddingProvider !== "local"
+            ? ctx.embeddingProvider
+            : null;
+        if (provider) {
             config.embedding = { ...config.embedding, provider };
-            writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
         }
-        catch {
-            // Non-fatal
+        // Apply per-package config overrides from the interactive config phase
+        const overrides = ctx.packageConfigs?.minimem?.values;
+        if (overrides) {
+            applyNestedOverrides(config, overrides);
         }
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    }
+    catch {
+        // Non-fatal
     }
     return { package: "minimem", success: true };
 }
@@ -242,7 +356,10 @@ function initMinimemInline(targetDir) {
     }
 }
 async function initSdr(ctx) {
-    const result = await shellInit("sdr", ["init", "-t", "triage-only"], ctx.cwd, ctx.usePrefix
+    // Use template from interactive config if available, otherwise default
+    const template = ctx.packageConfigs?.["self-driving-repo"]?.values?.template ??
+        "triage-only";
+    const result = await shellInit("sdr", ["init", "-t", template], ctx.cwd, ctx.usePrefix
         ? { SDR_CONFIG_DIR: join(PROJECT_ROOT, "self-driving") }
         : undefined);
     // relocate handles packages that don't yet respect the env var;
@@ -311,7 +428,15 @@ async function initSessionlogProject(ctx) {
             ? join(ctx.cwd, PROJECT_ROOT, "sessionlog")
             : join(ctx.cwd, ".sessionlog");
         mkdirSync(targetDir, { recursive: true });
-        // Write default settings.json
+        // Apply per-package config overrides
+        const overrides = ctx.packageConfigs?.sessionlog?.values;
+        // Extract session repo config from dot-notation overrides.
+        // sessionRepo.remote and sessionRepo.directory are committable (go to settings.json).
+        // sessionRepo.localPath is machine-specific (goes to settings.local.json).
+        const repoRemote = overrides?.["sessionRepo.remote"];
+        const repoDirectory = overrides?.["sessionRepo.directory"];
+        const repoLocalPath = overrides?.["sessionRepo.localPath"];
+        // Write settings.json with defaults (committed, shared across clones)
         const settingsPath = join(targetDir, "settings.json");
         if (!existsSync(settingsPath)) {
             const defaultSettings = {
@@ -321,8 +446,48 @@ async function initSessionlogProject(ctx) {
                 telemetryEnabled: false,
                 summarizationEnabled: false,
             };
+            // Apply overrides, stripping session repo dot-notation keys
+            if (overrides) {
+                const sessionRepoKeys = ["sessionRepo.remote", "sessionRepo.directory", "sessionRepo.localPath", "sessionRepo.autoPush"];
+                for (const [key, value] of Object.entries(overrides)) {
+                    if (!sessionRepoKeys.includes(key)) {
+                        defaultSettings[key] = value;
+                    }
+                }
+            }
+            // Build sessionRepo object for committable fields (remote + directory)
+            if (repoRemote) {
+                const sessionRepo = { remote: repoRemote };
+                if (repoDirectory) {
+                    sessionRepo.directory = repoDirectory;
+                }
+                defaultSettings.sessionRepo = sessionRepo;
+            }
             writeFileSync(settingsPath, JSON.stringify(defaultSettings, null, 2) + "\n");
         }
+        // Write machine-specific session repo fields to settings.local.json
+        if (repoLocalPath) {
+            const localSettingsPath = join(targetDir, "settings.local.json");
+            const localSettings = {};
+            if (existsSync(localSettingsPath)) {
+                try {
+                    Object.assign(localSettings, JSON.parse(readFileSync(localSettingsPath, "utf-8")));
+                }
+                catch {
+                    // Start fresh
+                }
+            }
+            localSettings.sessionRepo = {
+                ...(localSettings.sessionRepo ?? {}),
+                localPath: repoLocalPath,
+            };
+            writeFileSync(localSettingsPath, JSON.stringify(localSettings, null, 2) + "\n");
+        }
+        // Ensure settings.local.json is gitignored
+        const gitignorePath = join(targetDir, ".gitignore");
+        if (!existsSync(gitignorePath)) {
+            writeFileSync(gitignorePath, "# Sessionlog local files (not committed)\nsettings.local.json\ntmp/\nlogs/\n");
+        }
         return { package: "sessionlog", success: true };
     }
     catch (err) {
@@ -386,6 +551,40 @@ async function initOpenhive(opts) {
         };
     }
 }
+async function initClaudeSwarmGlobal(ctx) {
+    try {
+        const targetDir = join(homedir(), ".claude-swarm");
+        mkdirSync(targetDir, { recursive: true });
+        // Write default global config.json (user preferences that apply across projects)
+        const configPath = join(targetDir, "config.json");
+        if (!existsSync(configPath)) {
+            const defaultConfig = {
+                map: {
+                    server: "",
+                    sidecar: "session",
+                },
+                sessionlog: {
+                    enabled: false,
+                    sync: "off",
+                },
+            };
+            // Apply per-package config overrides
+            const overrides = ctx.packageConfigs?.["claude-code-swarm"]?.values;
+            if (overrides) {
+                applyNestedOverrides(defaultConfig, overrides);
+            }
+            writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2) + "\n", { mode: 0o600 });
+        }
+        return { package: "claude-code-swarm", success: true };
+    }
+    catch (err) {
+        return {
+            package: "claude-code-swarm",
+            success: false,
+            message: formatError(err),
+        };
+    }
+}
 async function initClaudeSwarmProject(ctx) {
     try {
         const targetDir = ctx.usePrefix
@@ -409,6 +608,11 @@ async function initClaudeSwarmProject(ctx) {
                     sync: "off",
                 },
             };
+            // Apply per-package config overrides
+            const overrides = ctx.packageConfigs?.["claude-code-swarm"]?.values;
+            if (overrides) {
+                applyNestedOverrides(defaultConfig, overrides);
+            }
             writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2) + "\n");
         }
         // Write .gitignore for tmp/
@@ -427,6 +631,31 @@ async function initClaudeSwarmProject(ctx) {
     }
 }
 // ─── Helpers ─────────────────────────────────────────────────────────────────
+/**
+ * Apply dotted-key overrides to a nested config object.
+ * e.g., { "hybrid.vectorWeight": 0.8 } sets config.hybrid.vectorWeight = 0.8
+ */
+function applyNestedOverrides(config, overrides) {
+    for (const [key, value] of Object.entries(overrides)) {
+        const parts = key.split(".");
+        let target = config;
+        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];
+        // Coerce numeric strings to numbers for config values
+        if (typeof value === "string" && /^\d+(\.\d+)?$/.test(value)) {
+            target[finalKey] = parseFloat(value);
+        }
+        else {
+            target[finalKey] = value;
+        }
+    }
+}
 /** Check if a directory exists and contains at least one file (recursively) */
 function hasContent(dir) {
     if (!existsSync(dir))