@cortexkit/opencode-magic-context 0.38.1 → 0.40.0

package/src/config/index.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, it } from "bun:test";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-
+import { resolveHistorianModel } from "../shared/model-resolution";
 import { loadPluginConfig, loadPluginConfigDetailed } from "./index";
+import { resolveConfigProfile } from "./profiles";
 import { RUST_COMPACTION_OFF_WARNING } from "./transform-mode";
 
 /**
@@ -342,6 +343,40 @@ describe("loadPluginConfig — secret redaction", () => {
         expect(w).toBeDefined();
     });
 
+    it("prunes only cross-harness qualifier leaves and names their full paths", () => {
+        const result = loadWithUserConfig(
+            JSON.stringify({
+                historian: {
+                    two_pass: true,
+                    opencode: {
+                        model: "anthropic/claude-sonnet",
+                        variant: "high",
+                        thinking_level: "minimal",
+                    },
+                    pi: {
+                        model: "github-copilot/gpt-5",
+                        thinking_level: "medium",
+                        variant: "fast",
+                    },
+                },
+            }),
+        );
+
+        expect(result.historian?.two_pass).toBe(true);
+        expect(result.historian?.opencode).toEqual({
+            model: "anthropic/claude-sonnet",
+            variant: "high",
+        });
+        expect(result.historian?.pi).toEqual({
+            model: "github-copilot/gpt-5",
+            thinking_level: "medium",
+        });
+        const warnings = result.configWarnings?.join("\n") ?? "";
+        expect(warnings).toContain("historian.opencode.thinking_level");
+        expect(warnings).toContain("historian.pi.variant");
+        expect(warnings).not.toContain("invalid agent configuration, ignoring");
+    });
+
     it("still shows numeric and boolean invalid values (not secrets by nature)", () => {
         // Numbers/booleans in config fields are never secrets — they're
         // plain validation mistakes — so we surface them fully to help
@@ -740,25 +775,43 @@ describe("loadPluginConfig — user-only settings", () => {
         const result = loadWithUserAndProjectConfig(
             JSON.stringify({
                 historian: {
-                    model: "anthropic/user-historian",
-                    fallback_models: ["anthropic/user-fallback"],
+                    opencode: {
+                        model: "anthropic/user-historian",
+                        fallback_models: ["anthropic/user-fallback"],
+                    },
+                    pi: {
+                        model: "github-copilot/user-historian",
+                        fallback_models: ["github-copilot/user-fallback"],
+                    },
                 },
             }),
             JSON.stringify({
                 historian: {
-                    model: "anthropic/project-historian",
-                    fallback_models: ["anthropic/project-fallback"],
+                    opencode: {
+                        model: "anthropic/project-historian",
+                        fallback_models: ["anthropic/project-fallback"],
+                    },
+                    pi: {
+                        model: "github-copilot/project-historian",
+                        fallback_models: ["github-copilot/project-fallback"],
+                    },
                     temperature: 0.2,
                 },
             }),
         );
 
-        expect(result.historian?.model).toBe("anthropic/user-historian");
-        expect(result.historian?.fallback_models).toEqual(["anthropic/user-fallback"]);
+        expect(result.historian?.opencode).toEqual({
+            model: "anthropic/user-historian",
+            fallback_models: ["anthropic/user-fallback"],
+        });
+        expect(result.historian?.pi).toEqual({
+            model: "github-copilot/user-historian",
+            fallback_models: ["github-copilot/user-fallback"],
+        });
         expect(result.historian?.temperature).toBe(0.2);
-        expect(result.configWarnings?.join("\n")).toContain(
-            "Ignoring historian.model/fallback_models",
-        );
+        const warnings = result.configWarnings?.join("\n") ?? "";
+        expect(warnings).toContain("historian.opencode.model");
+        expect(warnings).toContain("historian.pi.model");
     });
 });
 
@@ -877,21 +930,25 @@ describe("loadPluginConfig — raw merge preserves user fields not set in projec
             JSON.stringify({ language: "tr" }),
             JSON.stringify({
                 dreamer: {
-                    model: "anthropic/project-dreamer",
-                    tasks: {
-                        verify: {
-                            schedule: "0 3 * * *",
-                            model: "anthropic/project-verify",
-                        },
+                    tasks: { verify: { schedule: "0 3 * * *" } },
+                    opencode: {
+                        model: "anthropic/project-dreamer",
+                        tasks: { verify: { model: "anthropic/project-verify" } },
+                    },
+                    pi: {
+                        model: "github-copilot/project-dreamer",
+                        tasks: { verify: { model: "github-copilot/project-verify" } },
                     },
                 },
             }),
         );
 
         expect(result.language).toBe("tr");
-        expect(result.dreamer?.model).toBe("anthropic/project-dreamer");
+        expect(result.dreamer?.opencode?.model).toBe("anthropic/project-dreamer");
+        expect(result.dreamer?.pi?.model).toBe("github-copilot/project-dreamer");
         expect(result.dreamer?.tasks.verify.schedule).toBe("0 3 * * *");
-        expect(result.dreamer?.tasks.verify.model).toBe("anthropic/project-verify");
+        expect(result.dreamer?.opencode?.tasks?.verify?.model).toBe("anthropic/project-verify");
+        expect(result.dreamer?.pi?.tasks?.verify?.model).toBe("github-copilot/project-verify");
     });
 
     it("project boolean override beats user default", () => {
@@ -958,6 +1015,364 @@ describe("transform_mode resolution", () => {
     });
 });
 
+describe("loadPluginConfig — user-owned model profiles", () => {
+    it("merges user base, selected profile, then project config without losing profile fallback qualifiers", () => {
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({
+                profile: "personal",
+                historian: {
+                    two_pass: true,
+                    opencode: {
+                        model: "anthropic/base-historian",
+                        fallback_models: ["anthropic/base-fallback"],
+                    },
+                },
+                dreamer: {
+                    opencode: { model: "anthropic/base-dreamer" },
+                },
+                profiles: {
+                    work: {
+                        historian: {
+                            opencode: {
+                                model: { model: "anthropic/work-historian", variant: "high" },
+                                fallback_models: [
+                                    { model: "openai/work-fallback", variant: "low" },
+                                ],
+                            },
+                        },
+                        dreamer: {
+                            opencode: {
+                                model: "anthropic/work-dreamer",
+                                fallback_models: [
+                                    { model: "openai/work-dreamer-fallback", variant: "medium" },
+                                ],
+                            },
+                        },
+                        sidekick: { model: "anthropic/work-sidekick" },
+                    },
+                    personal: {
+                        historian: { opencode: { model: "anthropic/personal-historian" } },
+                    },
+                },
+            }),
+            JSON.stringify({
+                profile: "work",
+                memory: { enabled: false },
+            }),
+        );
+
+        expect(result.profile).toBe("work");
+        expect(result.memory.enabled).toBe(false);
+        expect(result.historian?.two_pass).toBe(true);
+        expect(result.historian?.opencode).toEqual({
+            model: { model: "anthropic/work-historian", variant: "high" },
+            fallback_models: [{ model: "openai/work-fallback", variant: "low" }],
+        });
+        expect(result.dreamer?.opencode?.model).toBe("anthropic/work-dreamer");
+        expect(result.dreamer?.opencode?.fallback_models).toEqual([
+            { model: "openai/work-dreamer-fallback", variant: "medium" },
+        ]);
+        expect(result.sidekick?.model).toBe("anthropic/work-sidekick");
+    });
+
+    it("uses project selection over user selection and falls back to the base on an unknown name", () => {
+        const userConfig = JSON.stringify({
+            profile: "personal",
+            historian: { opencode: { model: "anthropic/base" } },
+            profiles: {
+                personal: { historian: { opencode: { model: "anthropic/personal" } } },
+                work: { historian: { opencode: { model: "anthropic/work" } } },
+            },
+        });
+
+        const userDefault = loadWithUserAndProjectConfig(userConfig, "{}");
+        const projectOverride = loadWithUserAndProjectConfig(userConfig, '{"profile":"work"}');
+        const unknownProject = loadWithUserAndProjectConfig(userConfig, '{"profile":"missing"}');
+
+        expect(userDefault.profile).toBe("personal");
+        expect(userDefault.historian?.opencode?.model).toBe("anthropic/personal");
+        expect(projectOverride.profile).toBe("work");
+        expect(projectOverride.historian?.opencode?.model).toBe("anthropic/work");
+        expect(unknownProject.profile).toBeUndefined();
+        expect(unknownProject.enabled).toBe(true);
+        expect(unknownProject.historian?.opencode?.model).toBe("anthropic/base");
+        expect(unknownProject.configWarnings?.join("\n")).toContain(
+            'Unknown profile "missing" selected by project config',
+        );
+    });
+
+    it("rejects invalid profile definitions with a warning instead of applying their fields", () => {
+        const result = loadWithUserConfig(
+            JSON.stringify({
+                profile: "unsafe",
+                historian: { opencode: { model: "anthropic/base" } },
+                profiles: {
+                    unsafe: {
+                        embedding: { provider: "off" },
+                    },
+                },
+            }),
+        );
+
+        expect(result.profile).toBeUndefined();
+        expect(result.embedding.provider).toBe("local");
+        expect(result.historian?.opencode?.model).toBe("anthropic/base");
+        expect(result.configWarnings?.join("\n")).toContain("Ignoring profiles from user config");
+    });
+
+    it("strips hostile project profile definitions while allowing only user-owned definitions", () => {
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({
+                historian: { opencode: { model: "anthropic/user-base" } },
+            }),
+            JSON.stringify({
+                profile: "work",
+                profiles: {
+                    work: {
+                        historian: { opencode: { model: "attacker/project-profile" } },
+                    },
+                },
+            }),
+        );
+
+        expect(result.profile).toBeUndefined();
+        expect(result.historian?.opencode?.model).toBe("anthropic/user-base");
+        expect(result.configWarnings?.join("\n")).toContain(
+            "Ignoring profiles from project config",
+        );
+    });
+
+    it("falls back loudly for inherited profile names without changing the resolved base config", () => {
+        const userConfig = JSON.stringify({
+            historian: { opencode: { model: "anthropic/base", fallback_models: ["openai/base"] } },
+            profiles: { known: { historian: { opencode: { model: "anthropic/known" } } } },
+        });
+        const base = loadWithUserConfig(userConfig);
+        const { configWarnings: _baseWarnings, ...baseWithoutWarnings } = base;
+        const hostileNames = [
+            "__proto__",
+            "constructor",
+            "prototype",
+            "toString",
+            "hasOwnProperty",
+            "valueOf",
+        ];
+
+        for (const name of hostileNames) {
+            const resolved = loadWithUserAndProjectConfig(
+                userConfig,
+                JSON.stringify({ profile: name }),
+            );
+            const { configWarnings: _warnings, ...resolvedWithoutWarnings } = resolved;
+
+            expect(resolved.profile).toBeUndefined();
+            expect(resolved.configWarnings?.join("\n")).toContain(
+                `Unknown profile "${name}" selected by project config`,
+            );
+            expect(resolvedWithoutWarnings).toEqual(baseWithoutWarnings);
+        }
+    });
+
+    it("ignores a profile inherited from a polluted Object prototype", () => {
+        const profileName = "profile_overlay_pollution_canary";
+        const previousDescriptor = Object.getOwnPropertyDescriptor(Object.prototype, profileName);
+        const userBase = { historian: { opencode: { model: "anthropic/base" } } };
+        // Null-prototype input isolates lookup behavior from strict schema validation of inherited data.
+        const profileOpenCode = Object.assign(Object.create(null), {
+            model: "anthropic/known",
+        });
+        const profileHistorian = Object.assign(Object.create(null), {
+            opencode: profileOpenCode,
+        });
+        const knownProfile = Object.assign(Object.create(null), {
+            historian: profileHistorian,
+        });
+        const profiles = Object.assign(Object.create(null), {
+            known: knownProfile,
+        }) as Record<string, unknown>;
+        Object.defineProperty(Object.prototype, profileName, {
+            value: { historian: { opencode: { model: "attacker/inherited-overlay" } } },
+            enumerable: true,
+            configurable: true,
+        });
+
+        try {
+            const resolution = resolveConfigProfile({
+                userRaw: {
+                    ...userBase,
+                    profiles,
+                },
+                projectRaw: { profile: profileName },
+            });
+
+            expect(resolution.activeProfile).toBeUndefined();
+            expect(resolution.overlay).toEqual({});
+            expect(resolution.userBase).toEqual(userBase);
+            expect(resolution.projectBase).toEqual({});
+            expect(resolution.warnings).toEqual([
+                `Unknown profile "${profileName}" selected by project config; using base config without a profile.`,
+            ]);
+        } finally {
+            if (previousDescriptor) {
+                Object.defineProperty(Object.prototype, profileName, previousDescriptor);
+            } else {
+                delete (Object.prototype as Record<string, unknown>)[profileName];
+            }
+        }
+    });
+
+    it("treats empty, null, and non-string project selectors as no selection", () => {
+        const userConfig = JSON.stringify({
+            profile: "personal",
+            historian: { opencode: { model: "anthropic/base" } },
+            profiles: {
+                personal: { historian: { opencode: { model: "anthropic/personal" } } },
+            },
+        });
+        const invalidProjectSelectors = ["", null, { name: "work" }];
+
+        for (const profile of invalidProjectSelectors) {
+            const result = loadWithUserAndProjectConfig(userConfig, JSON.stringify({ profile }));
+
+            expect(result.profile).toBe("personal");
+            expect(result.historian?.opencode?.model).toBe("anthropic/personal");
+            expect(result.configWarnings?.join("\n")).toContain(
+                "Ignoring invalid profile selection from project config",
+            );
+        }
+    });
+
+    it("preserves an untouched historian Pi block when a profile overlays OpenCode", () => {
+        const piBase = {
+            model: { model: "github-copilot/base", thinking_level: "high" },
+            fallback_models: [
+                { model: "openai/base-fallback", thinking_level: "minimal" },
+                { model: "github-copilot/second-base-fallback", thinking_level: "medium" },
+            ],
+            thinking_level: "high",
+        };
+        const result = loadWithUserConfig(
+            JSON.stringify({
+                profile: "work",
+                historian: {
+                    opencode: { model: "anthropic/base-opencode" },
+                    pi: piBase,
+                },
+                profiles: {
+                    work: {
+                        historian: { opencode: { model: "anthropic/work-opencode" } },
+                    },
+                },
+            }),
+        );
+
+        expect(result.historian?.opencode).toEqual({ model: "anthropic/work-opencode" });
+        expect(result.historian?.pi).toEqual(piBase);
+    });
+
+    it("replaces a base fallback_models array wholesale when a profile provides one", () => {
+        const result = loadWithUserConfig(
+            JSON.stringify({
+                profile: "work",
+                historian: {
+                    opencode: {
+                        model: "anthropic/base",
+                        fallback_models: [
+                            { model: "openai/base-first", variant: "low" },
+                            { model: "anthropic/base-second", variant: "high" },
+                        ],
+                    },
+                },
+                profiles: {
+                    work: {
+                        historian: {
+                            opencode: {
+                                fallback_models: [{ model: "google/work-only", variant: "medium" }],
+                            },
+                        },
+                    },
+                },
+            }),
+        );
+
+        expect(result.historian?.opencode?.fallback_models).toEqual([
+            { model: "google/work-only", variant: "medium" },
+        ]);
+    });
+
+    it("resolves profiles independently for two projects in one process", () => {
+        const xdg = mkdtempSync(join(tmpdir(), "mc-profile-isolation-user-"));
+        const projectA = mkdtempSync(join(tmpdir(), "mc-profile-isolation-a-"));
+        const projectB = mkdtempSync(join(tmpdir(), "mc-profile-isolation-b-"));
+        const previousXdg = process.env.XDG_CONFIG_HOME;
+        mkdirSync(join(xdg, "cortexkit"), { recursive: true });
+        mkdirSync(join(projectA, ".cortexkit"), { recursive: true });
+        mkdirSync(join(projectB, ".cortexkit"), { recursive: true });
+        writeFileSync(
+            join(xdg, "cortexkit", "magic-context.jsonc"),
+            JSON.stringify({
+                profiles: {
+                    work: { historian: { opencode: { model: "anthropic/work" } } },
+                    personal: {
+                        historian: { opencode: { model: "anthropic/personal" } },
+                    },
+                },
+            }),
+        );
+        writeFileSync(join(projectA, ".cortexkit", "magic-context.jsonc"), '{"profile":"work"}');
+        writeFileSync(
+            join(projectB, ".cortexkit", "magic-context.jsonc"),
+            '{"profile":"personal"}',
+        );
+        process.env.XDG_CONFIG_HOME = xdg;
+        try {
+            const work = loadPluginConfig(projectA);
+            const personal = loadPluginConfig(projectB);
+            const workAgain = loadPluginConfig(projectA);
+            expect(work.profile).toBe("work");
+            expect(personal.profile).toBe("personal");
+            expect(workAgain.profile).toBe("work");
+            expect(work.historian?.opencode?.model).toBe("anthropic/work");
+            expect(personal.historian?.opencode?.model).toBe("anthropic/personal");
+            expect(workAgain.historian?.opencode?.model).toBe("anthropic/work");
+        } finally {
+            if (previousXdg === undefined) delete process.env.XDG_CONFIG_HOME;
+            else process.env.XDG_CONFIG_HOME = previousXdg;
+            rmSync(xdg, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+            rmSync(projectA, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+            rmSync(projectB, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+        }
+    });
+
+    it("feeds the selected profile through the existing historian model resolver", () => {
+        const config = loadWithUserAndProjectConfig(
+            JSON.stringify({
+                profiles: {
+                    work: {
+                        historian: {
+                            opencode: {
+                                model: { model: "anthropic/work", variant: "high" },
+                                fallback_models: [
+                                    { model: "openai/work-fallback", variant: "low" },
+                                ],
+                            },
+                        },
+                    },
+                },
+            }),
+            '{"profile":"work"}',
+        );
+
+        // Profile selection changes only the normal resolved model input. The
+        // existing model-switch identity path still sees canonical model IDs and
+        // qualifier-distinct fallback attempts; profiles add no separate cache-bust class.
+        expect(resolveHistorianModel(config, "opencode")).toEqual({
+            primary: { model: "anthropic/work", qualifier: "high" },
+            fallbacks: [{ model: "openai/work-fallback", qualifier: "low" }],
+        });
+    });
+});
+
 describe("loadPluginConfigDetailed — prompt-surface registration owner", () => {
     it("captures the user default before project guidance routing is merged", () => {
         const xdg = mkdtempSync(join(tmpdir(), "mc-config-prompt-surface-"));