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

package/src/shared/conflict-detector.test.ts

@@ -0,0 +1,232 @@
+/// <reference types="bun-types" />
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { detectConflicts } from "./conflict-detector";
+
+/**
+ * Regression tests for plugin-conflict detection. The previous substring-
+ * based matcher misclassified `oh-my-opencode-slim` and `opencode-dcp-fork`
+ * as the canonical plugins, causing magic-context to disable itself with
+ * a false-positive conflict warning. See issue #43.
+ */
+describe("detectConflicts", () => {
+    let projectDir: string;
+    let userConfigDir: string;
+    let originalEnv: Record<string, string | undefined>;
+
+    beforeEach(() => {
+        const root = mkdtempSync(join(tmpdir(), "mc-conflict-"));
+        projectDir = join(root, "project");
+        mkdirSync(projectDir, { recursive: true });
+        userConfigDir = join(root, "user-config", "opencode");
+        mkdirSync(userConfigDir, { recursive: true });
+
+        // Save and override every env var that affects config-path resolution.
+        // OPENCODE_CONFIG_DIR takes precedence over XDG_CONFIG_HOME, so we set
+        // it directly and clear XDG to fully isolate from any inherited or
+        // test-leaked state.
+        originalEnv = {
+            OPENCODE_CONFIG_DIR: process.env.OPENCODE_CONFIG_DIR,
+            XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
+            OPENCODE_DISABLE_AUTOCOMPACT: process.env.OPENCODE_DISABLE_AUTOCOMPACT,
+        };
+        process.env.OPENCODE_CONFIG_DIR = userConfigDir;
+        delete process.env.XDG_CONFIG_HOME;
+        // Disable auto-compaction default during tests so we isolate plugin
+        // detection from compaction detection.
+        process.env.OPENCODE_DISABLE_AUTOCOMPACT = "1";
+    });
+
+    afterEach(() => {
+        for (const [k, v] of Object.entries(originalEnv)) {
+            if (v === undefined) delete process.env[k];
+            else process.env[k] = v;
+        }
+        // Test directories live under tmpdir(); cleanup is best-effort.
+        rmSync(projectDir, { recursive: true, force: true });
+        rmSync(userConfigDir, { recursive: true, force: true });
+    });
+
+    function writeProjectConfig(plugins: Array<string | [string, unknown]>): void {
+        writeFileSync(join(projectDir, "opencode.json"), JSON.stringify({ plugin: plugins }));
+    }
+
+    // --- DCP detection ---
+
+    describe("DCP detection", () => {
+        it("matches the canonical @tarquinen/opencode-dcp package", () => {
+            writeProjectConfig(["@tarquinen/opencode-dcp"]);
+            const result = detectConflicts(projectDir);
+            expect(result.conflicts.dcpPlugin).toBe(true);
+        });
+
+        it("matches the canonical package with a version suffix", () => {
+            writeProjectConfig(["@tarquinen/opencode-dcp@latest"]);
+            const result = detectConflicts(projectDir);
+            expect(result.conflicts.dcpPlugin).toBe(true);
+        });
+
+        it("matches with a semver range suffix", () => {
+            writeProjectConfig(["@tarquinen/opencode-dcp@^3.1.0"]);
+            const result = detectConflicts(projectDir);
+            expect(result.conflicts.dcpPlugin).toBe(true);
+        });
+
+        it("does NOT match a fork with a different package name", () => {
+            writeProjectConfig(["@some-fork/opencode-dcp-fork"]);
+            const result = detectConflicts(projectDir);
+            expect(result.conflicts.dcpPlugin).toBe(false);
+        });
+
+        it("does NOT match a file:// path that contains 'opencode-dcp'", () => {
+            writeProjectConfig(["file:///home/user/work/opencode-dcp-fork"]);
+            const result = detectConflicts(projectDir);
+            expect(result.conflicts.dcpPlugin).toBe(false);
+        });
+    });
+
+    // --- OMO detection (the issue #43 case) ---
+
+    describe("OMO detection", () => {
+        it("matches the canonical oh-my-opencode package", () => {
+            writeProjectConfig(["oh-my-opencode"]);
+            const result = detectConflicts(projectDir);
+            // No OMO config = hooks default ACTIVE = all three flagged
+            expect(result.conflicts.omoPreemptiveCompaction).toBe(true);
+            expect(result.conflicts.omoContextWindowMonitor).toBe(true);
+            expect(result.conflicts.omoAnthropicRecovery).toBe(true);
+        });
+
+        it("matches the canonical oh-my-openagent package alias", () => {
+            writeProjectConfig(["oh-my-openagent"]);
+            const result = detectConflicts(projectDir);
+            expect(result.conflicts.omoPreemptiveCompaction).toBe(true);
+        });
+
+        it("matches a canonical OMO with a version suffix", () => {
+            writeProjectConfig(["oh-my-opencode@3.17.5", "oh-my-openagent@latest"]);
+            const result = detectConflicts(projectDir);
+            expect(result.conflicts.omoPreemptiveCompaction).toBe(true);
+            expect(result.conflicts.omoContextWindowMonitor).toBe(true);
+            expect(result.conflicts.omoAnthropicRecovery).toBe(true);
+        });
+
+        it("does NOT match oh-my-opencode-slim (issue #43)", () => {
+            writeProjectConfig(["oh-my-opencode-slim"]);
+            const result = detectConflicts(projectDir);
+            expect(result.hasConflict).toBe(false);
+            expect(result.conflicts.omoPreemptiveCompaction).toBe(false);
+            expect(result.conflicts.omoContextWindowMonitor).toBe(false);
+            expect(result.conflicts.omoAnthropicRecovery).toBe(false);
+        });
+
+        it("does NOT match oh-my-opencode-slim with a version suffix (issue #43)", () => {
+            writeProjectConfig(["oh-my-opencode-slim@latest", "oh-my-opencode-slim@1.0.3"]);
+            const result = detectConflicts(projectDir);
+            expect(result.hasConflict).toBe(false);
+        });
+
+        it("does NOT match a file:// path containing 'oh-my-opencode' (issue #43)", () => {
+            writeProjectConfig(["file:///home/user/workspace/oh-my-opencode-slim-dev"]);
+            const result = detectConflicts(projectDir);
+            expect(result.hasConflict).toBe(false);
+        });
+
+        it("does NOT match other forks under different package names", () => {
+            writeProjectConfig([
+                "oh-my-opencode-cli",
+                "@some-org/oh-my-opencode-fork",
+                "my-oh-my-opencode-customizations",
+            ]);
+            const result = detectConflicts(projectDir);
+            expect(result.hasConflict).toBe(false);
+        });
+
+        it("still detects canonical OMO when slim is also installed", () => {
+            // A user running both slim and the real OMO should still get
+            // the conflict warning for the real one.
+            writeProjectConfig(["oh-my-opencode-slim", "oh-my-opencode@latest"]);
+            const result = detectConflicts(projectDir);
+            expect(result.conflicts.omoPreemptiveCompaction).toBe(true);
+        });
+
+        it("respects disabled_hooks in project-level OMO config", () => {
+            writeProjectConfig(["oh-my-opencode"]);
+            // Use project-scoped OMO config to avoid relying on user
+            // config-path resolution, which can be leaked across files
+            // by `spyOn(getOpenCodeConfigPaths)` mocks in sibling tests.
+            writeFileSync(
+                join(projectDir, "oh-my-opencode.json"),
+                JSON.stringify({
+                    disabled_hooks: [
+                        "preemptive-compaction",
+                        "context-window-monitor",
+                        "anthropic-context-window-limit-recovery",
+                    ],
+                }),
+            );
+            const result = detectConflicts(projectDir);
+            expect(result.hasConflict).toBe(false);
+        });
+    });
+
+    // --- Combined / control cases ---
+
+    it("returns no conflicts for an empty plugin list", () => {
+        writeProjectConfig([]);
+        const result = detectConflicts(projectDir);
+        expect(result.hasConflict).toBe(false);
+    });
+
+    it("returns no conflicts for unrelated plugins", () => {
+        writeProjectConfig(["@wolfx/opencode-magic-context@latest", "some-other-plugin"]);
+        const result = detectConflicts(projectDir);
+        expect(result.hasConflict).toBe(false);
+    });
+
+    // --- Tuple plugin entries (issue #49) ---
+    // OpenCode supports ["pkg@version", { ...options }] tuple form.
+    // The old code spread the raw array into the plugin list, causing
+    // matchesPackageName to receive an array instead of a string → crash.
+
+    describe("tuple plugin entries (issue #49)", () => {
+        it("does not crash when a plugin is defined as a [name, options] tuple", () => {
+            writeProjectConfig([
+                "@wolfx/opencode-magic-context@latest",
+                ["@plannotator/opencode@latest", { workflow: "plan-agent" }],
+            ]);
+            expect(() => detectConflicts(projectDir)).not.toThrow();
+        });
+
+        it("detects DCP conflict when DCP is expressed as a tuple", () => {
+            writeProjectConfig([
+                "@wolfx/opencode-magic-context@latest",
+                ["@tarquinen/opencode-dcp@latest", {}],
+            ]);
+            const result = detectConflicts(projectDir);
+            expect(result.conflicts.dcpPlugin).toBe(true);
+        });
+
+        it("detects OMO conflict when OMO is expressed as a tuple", () => {
+            writeProjectConfig([["oh-my-opencode@latest", {}]]);
+            const result = detectConflicts(projectDir);
+            expect(result.conflicts.omoPreemptiveCompaction).toBe(true);
+        });
+
+        it("does not crash on mixed string and tuple entries with unrelated packages", () => {
+            writeProjectConfig([
+                "oh-my-opencode-slim",
+                [
+                    "@plannotator/opencode@latest",
+                    { workflow: "plan-agent", planningAgents: ["plan"] },
+                ],
+                "@wolfx/opencode-magic-context@latest",
+            ]);
+            const result = detectConflicts(projectDir);
+            expect(result.hasConflict).toBe(false);
+        });
+    });
+});

package/src/shared/conflict-detector.ts

@@ -0,0 +1,371 @@
+import { join } from "node:path";
+import { readJsoncFile } from "./jsonc-parser";
+import { getOpenCodeConfigPaths } from "./opencode-config-dir";
+
+interface OpenCodeConfig {
+    compaction?: {
+        auto?: boolean;
+        prune?: boolean;
+    };
+    // OpenCode allows plugins as plain strings or [name, options] tuples.
+    plugin?: Array<string | [string, unknown]>;
+}
+
+interface OmoConfig {
+    disabled_hooks?: string[];
+}
+
+export interface ConflictResult {
+    /** Whether any blocking conflict was found */
+    hasConflict: boolean;
+    /** Human-readable reasons for each conflict */
+    reasons: string[];
+    /** Which conflicts were found — used for targeted fixes */
+    conflicts: {
+        compactionAuto: boolean;
+        compactionPrune: boolean;
+        dcpPlugin: boolean;
+        omoPreemptiveCompaction: boolean;
+        omoContextWindowMonitor: boolean;
+        omoAnthropicRecovery: boolean;
+    };
+}
+
+/**
+ * Detect all conflicts that would prevent magic-context from working correctly.
+ * Checks: OpenCode compaction, DCP plugin, OMO conflicting hooks.
+ */
+export function detectConflicts(directory: string): ConflictResult {
+    const conflicts: ConflictResult["conflicts"] = {
+        compactionAuto: false,
+        compactionPrune: false,
+        dcpPlugin: false,
+        omoPreemptiveCompaction: false,
+        omoContextWindowMonitor: false,
+        omoAnthropicRecovery: false,
+    };
+    const reasons: string[] = [];
+
+    // --- Check OpenCode compaction config ---
+    const compactionResult = checkCompaction(directory);
+    if (compactionResult.auto) {
+        conflicts.compactionAuto = true;
+        reasons.push("OpenCode auto-compaction is enabled (compaction.auto=true)");
+    }
+    if (compactionResult.prune) {
+        conflicts.compactionPrune = true;
+        reasons.push("OpenCode prune is enabled (compaction.prune=true)");
+    }
+
+    // --- Check for DCP plugin ---
+    const dcpFound = checkDcpPlugin(directory);
+    if (dcpFound) {
+        conflicts.dcpPlugin = true;
+        reasons.push(
+            "opencode-dcp plugin is installed — it conflicts with Magic Context's context management",
+        );
+    }
+
+    // --- Check OMO conflicting hooks ---
+    const omoResult = checkOmoHooks(directory);
+    if (omoResult.preemptiveCompaction) {
+        conflicts.omoPreemptiveCompaction = true;
+        reasons.push(
+            "oh-my-opencode preemptive-compaction hook is active — it triggers compaction that conflicts with historian",
+        );
+    }
+    if (omoResult.contextWindowMonitor) {
+        conflicts.omoContextWindowMonitor = true;
+        reasons.push(
+            "oh-my-opencode context-window-monitor hook is active — it injects usage warnings that overlap with Magic Context nudges",
+        );
+    }
+    if (omoResult.anthropicRecovery) {
+        conflicts.omoAnthropicRecovery = true;
+        reasons.push(
+            "oh-my-opencode anthropic-context-window-limit-recovery hook is active — it triggers emergency compaction that bypasses historian",
+        );
+    }
+
+    return {
+        hasConflict: reasons.length > 0,
+        reasons,
+        conflicts,
+    };
+}
+
+// --- Compaction detection (extracted from opencode-compaction-detector.ts) ---
+
+function checkCompaction(directory: string): { auto: boolean; prune: boolean } {
+    if (process.env.OPENCODE_DISABLE_AUTOCOMPACT) {
+        return { auto: false, prune: false };
+    }
+
+    // Check project-level config first (higher precedence)
+    const projectResult = readProjectCompaction(directory);
+    if (projectResult.resolved) return projectResult;
+
+    // Fall back to user-level config
+    const userResult = readUserCompaction();
+    if (userResult.resolved) return userResult;
+
+    // Default: OpenCode has compaction enabled by default
+    return { auto: true, prune: false };
+}
+
+function readProjectCompaction(directory: string): {
+    auto: boolean;
+    prune: boolean;
+    resolved: boolean;
+} {
+    // .opencode/ config has higher precedence
+    const dotOcJsonc = join(directory, ".opencode", "opencode.jsonc");
+    const dotOcJson = join(directory, ".opencode", "opencode.json");
+    const dotOcConfig =
+        readJsoncFile<OpenCodeConfig>(dotOcJsonc) ?? readJsoncFile<OpenCodeConfig>(dotOcJson);
+
+    if (dotOcConfig?.compaction) {
+        const c = dotOcConfig.compaction;
+        if (c.auto !== undefined || c.prune !== undefined) {
+            return { auto: c.auto === true, prune: c.prune === true, resolved: true };
+        }
+    }
+
+    // Root-level project config
+    const rootJsonc = join(directory, "opencode.jsonc");
+    const rootJson = join(directory, "opencode.json");
+    const rootConfig =
+        readJsoncFile<OpenCodeConfig>(rootJsonc) ?? readJsoncFile<OpenCodeConfig>(rootJson);
+
+    if (rootConfig?.compaction) {
+        const c = rootConfig.compaction;
+        if (c.auto !== undefined || c.prune !== undefined) {
+            return { auto: c.auto === true, prune: c.prune === true, resolved: true };
+        }
+    }
+
+    return { auto: false, prune: false, resolved: false };
+}
+
+function readUserCompaction(): { auto: boolean; prune: boolean; resolved: boolean } {
+    try {
+        const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+        const config =
+            readJsoncFile<OpenCodeConfig>(paths.configJsonc) ??
+            readJsoncFile<OpenCodeConfig>(paths.configJson);
+
+        if (config?.compaction) {
+            const c = config.compaction;
+            if (c.auto !== undefined || c.prune !== undefined) {
+                return { auto: c.auto === true, prune: c.prune === true, resolved: true };
+            }
+        }
+    } catch {
+        // Intentional: config read is best-effort
+    }
+    return { auto: false, prune: false, resolved: false };
+}
+
+// --- DCP detection ---
+
+/**
+ * Canonical npm package names that represent the conflicting plugin.
+ * Matched against the npm-style segment of each plugin entry, so:
+ *   - "@tarquinen/opencode-dcp"           ✓ direct match
+ *   - "@tarquinen/opencode-dcp@latest"    ✓ version suffix stripped
+ *   - "@tarquinen/opencode-dcp@^3.1.0"    ✓ semver suffix stripped
+ *   - "file:///path/to/opencode-dcp-fork" ✗ unrelated path
+ *
+ * forks/renames that don't ship the conflicting transform/system hooks are
+ * intentionally NOT matched.
+ */
+export const DCP_PACKAGE_NAMES = new Set(["@tarquinen/opencode-dcp"]);
+
+function checkDcpPlugin(directory: string): boolean {
+    const plugins = collectPluginEntries(directory);
+    return plugins.some((p) => matchesPackageName(p, DCP_PACKAGE_NAMES));
+}
+
+/**
+ * Match a plugin entry against a set of canonical npm package names.
+ *
+ * A plugin entry can be:
+ *   - "pkg-name"
+ *   - "pkg-name@version"
+ *   - "@scope/pkg-name"
+ *   - "@scope/pkg-name@version"
+ *   - "file://..." or other URL/path forms (never matched here)
+ *
+ * For the canonical-name path we only match the exact package name (with
+ * optional version suffix). file:// paths and forks with different
+ * package names are intentionally NOT matched — even if a path string
+ * happens to contain a substring like "oh-my-opencode" (e.g. forks like
+ * "oh-my-opencode-slim" published under a different package name).
+ */
+export function matchesPackageName(entry: string, canonicalNames: Set<string>): boolean {
+    // Skip URL/path forms — only npm-style entries can be canonically matched.
+    // (Local file:// checkouts of canonical plugins are rare; users running
+    // those need to ensure the path itself doesn't match a fork's name.)
+    if (
+        entry.startsWith("file:") ||
+        entry.startsWith("http:") ||
+        entry.startsWith("https:") ||
+        entry.startsWith("/") ||
+        entry.startsWith("./") ||
+        entry.startsWith("../")
+    ) {
+        return false;
+    }
+
+    // Strip version suffix: "@scope/pkg@1.2.3" → "@scope/pkg"
+    // Careful with scoped packages: the leading "@" is part of the name.
+    const lastAt = entry.lastIndexOf("@");
+    const nameOnly = lastAt > 0 ? entry.slice(0, lastAt) : entry;
+    return canonicalNames.has(nameOnly);
+}
+
+/** Extract the package-name string from a plugin entry.
+ *  OpenCode supports two forms:
+ *   - plain string:        "@scope/pkg@latest"
+ *   - tuple [name, opts]:  ["@scope/pkg@latest", { ... }]
+ *  Returns null for any other shape (numbers, objects, etc.). */
+export function extractPluginName(entry: unknown): string | null {
+    if (typeof entry === "string") return entry;
+    if (Array.isArray(entry) && typeof entry[0] === "string") return entry[0];
+    return null;
+}
+
+function collectPluginEntries(directory: string): string[] {
+    const plugins: string[] = [];
+
+    const pushFrom = (entries: Array<string | [string, unknown]> | undefined) => {
+        if (!entries) return;
+        for (const entry of entries) {
+            const name = extractPluginName(entry);
+            if (name) plugins.push(name);
+        }
+    };
+
+    // Project-level configs
+    for (const configPath of [
+        join(directory, ".opencode", "opencode.jsonc"),
+        join(directory, ".opencode", "opencode.json"),
+        join(directory, "opencode.jsonc"),
+        join(directory, "opencode.json"),
+    ]) {
+        const config = readJsoncFile<OpenCodeConfig>(configPath);
+        pushFrom(config?.plugin);
+    }
+
+    // User-level config
+    try {
+        const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+        for (const configPath of [paths.configJsonc, paths.configJson]) {
+            const config = readJsoncFile<OpenCodeConfig>(configPath);
+            pushFrom(config?.plugin);
+        }
+    } catch {
+        // best-effort
+    }
+
+    return plugins;
+}
+
+// --- OMO hook detection ---
+
+/**
+ * Canonical OMO npm package names. The plugin publishes under both names as
+ * a versioned alias (latest 3.17.5 on npm at time of writing).
+ *
+ * Forks under a different package name (e.g. `oh-my-opencode-slim`,
+ * `oh-my-opencode-cli`, etc.) are intentionally NOT matched here — they
+ * don't ship the `preemptive-compaction`, `context-window-monitor`, or
+ * `anthropic-context-window-limit-recovery` hooks that conflict with
+ * Magic Context. See https://github.com/cortexkit/magic-context/issues/43.
+ *
+ * The legacy `@code-yeongyu/` scope is no longer used — both names are
+ * unscoped on npm.
+ */
+export const OMO_PACKAGE_NAMES = new Set(["oh-my-opencode", "oh-my-openagent"]);
+
+function checkOmoHooks(directory: string): {
+    preemptiveCompaction: boolean;
+    contextWindowMonitor: boolean;
+    anthropicRecovery: boolean;
+} {
+    const result = {
+        preemptiveCompaction: false,
+        contextWindowMonitor: false,
+        anthropicRecovery: false,
+    };
+
+    // First check if OMO is even installed
+    const plugins = collectPluginEntries(directory);
+    const hasOmo = plugins.some((p) => matchesPackageName(p, OMO_PACKAGE_NAMES));
+    if (!hasOmo) return result;
+
+    // Read OMO config to check disabled_hooks
+    const disabledHooks = readOmoDisabledHooks(directory);
+
+    // Hooks are ACTIVE unless explicitly in disabled_hooks
+    result.preemptiveCompaction = !disabledHooks.has("preemptive-compaction");
+    result.contextWindowMonitor = !disabledHooks.has("context-window-monitor");
+    result.anthropicRecovery = !disabledHooks.has("anthropic-context-window-limit-recovery");
+
+    return result;
+}
+
+function readOmoDisabledHooks(directory: string): Set<string> {
+    const disabled = new Set<string>();
+
+    // Check both old and new OMO config names
+    const configNames = [
+        "oh-my-opencode.jsonc",
+        "oh-my-opencode.json",
+        "oh-my-openagent.jsonc",
+        "oh-my-openagent.json",
+    ];
+
+    try {
+        const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+        for (const name of configNames) {
+            const configPath = join(paths.configDir, name);
+            const config = readJsoncFile<OmoConfig>(configPath);
+            if (config?.disabled_hooks) {
+                for (const hook of config.disabled_hooks) {
+                    disabled.add(hook);
+                }
+            }
+        }
+    } catch {
+        // best-effort
+    }
+
+    // Also check project-level OMO configs
+    for (const name of configNames) {
+        const config = readJsoncFile<OmoConfig>(join(directory, name));
+        if (config?.disabled_hooks) {
+            for (const hook of config.disabled_hooks) {
+                disabled.add(hook);
+            }
+        }
+    }
+
+    return disabled;
+}
+
+/**
+ * Generate a short conflict summary for ignored message display.
+ */
+export function formatConflictShort(result: ConflictResult): string {
+    if (!result.hasConflict) return "";
+
+    const lines = [
+        "⚠️ Magic Context is disabled due to conflicting configuration:",
+        "",
+        ...result.reasons.map((r) => `• ${r}`),
+        "",
+        "Fix: run `npx @wolfx/opencode-magic-context@latest doctor`",
+    ];
+    return lines.join("\n");
+}