@wolfx/opencode-magic-context 0.21.8-patch.1

package/src/shared/opencode-compaction-detector.test.ts

@@ -0,0 +1,222 @@
+import { afterEach, beforeEach, describe, expect, it, spyOn } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { isOpenCodeAutoCompactionEnabled } from "./opencode-compaction-detector";
+import * as configDir from "./opencode-config-dir";
+
+describe("opencode-compaction-detector", () => {
+    let tmpDir: string;
+
+    beforeEach(() => {
+        tmpDir = join("/tmp", `compaction-detector-test-${Date.now()}`);
+        mkdirSync(join(tmpDir, ".opencode"), { recursive: true });
+        delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+        spyOn(configDir, "getOpenCodeConfigPaths").mockReturnValue({
+            configJson: join(tmpDir, "user-config", "opencode.json"),
+            configJsonc: join(tmpDir, "user-config", "opencode.jsonc"),
+        } as ReturnType<typeof configDir.getOpenCodeConfigPaths>);
+    });
+
+    afterEach(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+        delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+    });
+
+    describe("#given no config exists", () => {
+        it("#then returns true (default: compaction enabled)", () => {
+            const emptyDir = join("/tmp", `compaction-empty-${Date.now()}`);
+            mkdirSync(emptyDir, { recursive: true });
+
+            const result = isOpenCodeAutoCompactionEnabled(emptyDir);
+
+            expect(result).toBe(true);
+            rmSync(emptyDir, { recursive: true, force: true });
+        });
+    });
+
+    describe("#given OPENCODE_DISABLE_AUTOCOMPACT env flag is set", () => {
+        it("#then returns false", () => {
+            process.env.OPENCODE_DISABLE_AUTOCOMPACT = "1";
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+    });
+
+    describe("#given project config has compaction.auto = false", () => {
+        it("#when opencode.json #then returns false", () => {
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { auto: false } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+
+        it("#when opencode.jsonc #then returns false", () => {
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.jsonc"),
+                `{
+          // compaction disabled
+          "compaction": { "auto": false }
+        }`,
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+    });
+
+    describe("#given project config has compaction.auto = true", () => {
+        it("#then returns true", () => {
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { auto: true } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(true);
+        });
+    });
+
+    describe("#given project config has compaction.prune = true", () => {
+        it("#then returns true (conflict enabled)", () => {
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { auto: false, prune: true } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(true);
+        });
+    });
+
+    describe("#given project config has auto/prune both false", () => {
+        it("#then returns false", () => {
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { auto: false, prune: false } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+    });
+
+    describe("#given project config has only compaction.prune = false", () => {
+        it("#then returns false", () => {
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { prune: false } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+    });
+
+    describe("#given jsonc and json both exist", () => {
+        it("#then jsonc takes precedence", () => {
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { auto: true } }),
+            );
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.jsonc"),
+                `{ "compaction": { "auto": false } }`,
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+    });
+
+    describe("#given config exists but no compaction field", () => {
+        it("#then returns true (default)", () => {
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ model: "claude-opus-4-6" }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(true);
+        });
+    });
+
+    describe("#given env flag overrides config", () => {
+        it("#then env flag wins even when config has auto: true", () => {
+            process.env.OPENCODE_DISABLE_AUTOCOMPACT = "true";
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { auto: true } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+    });
+
+    describe("#given root-level project config", () => {
+        it("#when root opencode.json has compaction.auto = false #then returns false", () => {
+            writeFileSync(
+                join(tmpDir, "opencode.json"),
+                JSON.stringify({ compaction: { auto: false } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+
+        it("#when root opencode.jsonc has compaction.auto = false #then returns false", () => {
+            writeFileSync(join(tmpDir, "opencode.jsonc"), `{ "compaction": { "auto": false } }`);
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+    });
+
+    describe("#given .opencode/ overrides root-level config", () => {
+        it("#when root says false but .opencode says true #then .opencode wins", () => {
+            writeFileSync(
+                join(tmpDir, "opencode.json"),
+                JSON.stringify({ compaction: { auto: false } }),
+            );
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { auto: true } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(true);
+        });
+
+        it("#when root says true but .opencode says false #then .opencode wins", () => {
+            writeFileSync(
+                join(tmpDir, "opencode.json"),
+                JSON.stringify({ compaction: { auto: true } }),
+            );
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { auto: false } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+    });
+});

package/src/shared/opencode-compaction-detector.ts

@@ -0,0 +1,81 @@
+import { join } from "node:path";
+import { readJsoncFile } from "./jsonc-parser";
+import { log } from "./logger";
+import { getOpenCodeConfigPaths } from "./opencode-config-dir";
+
+interface OpenCodeConfig {
+    compaction?: {
+        auto?: boolean;
+        prune?: boolean;
+    };
+}
+
+function hasCompactionConflict(
+    compaction: OpenCodeConfig["compaction"] | undefined,
+): boolean | undefined {
+    if (!compaction) return undefined;
+    const hasExplicitSetting = compaction.auto !== undefined || compaction.prune !== undefined;
+    if (!hasExplicitSetting) return undefined;
+    return compaction.auto === true || compaction.prune === true;
+}
+
+export function isOpenCodeAutoCompactionEnabled(directory: string): boolean {
+    if (process.env.OPENCODE_DISABLE_AUTOCOMPACT) {
+        log(
+            "[compaction-detector] OPENCODE_DISABLE_AUTOCOMPACT env flag set — auto compaction disabled",
+        );
+        return false;
+    }
+
+    const projectCompaction = readProjectCompactionConfig(directory);
+    if (projectCompaction !== undefined) {
+        log("[compaction-detector] project config compaction conflict =", projectCompaction);
+        return projectCompaction;
+    }
+
+    const userCompaction = readUserCompactionConfig(directory);
+    if (userCompaction !== undefined) {
+        log("[compaction-detector] user config compaction conflict =", userCompaction);
+        return userCompaction;
+    }
+
+    log("[compaction-detector] no compaction config found — default is enabled");
+    return true;
+}
+
+function readProjectCompactionConfig(directory: string): boolean | undefined {
+    // .opencode/ dir config has higher precedence than root-level config in OpenCode's loading order.
+    // Check highest precedence first — if .opencode/ sets compaction.auto, that wins.
+    const dotOpenCodeJsonc = join(directory, ".opencode", "opencode.jsonc");
+    const dotOpenCodeJson = join(directory, ".opencode", "opencode.json");
+    const dotOpenCodeConfig =
+        readJsoncFile<OpenCodeConfig>(dotOpenCodeJsonc) ??
+        readJsoncFile<OpenCodeConfig>(dotOpenCodeJson);
+
+    const dotOpenCodeCompactionConflict = hasCompactionConflict(dotOpenCodeConfig?.compaction);
+    if (dotOpenCodeCompactionConflict !== undefined) {
+        return dotOpenCodeCompactionConflict;
+    }
+
+    // Root-level project config (lower precedence than .opencode/)
+    const rootJsonc = join(directory, "opencode.jsonc");
+    const rootJson = join(directory, "opencode.json");
+    const rootConfig =
+        readJsoncFile<OpenCodeConfig>(rootJsonc) ?? readJsoncFile<OpenCodeConfig>(rootJson);
+
+    return hasCompactionConflict(rootConfig?.compaction);
+}
+
+function readUserCompactionConfig(_directory: string): boolean | undefined {
+    try {
+        const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+        const config =
+            readJsoncFile<OpenCodeConfig>(paths.configJsonc) ??
+            readJsoncFile<OpenCodeConfig>(paths.configJson);
+
+        return hasCompactionConflict(config?.compaction);
+    } catch {
+        // Intentional: config read is best-effort; missing/unreadable config is not an error
+        return undefined;
+    }
+}

package/src/shared/opencode-config-dir-types.ts

@@ -0,0 +1,15 @@
+export type OpenCodeBinaryType = "opencode" | "opencode-desktop";
+
+export type OpenCodeConfigDirOptions = {
+    binary: OpenCodeBinaryType;
+    version?: string | null;
+    checkExisting?: boolean;
+};
+
+export type OpenCodeConfigPaths = {
+    configDir: string;
+    configJson: string;
+    configJsonc: string;
+    packageJson: string;
+    omoConfig: string;
+};

package/src/shared/opencode-config-dir.ts

@@ -0,0 +1,38 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+import type { OpenCodeConfigDirOptions, OpenCodeConfigPaths } from "./opencode-config-dir-types";
+
+export type {
+    OpenCodeBinaryType,
+    OpenCodeConfigDirOptions,
+    OpenCodeConfigPaths,
+} from "./opencode-config-dir-types";
+
+function getCliConfigDir(): string {
+    const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+    if (envConfigDir) {
+        return resolve(envConfigDir);
+    }
+
+    if (process.platform === "win32") {
+        return join(homedir(), ".config", "opencode");
+    }
+
+    return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "opencode");
+}
+
+export function getOpenCodeConfigDir(_options: OpenCodeConfigDirOptions): string {
+    return getCliConfigDir();
+}
+
+export function getOpenCodeConfigPaths(options: OpenCodeConfigDirOptions): OpenCodeConfigPaths {
+    const configDir = getOpenCodeConfigDir(options);
+    return {
+        configDir,
+        configJson: join(configDir, "opencode.json"),
+        configJsonc: join(configDir, "opencode.jsonc"),
+        packageJson: join(configDir, "package.json"),
+        omoConfig: join(configDir, "magic-context.jsonc"),
+    };
+}

package/src/shared/record-type-guard.ts

@@ -0,0 +1,3 @@
+export function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/shared/resolve-fallbacks.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, test } from "bun:test";
+
+import { DREAMER_AGENT } from "../agents/dreamer";
+import { HISTORIAN_AGENT } from "../agents/historian";
+import { SIDEKICK_AGENT } from "../agents/sidekick";
+import { parseProviderModel, resolveFallbackChain } from "./resolve-fallbacks";
+
+describe("resolveFallbackChain", () => {
+    test("returns builtin chain when user provides nothing", () => {
+        const chain = resolveFallbackChain(DREAMER_AGENT, undefined);
+        // Builtin DREAMER_FALLBACK_CHAIN expands to multiple provider/model entries.
+        expect(chain.length).toBeGreaterThan(2);
+        // Every entry must be in "provider/model" form.
+        for (const entry of chain) {
+            expect(entry.indexOf("/")).toBeGreaterThan(0);
+        }
+    });
+
+    test("returns builtin chain for empty string", () => {
+        const chain = resolveFallbackChain(DREAMER_AGENT, "");
+        expect(chain.length).toBeGreaterThan(0);
+    });
+
+    test("returns builtin chain for empty array", () => {
+        const chain = resolveFallbackChain(DREAMER_AGENT, []);
+        expect(chain.length).toBeGreaterThan(0);
+    });
+
+    test("user-only when user provides valid fallback_models string", () => {
+        const chain = resolveFallbackChain(DREAMER_AGENT, "anthropic/claude-sonnet-4-6");
+        expect(chain).toEqual(["anthropic/claude-sonnet-4-6"]);
+    });
+
+    test("user-only when user provides valid fallback_models array", () => {
+        const chain = resolveFallbackChain(DREAMER_AGENT, [
+            "anthropic/claude-sonnet-4-6",
+            "google/gemini-3-flash",
+        ]);
+        expect(chain).toEqual(["anthropic/claude-sonnet-4-6", "google/gemini-3-flash"]);
+    });
+
+    test("dedupes user-provided list", () => {
+        const chain = resolveFallbackChain(DREAMER_AGENT, [
+            "anthropic/claude-sonnet-4-6",
+            "anthropic/claude-sonnet-4-6",
+            "google/gemini-3-flash",
+        ]);
+        expect(chain).toEqual(["anthropic/claude-sonnet-4-6", "google/gemini-3-flash"]);
+    });
+
+    test("strips invalid 'provider/model' entries", () => {
+        const chain = resolveFallbackChain(DREAMER_AGENT, [
+            "anthropic/claude-sonnet-4-6",
+            "no-slash-here",
+            "/leading-slash",
+            "trailing-slash/",
+            "",
+            "  ",
+        ]);
+        expect(chain).toEqual(["anthropic/claude-sonnet-4-6"]);
+    });
+
+    test("trims whitespace in user entries", () => {
+        const chain = resolveFallbackChain(DREAMER_AGENT, [
+            "  anthropic/claude-sonnet-4-6  ",
+            "\tgoogle/gemini-3-flash\n",
+        ]);
+        expect(chain).toEqual(["anthropic/claude-sonnet-4-6", "google/gemini-3-flash"]);
+    });
+
+    test("returns empty array for unknown agent with no user fallbacks", () => {
+        const chain = resolveFallbackChain("unknown-agent", undefined);
+        expect(chain).toEqual([]);
+    });
+
+    test("returns user fallbacks for unknown agent when provided", () => {
+        const chain = resolveFallbackChain("unknown-agent", ["foo/bar"]);
+        expect(chain).toEqual(["foo/bar"]);
+    });
+
+    test("HISTORIAN_AGENT has builtin chain", () => {
+        const chain = resolveFallbackChain(HISTORIAN_AGENT, undefined);
+        expect(chain.length).toBeGreaterThan(0);
+    });
+
+    test("SIDEKICK_AGENT has builtin chain", () => {
+        const chain = resolveFallbackChain(SIDEKICK_AGENT, undefined);
+        expect(chain.length).toBeGreaterThan(0);
+    });
+
+    test("user-only policy: builtin not appended even if user set short list", () => {
+        const chain = resolveFallbackChain(DREAMER_AGENT, ["anthropic/claude-sonnet-4-6"]);
+        expect(chain).toEqual(["anthropic/claude-sonnet-4-6"]);
+        // Confirm length is exactly 1, not user+builtin
+        expect(chain.length).toBe(1);
+    });
+});
+
+describe("parseProviderModel", () => {
+    test("parses standard provider/model", () => {
+        expect(parseProviderModel("anthropic/claude-sonnet-4-6")).toEqual({
+            providerID: "anthropic",
+            modelID: "claude-sonnet-4-6",
+        });
+    });
+
+    test("handles model id with slashes (only splits on first slash)", () => {
+        expect(parseProviderModel("lemonade/GLM-4.7-Flash-GGUF/main")).toEqual({
+            providerID: "lemonade",
+            modelID: "GLM-4.7-Flash-GGUF/main",
+        });
+    });
+
+    test("trims whitespace", () => {
+        expect(parseProviderModel("  anthropic/claude-sonnet-4-6  ")).toEqual({
+            providerID: "anthropic",
+            modelID: "claude-sonnet-4-6",
+        });
+    });
+
+    test("returns null for no slash", () => {
+        expect(parseProviderModel("anthropic")).toBeNull();
+    });
+
+    test("returns null for leading slash", () => {
+        expect(parseProviderModel("/claude-sonnet-4-6")).toBeNull();
+    });
+
+    test("returns null for trailing slash", () => {
+        expect(parseProviderModel("anthropic/")).toBeNull();
+    });
+
+    test("returns null for empty string", () => {
+        expect(parseProviderModel("")).toBeNull();
+    });
+});

package/src/shared/resolve-fallbacks.ts

@@ -0,0 +1,76 @@
+import { getAgentFallbackModels } from "./model-requirements";
+
+/**
+ * Resolve the final fallback model list to attempt for an OpenCode subagent
+ * call.
+ *
+ * Policy (decided 2026-05-10):
+ *   - If user configured explicit `fallback_models` in their magic-context.jsonc
+ *     for this agent: use ONLY those. Respects user intent, no surprise
+ *     providers.
+ *   - If user did NOT configure any: fall back to the plugin's builtin
+ *     provider-agnostic chain (`AGENT_MODEL_REQUIREMENTS`).
+ *
+ * The returned list does NOT include the primary model — it's the ordered
+ * list of *alternates* to try after the primary fails. Each entry is
+ * "provider/modelID" form.
+ *
+ * Duplicates and empty strings are filtered. Entries that don't match the
+ * "provider/modelID" shape (must contain a "/" with non-empty parts) are
+ * also dropped — defensive guard against malformed user config.
+ */
+export function resolveFallbackChain(
+    agentName: string,
+    userFallbacks: readonly string[] | string | undefined,
+): string[] {
+    const userList = normalizeUserFallbacks(userFallbacks);
+
+    if (userList.length > 0) {
+        return dedupe(userList.filter(isValidModelSpec));
+    }
+
+    const builtin = getAgentFallbackModels(agentName);
+    if (!builtin || builtin.length === 0) return [];
+    return dedupe(builtin.filter(isValidModelSpec));
+}
+
+function normalizeUserFallbacks(userFallbacks: readonly string[] | string | undefined): string[] {
+    if (!userFallbacks) return [];
+    if (typeof userFallbacks === "string") {
+        const trimmed = userFallbacks.trim();
+        return trimmed ? [trimmed] : [];
+    }
+    return userFallbacks.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+
+function isValidModelSpec(spec: string): boolean {
+    const slash = spec.indexOf("/");
+    return slash > 0 && slash < spec.length - 1;
+}
+
+function dedupe(list: string[]): string[] {
+    const seen = new Set<string>();
+    const out: string[] = [];
+    for (const item of list) {
+        if (seen.has(item)) continue;
+        seen.add(item);
+        out.push(item);
+    }
+    return out;
+}
+
+/**
+ * Parse a "provider/modelID" string into the OpenCode `model` object shape.
+ * Returns null on invalid input.
+ *
+ * Note: only splits on the FIRST "/" — modelID can legitimately contain slashes
+ * (e.g. `lemonade/GLM-4.7-Flash-GGUF/main`).
+ */
+export function parseProviderModel(spec: string): { providerID: string; modelID: string } | null {
+    const slash = spec.indexOf("/");
+    if (slash < 1 || slash >= spec.length - 1) return null;
+    return {
+        providerID: spec.slice(0, slash).trim(),
+        modelID: spec.slice(slash + 1).trim(),
+    };
+}