swarmkit 0.0.5 → 0.0.6

package/dist/packages/setup.js

@@ -1,6 +1,6 @@
 import { execFile } 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);
@@ -63,9 +63,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 +76,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 +102,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":
@@ -206,40 +193,52 @@ 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");
-    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");
+        ? 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 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"));
+            config.embedding = { ...config.embedding, provider };
+            writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
         }
-        // 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
-                }
-            }
+        catch {
+            // Non-fatal
         }
-        return { package: "minimem", success: true };
     }
-    catch (err) {
-        return { package: "minimem", success: false, message: formatError(err) };
+    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) {
@@ -446,6 +445,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)) {

package/dist/packages/setup.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { mkdirSync, rmSync, existsSync, lstatSync, readFileSync, readlinkSync, writeFileSync, realpathSync, } from "node:fs";
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync, realpathSync, } from "node:fs";
 import { join, basename } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -152,7 +152,7 @@ describe("isGlobalInit", () => {
 // ─── Project: opentasks (real CLI) ───────────────────────────────────────────
 describe("initProjectPackage — opentasks (real CLI)", async () => {
     const installed = await hasCliInstalled("opentasks");
-    it.skipIf(!installed)("runs opentasks init, relocates to .swarm/, and creates symlink", async () => {
+    it.skipIf(!installed)("runs opentasks init and relocates to .swarm/", async () => {
         createProject("test-opentasks");
         const result = await initProjectPackage("opentasks", projectCtx({ cwd: testDir, packages: ["opentasks"] }));
         expect(result.success).toBe(true);
@@ -162,12 +162,10 @@ describe("initProjectPackage — opentasks (real CLI)", async () => {
         expect(existsSync(join(testDir, ".swarm", "opentasks", "config.json"))).toBe(true);
         expect(existsSync(join(testDir, ".swarm", "opentasks", "graph.jsonl"))).toBe(true);
         expect(existsSync(join(testDir, ".swarm", "opentasks", ".gitignore"))).toBe(true);
-        // Verify symlink at legacy location
-        const link = join(testDir, ".opentasks");
-        expect(lstatSync(link).isSymbolicLink()).toBe(true);
-        expect(readlinkSync(link)).toBe(".swarm/opentasks");
-        // Accessible via symlink
-        expect(existsSync(join(testDir, ".opentasks", "config.json"))).toBe(true);
+        // No symlink at legacy location (packages natively check .swarm/)
+        expect(existsSync(join(testDir, ".opentasks"))).toBe(false);
+        // .gitattributes should be cleaned up (merge driver creates it at root)
+        expect(existsSync(join(testDir, ".gitattributes"))).toBe(false);
         // Verify config content
         const config = JSON.parse(readFileSync(join(testDir, ".swarm", "opentasks", "config.json"), "utf-8"));
         expect(config.version).toBe("1.0");
@@ -189,24 +187,30 @@ describe("initProjectPackage — opentasks (real CLI)", async () => {
         expect(config.location.name).toBe(basename(testDir));
     });
 });
-// ─── Project: minimem (real CLI) + embedding patching ────────────────────────
-describe("initProjectPackage — minimem (real CLI)", async () => {
-    const installed = await hasCliInstalled("minimem");
-    it.skipIf(!installed)("runs minimem init and creates .minimem/", async () => {
+// ─── Project: minimem (CLI with inline fallback) ─────────────────────────────
+describe("initProjectPackage — minimem", () => {
+    it("creates all artifacts inside .swarm/minimem/", async () => {
         createProject("test-minimem");
         const result = await initProjectPackage("minimem", projectCtx({ cwd: testDir, packages: ["minimem"] }));
         expect(result.success).toBe(true);
-        // Verify real filesystem artifacts
+        // Core artifacts inside .swarm/minimem/
         expect(existsSync(join(testDir, ".swarm", "minimem"))).toBe(true);
         expect(existsSync(join(testDir, ".swarm", "minimem", "config.json"))).toBe(true);
         expect(existsSync(join(testDir, ".swarm", "minimem", ".gitignore"))).toBe(true);
-        expect(existsSync(join(testDir, "MEMORY.md"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "minimem", "MEMORY.md"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "minimem", "memory"))).toBe(true);
+        // Nothing at project root
+        expect(existsSync(join(testDir, "MEMORY.md"))).toBe(false);
+        expect(existsSync(join(testDir, "memory"))).toBe(false);
         // Verify default config
         const config = JSON.parse(readFileSync(join(testDir, ".swarm", "minimem", "config.json"), "utf-8"));
         expect(config.embedding.provider).toBe("auto");
         expect(config.hybrid.enabled).toBe(true);
+        // Verify .gitignore content
+        const gitignore = readFileSync(join(testDir, ".swarm", "minimem", ".gitignore"), "utf-8");
+        expect(gitignore).toContain("index.db");
     });
-    it.skipIf(!installed)("patches embedding.provider to openai", async () => {
+    it("sets embedding.provider to openai", async () => {
         createProject("test-embed");
         await initProjectPackage("minimem", projectCtx({
             cwd: testDir,
@@ -215,11 +219,8 @@ describe("initProjectPackage — minimem (real CLI)", async () => {
         }));
         const config = JSON.parse(readFileSync(join(testDir, ".swarm", "minimem", "config.json"), "utf-8"));
         expect(config.embedding.provider).toBe("openai");
-        // Other fields preserved
-        expect(config.hybrid.enabled).toBe(true);
-        expect(config.query.maxResults).toBe(10);
     });
-    it.skipIf(!installed)("patches embedding.provider to gemini", async () => {
+    it("sets embedding.provider to gemini", async () => {
         createProject("test-embed-gemini");
         await initProjectPackage("minimem", projectCtx({
             cwd: testDir,
@@ -229,7 +230,7 @@ describe("initProjectPackage — minimem (real CLI)", async () => {
         const config = JSON.parse(readFileSync(join(testDir, ".swarm", "minimem", "config.json"), "utf-8"));
         expect(config.embedding.provider).toBe("gemini");
     });
-    it.skipIf(!installed)("does NOT patch when provider is local", async () => {
+    it("uses 'auto' when provider is local", async () => {
         createProject("test-local");
         await initProjectPackage("minimem", projectCtx({
             cwd: testDir,
@@ -239,7 +240,7 @@ describe("initProjectPackage — minimem (real CLI)", async () => {
         const config = JSON.parse(readFileSync(join(testDir, ".swarm", "minimem", "config.json"), "utf-8"));
         expect(config.embedding.provider).toBe("auto");
     });
-    it.skipIf(!installed)("does NOT patch when provider is null", async () => {
+    it("uses 'auto' when provider is null", async () => {
         createProject("test-null");
         await initProjectPackage("minimem", projectCtx({
             cwd: testDir,
@@ -552,8 +553,7 @@ describe("initGlobalPackage — unknown", () => {
 // ─── E2E: full project init flow (solo bundle) ──────────────────────────────
 describe("e2e: project init — solo bundle", async () => {
     const opentasksOk = await hasCliInstalled("opentasks");
-    const minimemOk = await hasCliInstalled("minimem");
-    const allOk = opentasksOk && minimemOk;
+    const allOk = opentasksOk; // minimem init is inline (no CLI needed)
     it.skipIf(!allOk)("initializes opentasks → minimem with cross-wiring", async () => {
         createProject("solo-e2e");
         const ctx = projectCtx({
@@ -614,9 +614,8 @@ describe("e2e: project init — solo bundle", async () => {
 // ─── E2E: full project init flow (team bundle — init order) ─────────────────
 describe("e2e: project init — team bundle (init order)", async () => {
     const opentasksOk = await hasCliInstalled("opentasks");
-    const minimemOk = await hasCliInstalled("minimem");
     const ccOk = await hasCliInstalled("cognitive-core");
-    const allOk = opentasksOk && minimemOk && ccOk;
+    const allOk = opentasksOk && ccOk; // minimem init is inline (no CLI needed)
     it.skipIf(!allOk)("cognitive-core runs after minimem (can detect .minimem/)", async () => {
         createProject("team-e2e");
         const ctx = projectCtx({
@@ -845,9 +844,8 @@ describe("flow: plugin bootstrap — init project dirs via swarmkit", () => {
     });
 });
 // ─── E2E: embedding provider propagation ─────────────────────────────────────
-describe("e2e: embedding provider propagation", async () => {
-    const minimemOk = await hasCliInstalled("minimem");
-    it.skipIf(!minimemOk)("openai embedding flows through to real minimem config", async () => {
+describe("e2e: embedding provider propagation", () => {
+    it("openai embedding flows through to minimem config", async () => {
         createProject("embed-e2e");
         await initProjectPackage("minimem", projectCtx({
             cwd: testDir,
@@ -857,7 +855,6 @@ describe("e2e: embedding provider propagation", async () => {
         }));
         const config = JSON.parse(readFileSync(join(testDir, ".swarm", "minimem", "config.json"), "utf-8"));
         expect(config.embedding.provider).toBe("openai");
-        // Real minimem config has these fields too
         expect(config.hybrid).toBeDefined();
         expect(config.query).toBeDefined();
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarmkit",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Multi-agent infa toolkit",
   "type": "module",
   "main": "dist/index.js",