swarmkit 0.0.1 → 0.0.3

package/dist/packages/setup.js

@@ -0,0 +1,414 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+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 ─────────────────────────────────────────────────────
+/** 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",
+    "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).
+ */
+export const PROJECT_INIT_ORDER = [
+    "opentasks",
+    "minimem",
+    "cognitive-core",
+    "skill-tree",
+    "self-driving-repo",
+    "openteams",
+    "sessionlog",
+    "claude-code-swarm",
+];
+/** Check whether a package is already initialized in a project (checks both layouts) */
+export function isProjectInit(cwd, pkg) {
+    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": {
+            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": {
+            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 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" };
+    }
+}
+// ─── Global-level setup ──────────────────────────────────────────────────────
+/** Config directories for global packages (relative to homedir) */
+export const GLOBAL_CONFIG_DIRS = {
+    "skill-tree": ".skill-tree",
+    openhive: ".openhive",
+};
+/** Check whether a global package is already configured */
+export function isGlobalInit(pkg) {
+    const dir = GLOBAL_CONFIG_DIRS[pkg];
+    if (!dir)
+        return false;
+    return existsSync(join(homedir(), dir));
+}
+/** Initialize a single global package */
+export async function initGlobalPackage(pkg, ctx, openhiveOpts) {
+    switch (pkg) {
+        case "skill-tree":
+            return initSkillTree();
+        case "openhive":
+            return openhiveOpts
+                ? initOpenhive(openhiveOpts)
+                : {
+                    package: "openhive",
+                    success: false,
+                    message: "No openhive options provided",
+                };
+        case "openteams":
+            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" };
+    }
+}
+// ─── Package-specific init functions ─────────────────────────────────────────
+/** Build a clean env for child processes (strips test-runner vars like VITEST) */
+function cleanEnv() {
+    const env = { ...process.env };
+    delete env.VITEST;
+    delete env.VITEST_POOL_ID;
+    delete env.VITEST_WORKER_ID;
+    return env;
+}
+/** Shell out to a package's CLI init command */
+async function shellInit(command, args, cwd, envOverrides) {
+    const pkg = command === "sdr" ? "self-driving-repo" : command;
+    try {
+        const env = envOverrides
+            ? { ...cleanEnv(), ...envOverrides }
+            : cleanEnv();
+        await execFileAsync(command, args, { cwd, timeout: 30_000, env });
+        return { package: pkg, success: true };
+    }
+    catch (err) {
+        return { package: pkg, success: false, message: formatError(err) };
+    }
+}
+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: 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(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
+                }
+            }
+        }
+        return { package: "minimem", success: true };
+    }
+    catch (err) {
+        return { package: "minimem", success: false, message: formatError(err) };
+    }
+}
+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 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),
+        };
+    }
+}
+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");
+        }
+        return { package: "openteams", success: true };
+    }
+    catch (err) {
+        return {
+            package: "openteams",
+            success: false,
+            message: formatError(err),
+        };
+    }
+}
+async function initSessionlogProject(ctx) {
+    try {
+        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: "sessionlog", success: true };
+    }
+    catch (err) {
+        return {
+            package: "sessionlog",
+            success: false,
+            message: formatError(err),
+        };
+    }
+}
+async function initSkillTree() {
+    const configPath = join(homedir(), ".skill-tree", "config.yaml");
+    if (existsSync(configPath)) {
+        return {
+            package: "skill-tree",
+            success: true,
+            message: "already configured",
+        };
+    }
+    try {
+        const env = { ...cleanEnv(), HOME: homedir() };
+        await execFileAsync("skill-tree", ["config", "init"], {
+            timeout: 15_000,
+            env,
+        });
+        return { package: "skill-tree", success: true };
+    }
+    catch (err) {
+        return {
+            package: "skill-tree",
+            success: false,
+            message: formatError(err),
+        };
+    }
+}
+async function initOpenhive(opts) {
+    try {
+        const args = [
+            "init",
+            "--name",
+            opts.name,
+            "--port",
+            String(opts.port),
+            "--auth-mode",
+            opts.authMode,
+            "--verification",
+            opts.verification,
+        ];
+        if (opts.dataDir) {
+            args.unshift("--data-dir", opts.dataDir);
+        }
+        const env = { ...cleanEnv(), HOME: homedir() };
+        await execFileAsync("openhive", args, { timeout: 60_000, env });
+        return { package: "openhive", success: true };
+    }
+    catch (err) {
+        return {
+            package: "openhive",
+            success: false,
+            message: formatError(err),
+        };
+    }
+}
+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");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            if (typeof pkg.name === "string" && pkg.name)
+                return pkg.name;
+        }
+        catch {
+            // Fall through
+        }
+    }
+    return basename(cwd) || "project";
+}
+function formatError(err) {
+    if (err instanceof Error) {
+        return err.message.split("\n")[0];
+    }
+    return String(err);
+}

package/dist/packages/setup.test.d.ts

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