swarmkit 0.0.2 → 0.0.4

package/dist/packages/setup.js

@@ -1,48 +1,146 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, symlinkSync, writeFileSync, } from "node:fs";
 import { basename, join } from "node:path";
 import { homedir } from "node:os";
 const execFileAsync = promisify(execFile);
 // ─── Project-level setup ─────────────────────────────────────────────────────
-/** Config directories each package creates at the project level */
+/** Root directory for all swarmkit project-level config */
+export const PROJECT_ROOT = ".swarm";
+/** Config directories with .swarm/ prefix (default layout) */
 export const PROJECT_CONFIG_DIRS = {
+    opentasks: ".swarm/opentasks",
+    minimem: ".swarm/minimem",
+    "cognitive-core": ".swarm/cognitive-core",
+    "skill-tree": ".swarm/skilltree",
+    "self-driving-repo": ".swarm/self-driving",
+    openteams: ".swarm/openteams",
+    sessionlog: ".swarm/sessionlog",
+    "claude-code-swarm": ".swarm/claude-swarm",
+};
+/** Config directories without prefix (flat layout, --no-prefix) */
+export const FLAT_PROJECT_CONFIG_DIRS = {
     opentasks: ".opentasks",
     minimem: ".minimem",
     "cognitive-core": ".cognitive-core",
-    "macro-agent": ".multiagent",
+    "skill-tree": ".skilltree",
     "self-driving-repo": ".self-driving",
+    openteams: ".openteams",
+    sessionlog: ".sessionlog",
+    "claude-code-swarm": ".claude-swarm",
 };
+/** Get config dirs for the given mode */
+export function projectConfigDirs(usePrefix) {
+    return usePrefix ? PROJECT_CONFIG_DIRS : FLAT_PROJECT_CONFIG_DIRS;
+}
 /**
  * Project-level packages in correct init order.
- * Order matters: minimem before cognitive-core (runtime detection),
- * opentasks before macro-agent (task backend wiring).
+ * Order matters: minimem before cognitive-core (runtime detection).
  */
 export const PROJECT_INIT_ORDER = [
     "opentasks",
     "minimem",
     "cognitive-core",
-    "macro-agent",
+    "skill-tree",
     "self-driving-repo",
+    "openteams",
+    "sessionlog",
+    "claude-code-swarm",
 ];
-/** Check whether a package is already initialized in a project */
+/** Check whether a package is already initialized in a project (checks both layouts) */
 export function isProjectInit(cwd, pkg) {
-    const dir = PROJECT_CONFIG_DIRS[pkg];
-    return dir ? existsSync(join(cwd, dir)) : false;
+    const prefixed = PROJECT_CONFIG_DIRS[pkg];
+    const flat = FLAT_PROJECT_CONFIG_DIRS[pkg];
+    return (prefixed ? existsSync(join(cwd, prefixed)) : false) ||
+        (flat ? existsSync(join(cwd, flat)) : false);
+}
+/** Ensure the .swarm/ project root directory exists */
+function ensureProjectRoot(cwd) {
+    const root = join(cwd, PROJECT_ROOT);
+    if (!existsSync(root)) {
+        mkdirSync(root, { recursive: true });
+    }
+}
+/**
+ * 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.
+ */
+function relocate(cwd, legacyName, targetName) {
+    const src = join(cwd, legacyName);
+    const dest = join(cwd, PROJECT_ROOT, targetName);
+    // Move the directory if it was created at the legacy location
+    if (existsSync(src) && !isSymlink(src) && !existsSync(dest)) {
+        try {
+            renameSync(src, dest);
+        }
+        catch {
+            return; // 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 {
+        return lstatSync(path).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
 }
 /** Initialize a single project-level package */
 export async function initProjectPackage(pkg, ctx) {
+    if (ctx.usePrefix) {
+        ensureProjectRoot(ctx.cwd);
+    }
     switch (pkg) {
-        case "opentasks":
-            return shellInit("opentasks", ["init", "--name", getProjectName(ctx.cwd)], ctx.cwd);
+        case "opentasks": {
+            const result = await shellInit("opentasks", ["init", "--name", getProjectName(ctx.cwd)], ctx.cwd, ctx.usePrefix
+                ? { OPENTASKS_PROJECT_DIR: join(PROJECT_ROOT, "opentasks") }
+                : undefined);
+            // 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, ".opentasks", "opentasks");
+            return result;
+        }
         case "minimem":
             return initMinimem(ctx);
-        case "cognitive-core":
-            return shellInit("cognitive-core", ["init"], ctx.cwd);
-        case "macro-agent":
-            return initMacroAgent(ctx);
+        case "cognitive-core": {
+            const result = await shellInit("cognitive-core", ["init"], ctx.cwd, ctx.usePrefix
+                ? { COGNITIVE_CORE_HOME: join(ctx.cwd, PROJECT_ROOT, "cognitive-core") }
+                : undefined);
+            if (ctx.usePrefix)
+                relocate(ctx.cwd, ".cognitive-core", "cognitive-core");
+            return result;
+        }
+        case "skill-tree":
+            return initSkillTreeProject(ctx);
         case "self-driving-repo":
-            return shellInit("sdr", ["init", "-t", "triage-only"], ctx.cwd);
+            return initSdr(ctx);
+        case "openteams":
+            return initOpenteamsProject(ctx);
+        case "sessionlog":
+            return initSessionlogProject(ctx);
+        case "claude-code-swarm":
+            return initClaudeSwarmProject(ctx);
         default:
             return { package: pkg, success: false, message: "Unknown package" };
     }
@@ -50,9 +148,7 @@ export async function initProjectPackage(pkg, ctx) {
 // ─── Global-level setup ──────────────────────────────────────────────────────
 /** Config directories for global packages (relative to homedir) */
 export const GLOBAL_CONFIG_DIRS = {
-    "agent-iam": ".agent-credentials",
     "skill-tree": ".skill-tree",
-    openswarm: ".openswarm",
     openhive: ".openhive",
 };
 /** Check whether a global package is already configured */
@@ -65,12 +161,8 @@ export function isGlobalInit(pkg) {
 /** Initialize a single global package */
 export async function initGlobalPackage(pkg, ctx, openhiveOpts) {
     switch (pkg) {
-        case "agent-iam":
-            return initAgentIam(ctx);
         case "skill-tree":
             return initSkillTree();
-        case "openswarm":
-            return initOpenswarm(ctx);
         case "openhive":
             return openhiveOpts
                 ? initOpenhive(openhiveOpts)
@@ -83,6 +175,8 @@ export async function initGlobalPackage(pkg, ctx, openhiveOpts) {
             return { package: "openteams", success: true, message: "no setup required" };
         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" };
         default:
             return { package: pkg, success: false, message: "Unknown package" };
     }
@@ -97,10 +191,13 @@ function cleanEnv() {
     return env;
 }
 /** Shell out to a package's CLI init command */
-async function shellInit(command, args, cwd) {
+async function shellInit(command, args, cwd, envOverrides) {
     const pkg = command === "sdr" ? "self-driving-repo" : command;
     try {
-        await execFileAsync(command, args, { cwd, timeout: 30_000, env: cleanEnv() });
+        const env = envOverrides
+            ? { ...cleanEnv(), ...envOverrides }
+            : cleanEnv();
+        await execFileAsync(command, args, { cwd, timeout: 30_000, env });
         return { package: pkg, success: true };
     }
     catch (err) {
@@ -108,15 +205,25 @@ async function shellInit(command, args, cwd) {
     }
 }
 async function initMinimem(ctx) {
+    const targetDir = ctx.usePrefix
+        ? join(ctx.cwd, PROJECT_ROOT, "minimem")
+        : join(ctx.cwd, ".minimem");
     try {
         await execFileAsync("minimem", ["init"], {
             cwd: ctx.cwd,
             timeout: 30_000,
-            env: cleanEnv(),
+            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");
+        }
         // Patch embedding provider if configured
         if (ctx.embeddingProvider && ctx.embeddingProvider !== "local") {
-            const configPath = join(ctx.cwd, ".minimem", "config.json");
+            const configPath = join(targetDir, "config.json");
             if (existsSync(configPath)) {
                 try {
                     const config = JSON.parse(readFileSync(configPath, "utf-8"));
@@ -135,65 +242,71 @@ async function initMinimem(ctx) {
         return { package: "minimem", success: false, message: formatError(err) };
     }
 }
-async function initMacroAgent(ctx) {
+async function initSdr(ctx) {
+    const result = await shellInit("sdr", ["init", "-t", "triage-only"], ctx.cwd, ctx.usePrefix
+        ? { SDR_CONFIG_DIR: join(PROJECT_ROOT, "self-driving") }
+        : undefined);
+    // 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, ".self-driving", "self-driving");
+    }
+    return result;
+}
+async function initSkillTreeProject(ctx) {
     try {
-        const configDir = join(ctx.cwd, ".multiagent");
-        mkdirSync(configDir, { recursive: true });
-        const config = {
-            team: "default",
-            port: 3001,
-            host: "localhost",
+        const targetDir = ctx.usePrefix
+            ? join(ctx.cwd, PROJECT_ROOT, "skilltree")
+            : join(ctx.cwd, ".skilltree");
+        mkdirSync(targetDir, { recursive: true });
+        mkdirSync(join(targetDir, "skills"), { recursive: true });
+        return { package: "skill-tree", success: true };
+    }
+    catch (err) {
+        return {
+            package: "skill-tree",
+            success: false,
+            message: formatError(err),
         };
-        // Wire up opentasks if selected
-        if (ctx.packages.includes("opentasks")) {
-            config.task = {
-                backend: "opentasks",
-                opentasks: { auto_start: true },
-            };
+    }
+}
+async function initOpenteamsProject(ctx) {
+    try {
+        const targetDir = ctx.usePrefix
+            ? join(ctx.cwd, PROJECT_ROOT, "openteams")
+            : join(ctx.cwd, ".openteams");
+        mkdirSync(targetDir, { recursive: true });
+        // Write default config.json (matches `openteams template init` with no options)
+        const configPath = join(targetDir, "config.json");
+        if (!existsSync(configPath)) {
+            writeFileSync(configPath, JSON.stringify({}, null, 2) + "\n");
         }
-        writeFileSync(join(configDir, "config.json"), JSON.stringify(config, null, 2) + "\n");
-        return { package: "macro-agent", success: true };
+        return { package: "openteams", success: true };
     }
     catch (err) {
         return {
-            package: "macro-agent",
+            package: "openteams",
             success: false,
             message: formatError(err),
         };
     }
 }
-async function initAgentIam(ctx) {
+async function initSessionlogProject(ctx) {
     try {
-        const credDir = join(homedir(), ".agent-credentials");
-        if (!existsSync(credDir)) {
-            mkdirSync(credDir, { recursive: true, mode: 0o700 });
-        }
-        // Register stored API keys with agent-iam
-        const env = { ...cleanEnv(), HOME: homedir() };
-        for (const [provider, key] of Object.entries(ctx.apiKeys)) {
-            if (["anthropic", "openai", "gemini"].includes(provider)) {
-                try {
-                    await execFileAsync("agent-iam", [
-                        "apikey",
-                        "add",
-                        "--name",
-                        provider,
-                        "--provider",
-                        provider,
-                        "--key",
-                        key,
-                    ], { timeout: 15_000, env });
-                }
-                catch {
-                    // Non-fatal — agent-iam CLI may not be fully installed yet
-                }
-            }
+        const targetDir = ctx.usePrefix
+            ? join(ctx.cwd, PROJECT_ROOT, "sessionlog")
+            : join(ctx.cwd, ".sessionlog");
+        mkdirSync(targetDir, { recursive: true });
+        // Write default settings.json
+        const settingsPath = join(targetDir, "settings.json");
+        if (!existsSync(settingsPath)) {
+            writeFileSync(settingsPath, JSON.stringify({ enabled: false, strategy: "manual-commit" }, null, 2) + "\n");
         }
-        return { package: "agent-iam", success: true };
+        return { package: "sessionlog", success: true };
     }
     catch (err) {
         return {
-            package: "agent-iam",
+            package: "sessionlog",
             success: false,
             message: formatError(err),
         };
@@ -224,40 +337,6 @@ async function initSkillTree() {
         };
     }
 }
-async function initOpenswarm(ctx) {
-    const configDir = join(homedir(), ".openswarm");
-    const configPath = join(configDir, "server.json");
-    if (existsSync(configPath)) {
-        return {
-            package: "openswarm",
-            success: true,
-            message: "already configured",
-        };
-    }
-    try {
-        mkdirSync(configDir, { recursive: true });
-        const config = {
-            host: "localhost",
-            port: 3000,
-            auth: { mode: "none" },
-            storage: { type: "memory" },
-            logging: { level: "info" },
-        };
-        // Configure macro-agent adapter if installed
-        if (ctx.packages.includes("macro-agent")) {
-            config.adapter = { id: "macro-agent" };
-        }
-        writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-        return { package: "openswarm", success: true };
-    }
-    catch (err) {
-        return {
-            package: "openswarm",
-            success: false,
-            message: formatError(err),
-        };
-    }
-}
 async function initOpenhive(opts) {
     try {
         const args = [
@@ -286,6 +365,32 @@ async function initOpenhive(opts) {
         };
     }
 }
+async function initClaudeSwarmProject(ctx) {
+    try {
+        const targetDir = ctx.usePrefix
+            ? join(ctx.cwd, PROJECT_ROOT, "claude-swarm")
+            : join(ctx.cwd, ".claude-swarm");
+        mkdirSync(targetDir, { recursive: true });
+        // Write default config.json
+        const configPath = join(targetDir, "config.json");
+        if (!existsSync(configPath)) {
+            writeFileSync(configPath, JSON.stringify({}, null, 2) + "\n");
+        }
+        // Write .gitignore for tmp/
+        const gitignorePath = join(targetDir, ".gitignore");
+        if (!existsSync(gitignorePath)) {
+            writeFileSync(gitignorePath, "tmp/\n");
+        }
+        return { package: "claude-code-swarm", success: true };
+    }
+    catch (err) {
+        return {
+            package: "claude-code-swarm",
+            success: false,
+            message: formatError(err),
+        };
+    }
+}
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 function getProjectName(cwd) {
     const pkgPath = join(cwd, "package.json");