swarmkit 0.0.5 → 0.0.7

package/dist/commands/configure/configure.test.js

@@ -0,0 +1,539 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync, realpathSync, } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { execFile, execSync } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+// ─── Minimal mocking ────────────────────────────────────────────────────────
+// Only mock homedir — everything else (filesystem, CLI shell-outs) is real.
+// ─────────────────────────────────────────────────────────────────────────────
+let testHome;
+vi.mock("node:os", async () => {
+    const actual = await import("node:os");
+    return { ...actual, homedir: () => testHome };
+});
+const { readPackageConfig, getNestedValue } = await import("./read-config.js");
+const { initProjectPackage, initGlobalPackage, isProjectInit, PROJECT_CONFIG_DIRS, GLOBAL_CONFIG_DIRS, runPackageWizard, } = await import("../../packages/setup.js");
+import { createEmptyState } from "../init/state.js";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+let testDir;
+beforeEach(() => {
+    const realTmp = realpathSync(tmpdir());
+    testDir = join(realTmp, `swarmkit-configure-test-${randomUUID()}`);
+    testHome = join(realTmp, `swarmkit-configure-home-${randomUUID()}`);
+    mkdirSync(testDir, { recursive: true });
+    mkdirSync(testHome, { recursive: true });
+});
+afterEach(() => {
+    rmSync(testDir, { recursive: true, force: true });
+    rmSync(testHome, { recursive: true, force: true });
+});
+async function hasCliInstalled(command) {
+    try {
+        await execFileAsync("which", [command]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function createProject(name, dir = testDir) {
+    execSync("git init -q", { cwd: dir });
+    writeFileSync(join(dir, "package.json"), JSON.stringify({ name, version: "1.0.0" }));
+    return dir;
+}
+function projectCtx(overrides = {}) {
+    return {
+        cwd: overrides.cwd ?? testDir,
+        packages: overrides.packages ?? [],
+        embeddingProvider: overrides.embeddingProvider ?? null,
+        apiKeys: overrides.apiKeys ?? {},
+        usePrefix: overrides.usePrefix ?? true,
+        packageConfigs: overrides.packageConfigs,
+    };
+}
+function globalCtx(overrides = {}) {
+    return {
+        packages: overrides.packages ?? [],
+        embeddingProvider: overrides.embeddingProvider ?? null,
+        apiKeys: overrides.apiKeys ?? {},
+        packageConfigs: overrides.packageConfigs,
+    };
+}
+// ─── readPackageConfig ───────────────────────────────────────────────────────
+describe("readPackageConfig", () => {
+    it("returns null when no config exists", () => {
+        const result = readPackageConfig("minimem", testDir);
+        expect(result).toBeNull();
+    });
+    it("reads prefixed project config", () => {
+        const configDir = join(testDir, ".swarm", "minimem");
+        mkdirSync(configDir, { recursive: true });
+        writeFileSync(join(configDir, "config.json"), JSON.stringify({
+            embedding: { provider: "openai" },
+            hybrid: { vectorWeight: 0.8 },
+        }));
+        const result = readPackageConfig("minimem", testDir);
+        expect(result).not.toBeNull();
+        expect(result.embedding.provider).toBe("openai");
+        expect(result.hybrid.vectorWeight).toBe(0.8);
+    });
+    it("reads flat project config when prefixed doesn't exist", () => {
+        const configDir = join(testDir, ".minimem");
+        mkdirSync(configDir, { recursive: true });
+        writeFileSync(join(configDir, "config.json"), JSON.stringify({ embedding: { provider: "gemini" } }));
+        const result = readPackageConfig("minimem", testDir);
+        expect(result).not.toBeNull();
+        expect(result.embedding.provider).toBe("gemini");
+    });
+    it("prefers prefixed over flat when both exist", () => {
+        // Create both
+        mkdirSync(join(testDir, ".swarm", "minimem"), { recursive: true });
+        writeFileSync(join(testDir, ".swarm", "minimem", "config.json"), JSON.stringify({ embedding: { provider: "openai" } }));
+        mkdirSync(join(testDir, ".minimem"), { recursive: true });
+        writeFileSync(join(testDir, ".minimem", "config.json"), JSON.stringify({ embedding: { provider: "gemini" } }));
+        const result = readPackageConfig("minimem", testDir);
+        expect(result.embedding.provider).toBe("openai");
+    });
+    it("reads sessionlog settings.json instead of config.json", () => {
+        const configDir = join(testDir, ".swarm", "sessionlog");
+        mkdirSync(configDir, { recursive: true });
+        writeFileSync(join(configDir, "settings.json"), JSON.stringify({ enabled: true, strategy: "auto-commit" }));
+        const result = readPackageConfig("sessionlog", testDir);
+        expect(result).not.toBeNull();
+        expect(result.enabled).toBe(true);
+        expect(result.strategy).toBe("auto-commit");
+    });
+    it("reads global config for claude-code-swarm", () => {
+        const configDir = join(testHome, ".claude-swarm");
+        mkdirSync(configDir, { recursive: true });
+        writeFileSync(join(configDir, "config.json"), JSON.stringify({ map: { server: "ws://global:8080" } }));
+        const result = readPackageConfig("claude-code-swarm", testDir);
+        expect(result).not.toBeNull();
+        expect(result.map.server).toBe("ws://global:8080");
+    });
+    it("merges global + project config (project wins)", () => {
+        // Global config
+        const globalDir = join(testHome, ".claude-swarm");
+        mkdirSync(globalDir, { recursive: true });
+        writeFileSync(join(globalDir, "config.json"), JSON.stringify({
+            map: { server: "ws://global:8080", sidecar: "session" },
+            sessionlog: { enabled: false },
+        }));
+        // Project config (overrides map.server)
+        const projectDir = join(testDir, ".swarm", "claude-swarm");
+        mkdirSync(projectDir, { recursive: true });
+        writeFileSync(join(projectDir, "config.json"), JSON.stringify({
+            template: "gsd",
+            map: { server: "ws://project:9090", enabled: true },
+        }));
+        const result = readPackageConfig("claude-code-swarm", testDir);
+        expect(result).not.toBeNull();
+        // Project overrides global
+        expect(result.map.server).toBe("ws://project:9090");
+        expect(result.map.enabled).toBe(true);
+        // Global value preserved when not overridden
+        expect(result.map.sidecar).toBe("session");
+        // Global-only field preserved
+        expect(result.sessionlog.enabled).toBe(false);
+        // Project-only field preserved
+        expect(result.template).toBe("gsd");
+    });
+});
+// ─── getNestedValue ──────────────────────────────────────────────────────────
+describe("getNestedValue", () => {
+    const config = {
+        embedding: { provider: "openai" },
+        hybrid: { enabled: true, vectorWeight: 0.7, textWeight: 0.3 },
+        query: { maxResults: 10 },
+        simple: "value",
+    };
+    it("resolves top-level keys", () => {
+        expect(getNestedValue(config, "simple")).toBe("value");
+    });
+    it("resolves nested keys", () => {
+        expect(getNestedValue(config, "embedding.provider")).toBe("openai");
+        expect(getNestedValue(config, "hybrid.vectorWeight")).toBe(0.7);
+        expect(getNestedValue(config, "query.maxResults")).toBe(10);
+    });
+    it("returns undefined for missing keys", () => {
+        expect(getNestedValue(config, "missing")).toBeUndefined();
+        expect(getNestedValue(config, "embedding.missing")).toBeUndefined();
+        expect(getNestedValue(config, "deep.nested.missing")).toBeUndefined();
+    });
+});
+// ─── E2E: init → readPackageConfig cycle ─────────────────────────────────────
+describe("e2e: init then readPackageConfig — minimem", () => {
+    it("reads back minimem config after init with defaults", async () => {
+        createProject("read-mm");
+        await initProjectPackage("minimem", projectCtx({ cwd: testDir, packages: ["minimem"] }));
+        const config = readPackageConfig("minimem", testDir);
+        expect(config).not.toBeNull();
+        expect(getNestedValue(config, "embedding.provider")).toBe("auto");
+        expect(getNestedValue(config, "hybrid.vectorWeight")).toBe(0.7);
+        expect(getNestedValue(config, "hybrid.textWeight")).toBe(0.3);
+        expect(getNestedValue(config, "query.maxResults")).toBe(10);
+        expect(getNestedValue(config, "query.minScore")).toBe(0.3);
+    });
+    it("reads back minimem config after init with openai embedding", async () => {
+        createProject("read-mm-openai");
+        await initProjectPackage("minimem", projectCtx({
+            cwd: testDir,
+            packages: ["minimem"],
+            embeddingProvider: "openai",
+        }));
+        const config = readPackageConfig("minimem", testDir);
+        expect(getNestedValue(config, "embedding.provider")).toBe("openai");
+    });
+    it("reads back minimem config after init with packageConfigs overrides", async () => {
+        createProject("read-mm-overrides");
+        await initProjectPackage("minimem", projectCtx({
+            cwd: testDir,
+            packages: ["minimem"],
+            packageConfigs: {
+                minimem: {
+                    values: { "query.maxResults": "42", "hybrid.vectorWeight": "0.9" },
+                    usedCliWizard: false,
+                },
+            },
+        }));
+        const config = readPackageConfig("minimem", testDir);
+        expect(getNestedValue(config, "query.maxResults")).toBe(42);
+        expect(getNestedValue(config, "hybrid.vectorWeight")).toBe(0.9);
+        // Defaults preserved for non-overridden fields
+        expect(getNestedValue(config, "hybrid.textWeight")).toBe(0.3);
+    });
+});
+describe("e2e: init then readPackageConfig — sessionlog", () => {
+    it("reads back sessionlog settings after init with defaults", async () => {
+        await initProjectPackage("sessionlog", projectCtx({ cwd: testDir, packages: ["sessionlog"] }));
+        const config = readPackageConfig("sessionlog", testDir);
+        expect(config).not.toBeNull();
+        expect(config.enabled).toBe(false);
+        expect(config.strategy).toBe("manual-commit");
+        expect(config.logLevel).toBe("warn");
+        expect(config.summarizationEnabled).toBe(false);
+    });
+    it("reads back sessionlog settings after init with overrides", async () => {
+        await initProjectPackage("sessionlog", projectCtx({
+            cwd: testDir,
+            packages: ["sessionlog"],
+            packageConfigs: {
+                sessionlog: {
+                    values: { enabled: true, strategy: "auto-commit" },
+                    usedCliWizard: false,
+                },
+            },
+        }));
+        const config = readPackageConfig("sessionlog", testDir);
+        expect(config.enabled).toBe(true);
+        expect(config.strategy).toBe("auto-commit");
+        // Defaults for untouched fields
+        expect(config.logLevel).toBe("warn");
+    });
+});
+describe("e2e: init then readPackageConfig — claude-code-swarm", () => {
+    it("reads back project config after init", async () => {
+        await initProjectPackage("claude-code-swarm", projectCtx({ cwd: testDir, packages: ["claude-code-swarm"] }));
+        const config = readPackageConfig("claude-code-swarm", testDir);
+        expect(config).not.toBeNull();
+        expect(getNestedValue(config, "map.enabled")).toBe(false);
+        expect(getNestedValue(config, "map.server")).toBe("ws://localhost:8080");
+        expect(getNestedValue(config, "sessionlog.enabled")).toBe(false);
+    });
+    it("reads back project config after init with overrides", async () => {
+        await initProjectPackage("claude-code-swarm", projectCtx({
+            cwd: testDir,
+            packages: ["claude-code-swarm"],
+            packageConfigs: {
+                "claude-code-swarm": {
+                    values: {
+                        "map.enabled": true,
+                        "map.server": "ws://custom:9090",
+                        "sessionlog.enabled": true,
+                    },
+                    usedCliWizard: false,
+                },
+            },
+        }));
+        const config = readPackageConfig("claude-code-swarm", testDir);
+        expect(getNestedValue(config, "map.enabled")).toBe(true);
+        expect(getNestedValue(config, "map.server")).toBe("ws://custom:9090");
+        expect(getNestedValue(config, "sessionlog.enabled")).toBe(true);
+        // Defaults preserved
+        expect(getNestedValue(config, "map.systemId")).toBe("system-claude-swarm");
+    });
+    it("reads back global config after global init", async () => {
+        await initGlobalPackage("claude-code-swarm", globalCtx({ packages: ["claude-code-swarm"] }));
+        const config = readPackageConfig("claude-code-swarm", testDir);
+        expect(config).not.toBeNull();
+        expect(getNestedValue(config, "map.server")).toBe("");
+        expect(getNestedValue(config, "map.sidecar")).toBe("session");
+        expect(getNestedValue(config, "sessionlog.enabled")).toBe(false);
+    });
+    it("merges global + project config correctly", async () => {
+        // Init global first
+        await initGlobalPackage("claude-code-swarm", globalCtx({
+            packages: ["claude-code-swarm"],
+            packageConfigs: {
+                "claude-code-swarm": {
+                    values: { "map.server": "ws://global:8080" },
+                    usedCliWizard: false,
+                },
+            },
+        }));
+        // Init project with different overrides
+        await initProjectPackage("claude-code-swarm", projectCtx({
+            cwd: testDir,
+            packages: ["claude-code-swarm"],
+            packageConfigs: {
+                "claude-code-swarm": {
+                    values: { "map.enabled": true, "sessionlog.enabled": true },
+                    usedCliWizard: false,
+                },
+            },
+        }));
+        const config = readPackageConfig("claude-code-swarm", testDir);
+        // Project values
+        expect(getNestedValue(config, "map.enabled")).toBe(true);
+        expect(getNestedValue(config, "sessionlog.enabled")).toBe(true);
+        // Project default overrides global (project has ws://localhost:8080 default)
+        expect(getNestedValue(config, "map.server")).toBe("ws://localhost:8080");
+    });
+});
+// ─── E2E: init → patch → verify config cycle ────────────────────────────────
+describe("e2e: init → patch config → verify", () => {
+    it("patches minimem config in-place", async () => {
+        createProject("patch-mm");
+        // Initialize with defaults
+        await initProjectPackage("minimem", projectCtx({ cwd: testDir, packages: ["minimem"] }));
+        // Read the config file directly and patch it (simulating what configure does)
+        const configPath = join(testDir, ".swarm", "minimem", "config.json");
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        // Simulate the setNestedValue patching
+        config.hybrid.vectorWeight = 0.9;
+        config.query.maxResults = 25;
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+        // Read it back through readPackageConfig
+        const readBack = readPackageConfig("minimem", testDir);
+        expect(getNestedValue(readBack, "hybrid.vectorWeight")).toBe(0.9);
+        expect(getNestedValue(readBack, "query.maxResults")).toBe(25);
+        // Other values preserved
+        expect(getNestedValue(readBack, "hybrid.textWeight")).toBe(0.3);
+        expect(getNestedValue(readBack, "embedding.provider")).toBe("auto");
+    });
+    it("patches sessionlog settings in-place", async () => {
+        await initProjectPackage("sessionlog", projectCtx({ cwd: testDir, packages: ["sessionlog"] }));
+        const settingsPath = join(testDir, ".swarm", "sessionlog", "settings.json");
+        const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+        settings.enabled = true;
+        settings.strategy = "auto-commit";
+        settings.summarizationEnabled = true;
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+        const readBack = readPackageConfig("sessionlog", testDir);
+        expect(readBack.enabled).toBe(true);
+        expect(readBack.strategy).toBe("auto-commit");
+        expect(readBack.summarizationEnabled).toBe(true);
+        // Preserved
+        expect(readBack.logLevel).toBe("warn");
+    });
+    it("patches claude-code-swarm nested config in-place", async () => {
+        await initProjectPackage("claude-code-swarm", projectCtx({ cwd: testDir, packages: ["claude-code-swarm"] }));
+        const configPath = join(testDir, ".swarm", "claude-swarm", "config.json");
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        config.map.enabled = true;
+        config.map.server = "ws://reconfigured:9090";
+        config.map.scope = "my-scope";
+        config.sessionlog.enabled = true;
+        config.sessionlog.sync = "live";
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+        const readBack = readPackageConfig("claude-code-swarm", testDir);
+        expect(getNestedValue(readBack, "map.enabled")).toBe(true);
+        expect(getNestedValue(readBack, "map.server")).toBe("ws://reconfigured:9090");
+        expect(getNestedValue(readBack, "map.scope")).toBe("my-scope");
+        expect(getNestedValue(readBack, "sessionlog.enabled")).toBe(true);
+        expect(getNestedValue(readBack, "sessionlog.sync")).toBe("live");
+        // Preserved defaults
+        expect(getNestedValue(readBack, "map.systemId")).toBe("system-claude-swarm");
+        expect(getNestedValue(readBack, "template")).toBe("");
+    });
+});
+// ─── E2E: full init → reconfigure via packageConfigs → verify ───────────────
+describe("e2e: init → reconfigure with new packageConfigs", async () => {
+    const opentasksOk = await hasCliInstalled("opentasks");
+    it.skipIf(!opentasksOk)("init with defaults, then re-init with overrides updates config", async () => {
+        createProject("reconfig-e2e");
+        const packages = ["opentasks", "minimem", "sessionlog", "claude-code-swarm"];
+        // Phase 1: Init with all defaults
+        const ctx1 = projectCtx({
+            cwd: testDir,
+            packages,
+        });
+        const { PROJECT_INIT_ORDER } = await import("../../packages/setup.js");
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!packages.includes(pkg))
+                continue;
+            if (isProjectInit(testDir, pkg))
+                continue;
+            await initProjectPackage(pkg, ctx1);
+        }
+        // Verify defaults
+        let mmConfig = readPackageConfig("minimem", testDir);
+        expect(getNestedValue(mmConfig, "query.maxResults")).toBe(10);
+        let slConfig = readPackageConfig("sessionlog", testDir);
+        expect(slConfig.enabled).toBe(false);
+        let csConfig = readPackageConfig("claude-code-swarm", testDir);
+        expect(getNestedValue(csConfig, "map.enabled")).toBe(false);
+        // Phase 2: Simulate reconfigure by patching config files directly
+        // (This is what configure.ts's applyConfigUpdates does)
+        const mmPath = join(testDir, ".swarm", "minimem", "config.json");
+        const mm = JSON.parse(readFileSync(mmPath, "utf-8"));
+        mm.query.maxResults = 50;
+        mm.hybrid.vectorWeight = 0.85;
+        writeFileSync(mmPath, JSON.stringify(mm, null, 2) + "\n");
+        const slPath = join(testDir, ".swarm", "sessionlog", "settings.json");
+        const sl = JSON.parse(readFileSync(slPath, "utf-8"));
+        sl.enabled = true;
+        sl.strategy = "auto-commit";
+        writeFileSync(slPath, JSON.stringify(sl, null, 2) + "\n");
+        const csPath = join(testDir, ".swarm", "claude-swarm", "config.json");
+        const cs = JSON.parse(readFileSync(csPath, "utf-8"));
+        cs.map.enabled = true;
+        cs.map.server = "ws://production:8080";
+        cs.sessionlog.enabled = true;
+        cs.sessionlog.sync = "on-finish";
+        writeFileSync(csPath, JSON.stringify(cs, null, 2) + "\n");
+        // Phase 3: Verify reconfigured values via readPackageConfig
+        mmConfig = readPackageConfig("minimem", testDir);
+        expect(getNestedValue(mmConfig, "query.maxResults")).toBe(50);
+        expect(getNestedValue(mmConfig, "hybrid.vectorWeight")).toBe(0.85);
+        expect(getNestedValue(mmConfig, "hybrid.textWeight")).toBe(0.3); // preserved
+        slConfig = readPackageConfig("sessionlog", testDir);
+        expect(slConfig.enabled).toBe(true);
+        expect(slConfig.strategy).toBe("auto-commit");
+        expect(slConfig.logLevel).toBe("warn"); // preserved
+        csConfig = readPackageConfig("claude-code-swarm", testDir);
+        expect(getNestedValue(csConfig, "map.enabled")).toBe(true);
+        expect(getNestedValue(csConfig, "map.server")).toBe("ws://production:8080");
+        expect(getNestedValue(csConfig, "sessionlog.enabled")).toBe(true);
+        expect(getNestedValue(csConfig, "sessionlog.sync")).toBe("on-finish");
+        expect(getNestedValue(csConfig, "map.systemId")).toBe("system-claude-swarm"); // preserved
+        // opentasks should be untouched
+        expect(isProjectInit(testDir, "opentasks")).toBe(true);
+        const otConfig = JSON.parse(readFileSync(join(testDir, ".swarm", "opentasks", "config.json"), "utf-8"));
+        expect(otConfig.location.name).toBe("reconfig-e2e");
+    });
+});
+// ─── E2E: CLI wizard reconfigure with live packages ──────────────────────────
+describe("e2e: CLI wizard reconfigure — opentasks", async () => {
+    const installed = await hasCliInstalled("opentasks");
+    it.skipIf(!installed)("re-runs opentasks wizard on already-initialized project", async () => {
+        createProject("wizard-reconfig");
+        // First init
+        await initProjectPackage("opentasks", projectCtx({ cwd: testDir, packages: ["opentasks"] }));
+        expect(isProjectInit(testDir, "opentasks")).toBe(true);
+        const configBefore = JSON.parse(readFileSync(join(testDir, ".swarm", "opentasks", "config.json"), "utf-8"));
+        expect(configBefore.location.name).toBe("wizard-reconfig");
+        // Re-run wizard (simulates configure path)
+        const state = createEmptyState();
+        state.selectedPackages = ["opentasks"];
+        state.usePrefix = true;
+        const result = await runPackageWizard("opentasks", {
+            command: "opentasks",
+            args: ["init", "--name", "wizard-reconfig-v2"],
+            env: { OPENTASKS_PROJECT_DIR: ".swarm/opentasks" },
+        }, state, testDir);
+        expect(result.success).toBe(true);
+        // Config should be updated by the re-run
+        // (opentasks init is idempotent on already-initialized dirs,
+        // but verifies the wizard path completes successfully)
+        expect(isProjectInit(testDir, "opentasks")).toBe(true);
+    });
+});
+describe("e2e: CLI wizard reconfigure — skill-tree global", async () => {
+    const installed = await hasCliInstalled("skill-tree");
+    it.skipIf(!installed)("re-runs skill-tree config init on existing config", async () => {
+        // First init via global setup
+        await initGlobalPackage("skill-tree", globalCtx({ packages: ["skill-tree"] }));
+        expect(existsSync(join(testHome, ".skill-tree", "config.yaml"))).toBe(true);
+        // Re-run wizard with --force (simulates configure path)
+        // skill-tree config init requires --force to overwrite existing config
+        const state = createEmptyState();
+        state.selectedPackages = ["skill-tree"];
+        const result = await runPackageWizard("skill-tree", {
+            command: "skill-tree",
+            args: ["config", "init", "--force"],
+        }, state, testDir);
+        expect(result.success).toBe(true);
+        expect(existsSync(join(testHome, ".skill-tree", "config.yaml"))).toBe(true);
+    });
+});
+// ─── E2E: full multi-package init → reconfigure → verify ────────────────────
+describe("e2e: full multi-package init → reconfigure cycle", async () => {
+    const opentasksOk = await hasCliInstalled("opentasks");
+    it.skipIf(!opentasksOk)("initializes solo bundle, reconfigures minimem, verifies all configs intact", async () => {
+        createProject("full-reconfig");
+        const packages = ["opentasks", "minimem"];
+        const { PROJECT_INIT_ORDER } = await import("../../packages/setup.js");
+        // Step 1: Init with openai embedding
+        const ctx = projectCtx({
+            cwd: testDir,
+            packages,
+            embeddingProvider: "openai",
+        });
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!packages.includes(pkg))
+                continue;
+            if (isProjectInit(testDir, pkg))
+                continue;
+            await initProjectPackage(pkg, ctx);
+        }
+        // Verify initial state
+        let mmConfig = readPackageConfig("minimem", testDir);
+        expect(getNestedValue(mmConfig, "embedding.provider")).toBe("openai");
+        expect(getNestedValue(mmConfig, "hybrid.vectorWeight")).toBe(0.7);
+        expect(getNestedValue(mmConfig, "query.maxResults")).toBe(10);
+        // Step 2: Reconfigure minimem (simulate what configure does)
+        const mmPath = join(testDir, ".swarm", "minimem", "config.json");
+        const mm = JSON.parse(readFileSync(mmPath, "utf-8"));
+        mm.hybrid.vectorWeight = 0.95;
+        mm.hybrid.textWeight = 0.05;
+        mm.query.maxResults = 100;
+        mm.query.minScore = 0.5;
+        writeFileSync(mmPath, JSON.stringify(mm, null, 2) + "\n");
+        // Step 3: Verify reconfigured values
+        mmConfig = readPackageConfig("minimem", testDir);
+        expect(getNestedValue(mmConfig, "embedding.provider")).toBe("openai"); // unchanged
+        expect(getNestedValue(mmConfig, "hybrid.vectorWeight")).toBe(0.95);
+        expect(getNestedValue(mmConfig, "hybrid.textWeight")).toBe(0.05);
+        expect(getNestedValue(mmConfig, "query.maxResults")).toBe(100);
+        expect(getNestedValue(mmConfig, "query.minScore")).toBe(0.5);
+        // Step 4: opentasks should be completely untouched
+        const otConfig = JSON.parse(readFileSync(join(testDir, ".swarm", "opentasks", "config.json"), "utf-8"));
+        expect(otConfig.location.name).toBe("full-reconfig");
+        expect(otConfig.version).toBe("1.0");
+    });
+});
+// ─── E2E: flat layout reconfigure ────────────────────────────────────────────
+describe("e2e: reconfigure with flat layout", () => {
+    it("reads and patches flat layout configs", async () => {
+        // Init with flat layout
+        await initProjectPackage("sessionlog", projectCtx({ cwd: testDir, packages: ["sessionlog"], usePrefix: false }));
+        expect(existsSync(join(testDir, ".sessionlog", "settings.json"))).toBe(true);
+        // Read back via readPackageConfig (checks flat)
+        let config = readPackageConfig("sessionlog", testDir);
+        expect(config).not.toBeNull();
+        expect(config.enabled).toBe(false);
+        // Patch
+        const settingsPath = join(testDir, ".sessionlog", "settings.json");
+        const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+        settings.enabled = true;
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+        // Verify
+        config = readPackageConfig("sessionlog", testDir);
+        expect(config.enabled).toBe(true);
+        expect(config.strategy).toBe("manual-commit"); // preserved
+    });
+});

package/dist/commands/configure/read-config.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Read an existing package config file and return its parsed contents.
+ * Checks both prefixed and flat project layouts, plus global config.
+ *
+ * Returns the merged result of global + project config (project wins).
+ */
+export declare function readPackageConfig(pkg: string, cwd: string): Record<string, unknown> | null;
+/**
+ * Resolve a dotted key path from a nested config object.
+ * e.g., getNestedValue(config, "hybrid.vectorWeight") → 0.7
+ */
+export declare function getNestedValue(config: Record<string, unknown>, keyPath: string): unknown;

package/dist/commands/configure/read-config.js

@@ -0,0 +1,81 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { PROJECT_CONFIG_DIRS, FLAT_PROJECT_CONFIG_DIRS, GLOBAL_CONFIG_DIRS, } from "../../packages/setup.js";
+/**
+ * Read an existing package config file and return its parsed contents.
+ * Checks both prefixed and flat project layouts, plus global config.
+ *
+ * Returns the merged result of global + project config (project wins).
+ */
+export function readPackageConfig(pkg, cwd) {
+    const configs = [];
+    // Read global config if exists
+    const globalDir = GLOBAL_CONFIG_DIRS[pkg];
+    if (globalDir) {
+        const globalConfig = readJsonConfig(join(homedir(), globalDir, "config.json"));
+        if (globalConfig)
+            configs.push(globalConfig);
+    }
+    // Read project config (try prefixed first, then flat)
+    const prefixedDir = PROJECT_CONFIG_DIRS[pkg];
+    const flatDir = FLAT_PROJECT_CONFIG_DIRS[pkg];
+    const projectConfigFile = pkg === "sessionlog" ? "settings.json" : "config.json";
+    if (prefixedDir) {
+        const prefixedConfig = readJsonConfig(join(cwd, prefixedDir, projectConfigFile));
+        if (prefixedConfig) {
+            configs.push(prefixedConfig);
+        }
+        else if (flatDir) {
+            const flatConfig = readJsonConfig(join(cwd, flatDir, projectConfigFile));
+            if (flatConfig)
+                configs.push(flatConfig);
+        }
+    }
+    if (configs.length === 0)
+        return null;
+    // Merge: later entries override earlier
+    const merged = {};
+    for (const config of configs) {
+        deepMerge(merged, config);
+    }
+    return merged;
+}
+/**
+ * Resolve a dotted key path from a nested config object.
+ * e.g., getNestedValue(config, "hybrid.vectorWeight") → 0.7
+ */
+export function getNestedValue(config, keyPath) {
+    const parts = keyPath.split(".");
+    let current = config;
+    for (const part of parts) {
+        if (typeof current !== "object" || current === null)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function readJsonConfig(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function deepMerge(target, source) {
+    for (const [key, value] of Object.entries(source)) {
+        if (typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value) &&
+            typeof target[key] === "object" &&
+            target[key] !== null) {
+            deepMerge(target[key], value);
+        }
+        else {
+            target[key] = value;
+        }
+    }
+}

package/dist/commands/configure.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerConfigureCommand(program: Command): void;

package/dist/commands/configure.js

@@ -0,0 +1,14 @@
+export function registerConfigureCommand(program) {
+    program
+        .command("configure [package]")
+        .description("Reconfigure package settings (or all packages if none specified)")
+        .option("-q, --quick", "Reset to defaults without prompting")
+        .action(async (packageName, opts) => {
+        // Dynamic import to avoid loading @inquirer/prompts for other commands
+        const { runConfigure } = await import("./configure/configure.js");
+        await runConfigure({
+            packageName,
+            quick: opts.quick === true,
+        });
+    });
+}