swarmkit 0.0.5 → 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, symlinkSync, writeFileSync, } from "node:fs";
+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).
@@ -63,9 +170,9 @@ function ensureProjectRoot(cwd) {
 }
 /**
  * After init, relocate a package's config dir into .swarm/ if the CLI
- * created it at the legacy top-level location, then leave a symlink at
- * the old path so the package can still find its data at runtime.
- * This is a no-op when the package already respects its env-var override.
+ * created it at the legacy top-level location.
+ * All supported packages natively check .swarm/<pkg> before .<pkg>,
+ * so no symlink is needed.
  */
 function relocate(cwd, legacyName, targetName) {
     const src = join(cwd, legacyName);
@@ -76,26 +183,9 @@ function relocate(cwd, legacyName, targetName) {
             renameSync(src, dest);
         }
         catch {
-            return; // Non-fatal — leave in legacy location
+            // Non-fatal — leave in legacy location
         }
     }
-    // Create a symlink at the legacy location so packages find their data
-    ensureSymlink(cwd, legacyName, targetName);
-}
-/** Create a relative symlink: cwd/<legacyName> → .swarm/<targetName> */
-function ensureSymlink(cwd, legacyName, targetName) {
-    const link = join(cwd, legacyName);
-    const target = join(PROJECT_ROOT, targetName); // relative path
-    if (isSymlink(link))
-        return; // Already symlinked
-    if (existsSync(link))
-        return; // Real directory exists — don't overwrite
-    try {
-        symlinkSync(target, link);
-    }
-    catch {
-        // Non-fatal — package can still be configured via env var
-    }
 }
 function isSymlink(path) {
     try {
@@ -119,6 +209,10 @@ export async function initProjectPackage(pkg, ctx) {
             // for packages that create directly in .swarm/, this is a no-op.
             if (ctx.usePrefix)
                 relocate(ctx.cwd, ".opentasks", "opentasks");
+            // Older opentasks versions write .gitattributes at the project root.
+            // Newer versions write it inside the opentasks dir. Clean up the
+            // root-level file as a backwards-compat fallback.
+            cleanupGitattributes(ctx.cwd);
             return result;
         }
         case "minimem":
@@ -150,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) {
@@ -176,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" };
     }
@@ -206,44 +301,65 @@ async function shellInit(command, args, cwd, envOverrides) {
 }
 async function initMinimem(ctx) {
     const targetDir = ctx.usePrefix
-        ? join(ctx.cwd, PROJECT_ROOT, "minimem")
-        : join(ctx.cwd, ".minimem");
+        ? join(PROJECT_ROOT, "minimem")
+        : ".minimem";
+    const absTarget = join(ctx.cwd, targetDir);
+    // Try CLI init first (creates contained layout in newer versions)
+    const result = await shellInit("minimem", ["init", targetDir], ctx.cwd);
+    // Verify the CLI created the contained layout (config.json at root).
+    // Older minimem versions create a nested .minimem/ subdir instead.
+    if (!existsSync(join(absTarget, "config.json"))) {
+        initMinimemInline(absTarget);
+    }
+    // Patch config with wizard choices
+    const configPath = join(absTarget, "config.json");
     try {
-        await execFileAsync("minimem", ["init"], {
-            cwd: ctx.cwd,
-            timeout: 30_000,
-            env: ctx.usePrefix
-                ? { ...cleanEnv(), MINIMEM_CONFIG_DIR: join(PROJECT_ROOT, "minimem") }
-                : cleanEnv(),
-        });
-        // relocate handles packages that don't yet respect the env var;
-        // for packages that create directly in .swarm/, this is a no-op.
-        if (ctx.usePrefix) {
-            relocate(ctx.cwd, ".minimem", "minimem");
+        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 };
         }
-        // Patch embedding provider if configured
-        if (ctx.embeddingProvider && ctx.embeddingProvider !== "local") {
-            const configPath = join(targetDir, "config.json");
-            if (existsSync(configPath)) {
-                try {
-                    const config = JSON.parse(readFileSync(configPath, "utf-8"));
-                    config.embedding = config.embedding || {};
-                    config.embedding.provider = ctx.embeddingProvider;
-                    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-                }
-                catch {
-                    // Non-fatal — user can configure manually
-                }
-            }
+        // Apply per-package config overrides from the interactive config phase
+        const overrides = ctx.packageConfigs?.minimem?.values;
+        if (overrides) {
+            applyNestedOverrides(config, overrides);
         }
-        return { package: "minimem", success: true };
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
     }
-    catch (err) {
-        return { package: "minimem", success: false, message: formatError(err) };
+    catch {
+        // Non-fatal
+    }
+    return { package: "minimem", success: true };
+}
+/** Fallback: create contained layout inline when CLI is unavailable or outdated */
+function initMinimemInline(targetDir) {
+    mkdirSync(targetDir, { recursive: true });
+    mkdirSync(join(targetDir, "memory"), { recursive: true });
+    const configPath = join(targetDir, "config.json");
+    if (!existsSync(configPath)) {
+        writeFileSync(configPath, JSON.stringify({
+            embedding: { provider: "auto" },
+            hybrid: { enabled: true, vectorWeight: 0.7, textWeight: 0.3 },
+            query: { maxResults: 10, minScore: 0.3 },
+        }, null, 2) + "\n");
+    }
+    const memoryPath = join(targetDir, "MEMORY.md");
+    if (!existsSync(memoryPath)) {
+        writeFileSync(memoryPath, "# Memory\n\nAdd notes, decisions, and context here.\n");
+    }
+    const gitignorePath = join(targetDir, ".gitignore");
+    if (!existsSync(gitignorePath)) {
+        writeFileSync(gitignorePath, "index.db\nindex.db-*\n");
     }
 }
 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;
@@ -312,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 = {
@@ -322,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) {
@@ -387,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
@@ -410,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/
@@ -428,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))
@@ -446,6 +674,33 @@ function hasContent(dir) {
         return false;
     }
 }
+/**
+ * Remove root-level .gitattributes created by older opentasks versions.
+ * Newer versions write .gitattributes inside the opentasks directory.
+ */
+function cleanupGitattributes(cwd) {
+    const attrPath = join(cwd, ".gitattributes");
+    if (!existsSync(attrPath))
+        return;
+    try {
+        const content = readFileSync(attrPath, "utf-8");
+        const cleaned = content
+            .split("\n")
+            .filter((line) => !line.includes("merge=opentasks") &&
+            !line.includes("OpenTasks merge driver"))
+            .join("\n")
+            .trim();
+        if (!cleaned) {
+            unlinkSync(attrPath);
+        }
+        else {
+            writeFileSync(attrPath, cleaned + "\n");
+        }
+    }
+    catch {
+        // Non-fatal
+    }
+}
 function getProjectName(cwd) {
     const pkgPath = join(cwd, "package.json");
     if (existsSync(pkgPath)) {