@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/src/config/schema/magic-context.test.ts

@@ -0,0 +1,434 @@
+import { describe, expect, it } from "bun:test";
+import {
+    DEFAULT_HISTORIAN_TIMEOUT_MS,
+    DEFAULT_HISTORY_BUDGET_PERCENTAGE,
+    type MagicContextConfig,
+    MagicContextConfigSchema,
+    PER_HARNESS_MIGRATION_INVENTORY,
+} from "./magic-context";
+
+describe("MagicContextConfigSchema", () => {
+    describe("defaults", () => {
+        it("applies defaults for an empty config", () => {
+            const result = MagicContextConfigSchema.parse({});
+
+            expect(result).toMatchObject({
+                enabled: true,
+                allow_home_project: false,
+                fail_closed_blocking: true,
+                storage: { enforce_private_permissions: true },
+                cache_ttl: "5m",
+                prompt_surface: { default: "full" },
+                execute_threshold_percentage: 65,
+                clear_reasoning_age: 50,
+                history_budget_percentage: DEFAULT_HISTORY_BUDGET_PERCENTAGE,
+                historian_timeout_ms: DEFAULT_HISTORIAN_TIMEOUT_MS,
+                memory: {
+                    enabled: true,
+                    injection_budget_tokens: 4000,
+                    auto_promote: true,
+                },
+                todowrite: {
+                    enabled: false,
+                    overlay: true,
+                },
+            });
+            expect(result.historian_timeout_ms).toBeGreaterThanOrEqual(10 * 60_000);
+            expect(result.historian).toBeUndefined();
+            expect(result.dreamer).toBeUndefined();
+            expect(result.pi).toBeUndefined();
+            expect(result.mural).toBeUndefined();
+            expect(result).not.toHaveProperty("protected_tags");
+            expect(result.memory).not.toHaveProperty("retrieval_count_promotion_threshold");
+        });
+    });
+
+    it("defaults todowrite off but honors explicit enablement and disablement", () => {
+        expect(MagicContextConfigSchema.parse({}).todowrite).toEqual({
+            enabled: false,
+            overlay: true,
+        });
+        expect(MagicContextConfigSchema.parse({ todowrite: {} }).todowrite.enabled).toBe(false);
+        expect(MagicContextConfigSchema.parse({ todowrite: { enabled: true } }).todowrite).toEqual({
+            enabled: true,
+            overlay: true,
+        });
+        expect(
+            MagicContextConfigSchema.parse({ todowrite: { enabled: false } }).todowrite.enabled,
+        ).toBe(false);
+    });
+
+    describe("budget configuration", () => {
+        it("accepts 90% execute thresholds and rejects 91%", () => {
+            expect(
+                MagicContextConfigSchema.safeParse({ execute_threshold_percentage: 90 }).success,
+            ).toBe(true);
+            expect(
+                MagicContextConfigSchema.safeParse({ execute_threshold_percentage: 91 }).success,
+            ).toBe(false);
+        });
+
+        it("accepts numeric and per-model output reserves including zero", () => {
+            expect(MagicContextConfigSchema.parse({ output_reserve: 0 }).output_reserve).toBe(0);
+            expect(
+                MagicContextConfigSchema.parse({
+                    output_reserve: { default: 16_384, "google/gemini": 0 },
+                }).output_reserve,
+            ).toEqual({ default: 16_384, "google/gemini": 0 });
+            expect(MagicContextConfigSchema.safeParse({ output_reserve: -1 }).success).toBe(false);
+        });
+    });
+
+    describe("valid config", () => {
+        it("parses an enabled config without stale reduction-specific keys", () => {
+            const input = {
+                enabled: true,
+                allow_home_project: false,
+                fail_closed_blocking: true,
+                auto_update: false,
+                toast_duration_ms: 5000,
+                cache_ttl: "10m",
+                prompt_surface: { default: "full" },
+                execute_threshold_percentage: 75,
+                clear_reasoning_age: 60,
+                history_budget_percentage: 0.2,
+                historian_timeout_ms: 360_000,
+                commit_cluster_trigger: {
+                    enabled: true,
+                    min_clusters: 3,
+                },
+                sqlite: {
+                    cache_size_mb: 64,
+                    mmap_size_mb: 0,
+                },
+                storage: {
+                    enforce_private_permissions: false,
+                },
+                system_prompt_injection: {
+                    enabled: true,
+                    skip_signatures: ["<!-- magic-context: skip -->"],
+                },
+                temporal_awareness: false,
+                keep_subagents: false,
+                debug_rpc: false,
+                todowrite: {
+                    enabled: false,
+                    overlay: false,
+                },
+                smart_drops: false,
+                caveman_text_compression: {
+                    enabled: false,
+                    min_chars: 500,
+                },
+                memory: {
+                    enabled: true,
+                    injection_budget_tokens: 4000,
+                    auto_promote: true,
+                    auto_search: {
+                        enabled: false,
+                        score_threshold: 0.6,
+                        min_prompt_chars: 20,
+                    },
+                },
+                pi: {
+                    subagent_extensions: ["@example/provider", "./extensions/local.ts"],
+                },
+                compaction: {
+                    enabled: true,
+                },
+                maintenance: {
+                    enabled: true,
+                    budgets: {
+                        inputTokens: 400_000,
+                        outputTokens: 32_000,
+                        toolSteps: 60,
+                        wallMs: 900_000,
+                    },
+                    cooldowns: {
+                        interRunMs: 1_800_000,
+                        backoffScheduleMs: [900_000, 3_600_000, 14_400_000],
+                        backoffCapMs: 86_400_000,
+                        maxRetries: 3,
+                    },
+                    anomalyThreshold: {
+                        absoluteRows: 10,
+                        poolFraction: 0.25,
+                    },
+                },
+            } satisfies MagicContextConfig;
+
+            const result = MagicContextConfigSchema.parse(input);
+
+            expect(result).toEqual(input);
+        });
+
+        it("accepts a boolean storage permission policy and rejects non-booleans", () => {
+            expect(
+                MagicContextConfigSchema.parse({
+                    storage: { enforce_private_permissions: false },
+                }).storage.enforce_private_permissions,
+            ).toBe(false);
+            expect(
+                MagicContextConfigSchema.safeParse({
+                    storage: { enforce_private_permissions: "false" },
+                }).success,
+            ).toBe(false);
+        });
+
+        it("accepts disable on hidden agents and strips deprecated top-level enabled", () => {
+            const result = MagicContextConfigSchema.parse({
+                historian: { disable: true },
+            });
+
+            expect(result.historian?.disable).toBe(true);
+        });
+
+        it("accepts optional auto_update user preference", () => {
+            expect(MagicContextConfigSchema.parse({ auto_update: false }).auto_update).toBe(false);
+            expect(MagicContextConfigSchema.parse({ auto_update: true }).auto_update).toBe(true);
+        });
+
+        it("accepts an explicitly configured Pi subagent extension allowlist", () => {
+            expect(
+                MagicContextConfigSchema.parse({
+                    pi: { subagent_extensions: ["provider-package", "./local.ts"] },
+                }).pi,
+            ).toEqual({ subagent_extensions: ["provider-package", "./local.ts"] });
+        });
+
+        it("accepts and normalizes 2-letter ISO 639-1 language codes", () => {
+            expect(MagicContextConfigSchema.parse({ language: "tr" }).language).toBe("tr");
+            expect(MagicContextConfigSchema.parse({ language: "  ES " }).language).toBe("es");
+            expect(MagicContextConfigSchema.parse({ language: "ja" }).language).toBe("ja");
+        });
+
+        it("parses per-model cache_ttl objects", () => {
+            const input = {
+                cache_ttl: {
+                    default: "5m",
+                    "claude-3-haiku": "10m",
+                    "gpt-4": "2m",
+                },
+            };
+
+            const result = MagicContextConfigSchema.parse(input);
+
+            expect(result.cache_ttl).toEqual(input.cache_ttl);
+        });
+
+        // Accepts preset routing, a guidance override path, and tool-description overrides.
+        it("parses prompt-surface defaults, routes, and user overrides", () => {
+            const promptSurface = {
+                default: "light" as const,
+                models: {
+                    "anthropic/claude/sonnet": "full" as const,
+                    "claude-sonnet-4-5": "light" as const,
+                    "openai/*": "light" as const,
+                },
+                guidance_override_path: "./guidance.md",
+                tool_descriptions: { mmc_search: "Search project context" },
+            };
+
+            expect(
+                MagicContextConfigSchema.parse({ prompt_surface: promptSurface }).prompt_surface,
+            ).toEqual(promptSurface);
+        });
+    });
+
+    describe("config profiles", () => {
+        it("admits model-selection fields and preserves per-entry harness qualifiers", () => {
+            const result = MagicContextConfigSchema.parse({
+                profile: "work",
+                profiles: {
+                    work: {
+                        historian: {
+                            opencode: {
+                                model: { model: "anthropic/work-historian", variant: "high" },
+                                fallback_models: [
+                                    { model: "openai/work-fallback", variant: "low" },
+                                ],
+                                variant: "high",
+                            },
+                            pi: {
+                                model: {
+                                    model: "github-copilot/work-historian",
+                                    thinking_level: "high",
+                                },
+                                thinking_level: "high",
+                            },
+                        },
+                    },
+                },
+            });
+
+            expect(result.profiles?.work?.historian?.opencode?.fallback_models).toEqual([
+                { model: "openai/work-fallback", variant: "low" },
+            ]);
+        });
+
+        it("rejects a dreamer profile outright (agent removed)", () => {
+            const profiles = {
+                work: {
+                    dreamer: {
+                        opencode: { model: "x/y" },
+                    },
+                },
+            };
+
+            expect(MagicContextConfigSchema.safeParse({ profiles }).success).toBe(false);
+        });
+
+        it("rejects task execution and every other non-model field class in profiles", () => {
+            const profilesWithExcludedFields = [
+                { work: { embedding: { provider: "off" } } },
+                { work: { historian: { two_pass: true } } },
+                { work: { historian: { opencode: { prompt: "override" } } } },
+            ];
+
+            for (const profiles of profilesWithExcludedFields) {
+                expect(MagicContextConfigSchema.safeParse({ profiles }).success).toBe(false);
+            }
+        });
+    });
+
+    describe("per-harness model configuration", () => {
+        it("keeps the migration inventory exhaustive and field-specific", () => {
+            expect(PER_HARNESS_MIGRATION_INVENTORY).toEqual({
+                historian: {
+                    retained: [
+                        "temperature",
+                        "top_p",
+                        "prompt",
+                        "tools",
+                        "disable",
+                        "description",
+                        "mode",
+                        "color",
+                        "maxSteps",
+                        "permission",
+                        "maxTokens",
+                        "two_pass",
+                        "disallowed_tools",
+                    ],
+                    migrated_execution: ["model", "fallback_models", "variant", "thinking_level"],
+                },
+            });
+        });
+
+        it("keeps agent metadata separate from strict harness execution blocks", () => {
+            const result = MagicContextConfigSchema.parse({
+                historian: {
+                    disable: false,
+                    two_pass: true,
+                    disallowed_tools: ["read"],
+                    opencode: {
+                        model: { model: "anthropic/claude-sonnet-4-6", variant: "high" },
+                        fallback_models: ["openai/gpt-5.4"],
+                        variant: "medium",
+                    },
+                    pi: {
+                        model: {
+                            model: "github-copilot/gpt-5.4",
+                            thinking_level: "high",
+                        },
+                        fallback_models: ["openai/gpt-5.4"],
+                        thinking_level: "medium",
+                    },
+                },
+            });
+
+            expect(result.historian?.opencode?.fallback_models).toEqual(["openai/gpt-5.4"]);
+        });
+
+        it("rejects cross-harness vocabulary, non-array fallbacks, and execution fields at metadata depth", () => {
+            const invalidConfigs = [
+                { historian: { opencode: { thinking_level: "high" } } },
+                { historian: { pi: { variant: "high" } } },
+                { historian: { opencode: { fallback_models: "anthropic/claude-sonnet-4-6" } } },
+            ];
+
+            for (const config of invalidConfigs) {
+                expect(MagicContextConfigSchema.safeParse(config).success).toBe(false);
+            }
+        });
+    });
+
+    describe("validation", () => {
+        it("rejects malformed prompt-surface model keys and empty override text", () => {
+            const malformedKeys = [
+                "",
+                "model*",
+                "/model",
+                "provider/",
+                "provider//model",
+                "provider/model*",
+                "provider/*/nested",
+                "provider//model",
+                "provider/model/",
+                "provider/ model",
+                "*/model",
+            ];
+            for (const key of malformedKeys) {
+                expect(
+                    MagicContextConfigSchema.safeParse({
+                        prompt_surface: { models: { [key]: "light" } },
+                    }).success,
+                ).toBe(false);
+            }
+
+            expect(
+                MagicContextConfigSchema.safeParse({
+                    prompt_surface: { guidance_override_path: "  " },
+                }).success,
+            ).toBe(false);
+            expect(
+                MagicContextConfigSchema.safeParse({
+                    prompt_surface: { tool_descriptions: { mmc_search: "  " } },
+                }).success,
+            ).toBe(false);
+            expect(
+                MagicContextConfigSchema.safeParse({
+                    prompt_surface: { tool_descriptions: { "  ": "description" } },
+                }).success,
+            ).toBe(false);
+        });
+
+        it("rejects empty Pi subagent extension entries", () => {
+            expect(() =>
+                MagicContextConfigSchema.parse({ pi: { subagent_extensions: ["  "] } }),
+            ).toThrow();
+        });
+
+        it("enforces protected_tokens override range at both ends", () => {
+            expect(() => MagicContextConfigSchema.parse({ protected_tokens: 3999 })).toThrow();
+            expect(() => MagicContextConfigSchema.parse({ protected_tokens: 1_000_001 })).toThrow();
+            expect(() => MagicContextConfigSchema.parse({ protected_tokens: 30000.5 })).toThrow();
+            expect(
+                MagicContextConfigSchema.parse({ protected_tokens: 4000 }).protected_tokens,
+            ).toBe(4000);
+            expect(
+                MagicContextConfigSchema.parse({ protected_tokens: 1_000_000 }).protected_tokens,
+            ).toBe(1_000_000);
+            expect(
+                MagicContextConfigSchema.parse({ protected_tokens: 30000 }).protected_tokens,
+            ).toBe(30000);
+        });
+
+        it("rejects clear_reasoning_age below minimum", () => {
+            expect(() => MagicContextConfigSchema.parse({ clear_reasoning_age: 9 })).toThrow();
+        });
+
+        it("rejects historian_timeout_ms below minimum", () => {
+            expect(() =>
+                MagicContextConfigSchema.parse({ historian_timeout_ms: 59_999 }),
+            ).toThrow();
+        });
+
+        it("rejects non-code output language values", () => {
+            expect(() => MagicContextConfigSchema.parse({ language: "Turkish" })).toThrow(); // full name
+            expect(() => MagicContextConfigSchema.parse({ language: "tur" })).toThrow(); // 3-letter
+            expect(() => MagicContextConfigSchema.parse({ language: "zz" })).toThrow(); // unknown code
+            expect(() => MagicContextConfigSchema.parse({ language: "<x>" })).toThrow();
+        });
+    });
+});