@cortexkit/opencode-magic-context 0.15.1 → 0.15.3

package/src/shared/bounded-session-map.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "bun:test";
+import { BoundedSessionMap } from "./bounded-session-map";
+
+describe("BoundedSessionMap", () => {
+    it("rejects non-positive caps", () => {
+        expect(() => new BoundedSessionMap(0)).toThrow();
+        expect(() => new BoundedSessionMap(-5)).toThrow();
+        expect(() => new BoundedSessionMap(Number.NaN)).toThrow();
+    });
+
+    it("stores and retrieves values", () => {
+        const map = new BoundedSessionMap<number>(3);
+        map.set("a", 1);
+        map.set("b", 2);
+        expect(map.get("a")).toBe(1);
+        expect(map.get("b")).toBe(2);
+        expect(map.get("missing")).toBeUndefined();
+        expect(map.size).toBe(2);
+    });
+
+    it("evicts the oldest entry when cap is exceeded", () => {
+        const map = new BoundedSessionMap<string>(3);
+        map.set("a", "alpha");
+        map.set("b", "bravo");
+        map.set("c", "charlie");
+        map.set("d", "delta"); // evicts "a"
+        expect(map.has("a")).toBe(false);
+        expect(map.has("b")).toBe(true);
+        expect(map.has("c")).toBe(true);
+        expect(map.has("d")).toBe(true);
+        expect(map.size).toBe(3);
+    });
+
+    it("treats get() as a touch for LRU ordering", () => {
+        const map = new BoundedSessionMap<string>(3);
+        map.set("a", "alpha");
+        map.set("b", "bravo");
+        map.set("c", "charlie");
+        // Touch "a" — now "b" is the oldest.
+        expect(map.get("a")).toBe("alpha");
+        map.set("d", "delta");
+        expect(map.has("b")).toBe(false);
+        expect(map.has("a")).toBe(true);
+        expect(map.has("c")).toBe(true);
+        expect(map.has("d")).toBe(true);
+    });
+
+    it("peek() does NOT touch recency", () => {
+        const map = new BoundedSessionMap<number>(3);
+        map.set("a", 1);
+        map.set("b", 2);
+        map.set("c", 3);
+        expect(map.peek("a")).toBe(1);
+        // Adding a fourth entry should still evict "a" since peek didn't touch it.
+        map.set("d", 4);
+        expect(map.has("a")).toBe(false);
+    });
+
+    it("set() on existing key refreshes recency without growing size", () => {
+        const map = new BoundedSessionMap<number>(3);
+        map.set("a", 1);
+        map.set("b", 2);
+        map.set("c", 3);
+        map.set("a", 100); // refresh "a" to most-recent with new value
+        expect(map.size).toBe(3);
+        expect(map.get("a")).toBe(100);
+        map.set("d", 4); // evicts "b" (now oldest)
+        expect(map.has("b")).toBe(false);
+        expect(map.has("a")).toBe(true);
+    });
+
+    it("delete() removes entries and returns true when present", () => {
+        const map = new BoundedSessionMap<number>(3);
+        map.set("a", 1);
+        expect(map.delete("a")).toBe(true);
+        expect(map.delete("a")).toBe(false);
+        expect(map.size).toBe(0);
+    });
+
+    it("clear() drops all entries", () => {
+        const map = new BoundedSessionMap<number>(3);
+        map.set("a", 1);
+        map.set("b", 2);
+        map.clear();
+        expect(map.size).toBe(0);
+        expect(map.get("a")).toBeUndefined();
+    });
+
+    it("tolerates cap=1 edge case (every set evicts previous)", () => {
+        const map = new BoundedSessionMap<number>(1);
+        map.set("a", 1);
+        map.set("b", 2);
+        expect(map.has("a")).toBe(false);
+        expect(map.get("b")).toBe(2);
+        expect(map.size).toBe(1);
+    });
+});

package/src/shared/bounded-session-map.ts

@@ -0,0 +1,84 @@
+/**
+ * Bounded LRU map keyed by session id.
+ *
+ * Rationale: magic-context maintains several module-scope Maps that track
+ * per-session state (prepared injection cache, per-message token cache, etc.).
+ * These are cleared on the `session.deleted` event, but sessions that are
+ * never explicitly deleted — because OpenCode crashed, the user force-quit,
+ * the session was archived rather than deleted, or the session simply outlived
+ * the plugin process's interest in it — leak entries for the lifetime of the
+ * plugin process.
+ *
+ * In long-running OpenCode instances with thousands of sessions over time,
+ * an unbounded `Map<sessionId, LargeObject>` can retain tens of megabytes
+ * indefinitely. A session-scoped LRU with a generous cap (e.g. 100) covers
+ * any realistic working-set of active sessions a user actually cares about,
+ * while evicting cold session ids that will either never return or be
+ * rebuilt from durable SQLite state on their next transform pass.
+ *
+ * Implementation notes:
+ * - Built on `Map` which preserves insertion order. On every `set`/`get`
+ *   touch we delete+reinsert to move the key to the tail (most-recent).
+ * - Eviction drops the oldest entry (first in iteration order).
+ * - The cached value type is generic — callers decide what per-session state
+ *   to store. For injection/token state, all three properties of the cached
+ *   object are safe to throw away: they are either recomputable from the
+ *   messages array on the next pass, or reloadable from SQLite.
+ */
+export class BoundedSessionMap<V> {
+    private readonly maxEntries: number;
+    private readonly store = new Map<string, V>();
+
+    constructor(maxEntries: number) {
+        if (!Number.isFinite(maxEntries) || maxEntries < 1) {
+            throw new Error(`BoundedSessionMap: maxEntries must be >= 1, got ${maxEntries}`);
+        }
+        this.maxEntries = maxEntries;
+    }
+
+    get(sessionId: string): V | undefined {
+        const value = this.store.get(sessionId);
+        if (value === undefined) return undefined;
+        // Touch: move to most-recent position.
+        this.store.delete(sessionId);
+        this.store.set(sessionId, value);
+        return value;
+    }
+
+    /**
+     * Peek without touching recency — useful for `has`-style checks that
+     * should not rearrange LRU order. Use sparingly; `get` is the normal
+     * access path.
+     */
+    peek(sessionId: string): V | undefined {
+        return this.store.get(sessionId);
+    }
+
+    has(sessionId: string): boolean {
+        return this.store.has(sessionId);
+    }
+
+    set(sessionId: string, value: V): void {
+        if (this.store.has(sessionId)) {
+            // Refresh recency.
+            this.store.delete(sessionId);
+        } else if (this.store.size >= this.maxEntries) {
+            // Evict oldest entry. Map iteration is insertion-ordered.
+            const oldest = this.store.keys().next().value;
+            if (oldest !== undefined) this.store.delete(oldest);
+        }
+        this.store.set(sessionId, value);
+    }
+
+    delete(sessionId: string): boolean {
+        return this.store.delete(sessionId);
+    }
+
+    clear(): void {
+        this.store.clear();
+    }
+
+    get size(): number {
+        return this.store.size;
+    }
+}

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

@@ -0,0 +1,189 @@
+/// <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: string[]): 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(["@cortexkit/opencode-magic-context@latest", "some-other-plugin"]);
+        const result = detectConflicts(projectDir);
+        expect(result.hasConflict).toBe(false);
+    });
+});

package/src/shared/conflict-detector.ts

@@ -167,9 +167,60 @@ function readUserCompaction(): { auto: boolean; prune: boolean; resolved: boolea
 
 // --- 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.
+ */
+const DCP_PACKAGE_NAMES = new Set(["@tarquinen/opencode-dcp"]);
+
 function checkDcpPlugin(directory: string): boolean {
     const plugins = collectPluginEntries(directory);
-    return plugins.some((p) => p.includes("opencode-dcp"));
+    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).
+ */
+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);
 }
 
 function collectPluginEntries(directory: string): string[] {
@@ -206,6 +257,21 @@ function collectPluginEntries(directory: string): string[] {
 
 // --- 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/opencode-magic-context/issues/43.
+ *
+ * The legacy `@code-yeongyu/` scope is no longer used — both names are
+ * unscoped on npm.
+ */
+const OMO_PACKAGE_NAMES = new Set(["oh-my-opencode", "oh-my-openagent"]);
+
 function checkOmoHooks(directory: string): {
     preemptiveCompaction: boolean;
     contextWindowMonitor: boolean;
@@ -219,12 +285,7 @@ function checkOmoHooks(directory: string): {
 
     // First check if OMO is even installed
     const plugins = collectPluginEntries(directory);
-    const hasOmo = plugins.some(
-        (p) =>
-            p.includes("oh-my-opencode") ||
-            p.includes("oh-my-openagent") ||
-            p.includes("@code-yeongyu/"),
-    );
+    const hasOmo = plugins.some((p) => matchesPackageName(p, OMO_PACKAGE_NAMES));
     if (!hasOmo) return result;
 
     // Read OMO config to check disabled_hooks