@cortexkit/opencode-magic-context 0.17.2 → 0.19.0

package/src/shared/stable-json.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, test } from "bun:test";
+import { stableStringify } from "./stable-json";
+
+describe("stableStringify", () => {
+    test("primitive values match JSON.stringify", () => {
+        expect(stableStringify("hello")).toBe('"hello"');
+        expect(stableStringify(42)).toBe("42");
+        expect(stableStringify(true)).toBe("true");
+        expect(stableStringify(false)).toBe("false");
+        expect(stableStringify(null)).toBe("null");
+    });
+
+    test("undefined renders as literal string", () => {
+        expect(stableStringify(undefined)).toBe("undefined");
+    });
+
+    test("object keys sort by code-point order, not locale", () => {
+        // 'Z' (0x5a) sorts before 'a' (0x61) by code-point.
+        // localeCompare would sort 'a' before 'Z' in many locales.
+        // We want code-point semantics.
+        const input = { Z: 1, a: 2 };
+        expect(stableStringify(input)).toBe('{"Z":1,"a":2}');
+    });
+
+    test("nested objects sort recursively", () => {
+        const input = { b: { y: 1, x: 2 }, a: { z: 3, w: 4 } };
+        expect(stableStringify(input)).toBe('{"a":{"w":4,"z":3},"b":{"x":2,"y":1}}');
+    });
+
+    test("arrays preserve order", () => {
+        const input = [3, 1, 2];
+        expect(stableStringify(input)).toBe("[3,1,2]");
+    });
+
+    test("arrays of objects sort keys per element", () => {
+        const input = [
+            { b: 1, a: 2 },
+            { d: 3, c: 4 },
+        ];
+        expect(stableStringify(input)).toBe('[{"a":2,"b":1},{"c":4,"d":3}]');
+    });
+
+    test("identical objects with different key insertion order produce same string", () => {
+        const a = { foo: 1, bar: 2 };
+        const b = { bar: 2, foo: 1 };
+        expect(stableStringify(a)).toBe(stableStringify(b));
+    });
+
+    test("circular references render as marker, do not throw", () => {
+        const a: Record<string, unknown> = { x: 1 };
+        a.self = a;
+        expect(stableStringify(a)).toBe('{"self":"[Circular]","x":1}');
+    });
+
+    test("mixed cycle through array does not crash", () => {
+        const arr: unknown[] = [];
+        arr.push(arr);
+        expect(stableStringify(arr)).toBe('["[Circular]"]');
+    });
+
+    test("empty object and array", () => {
+        expect(stableStringify({})).toBe("{}");
+        expect(stableStringify([])).toBe("[]");
+    });
+
+    test("special string characters JSON-escaped in keys", () => {
+        const input = { 'with "quotes"': 1 };
+        expect(stableStringify(input)).toBe('{"with \\"quotes\\"":1}');
+    });
+
+    test("Unicode key sort by code-point, not by collation", () => {
+        // 'ä' (U+00E4) sorts AFTER 'z' (U+007A) by code-point.
+        // localeCompare in many locales would put 'ä' near 'a'.
+        const input = { z: 1, ä: 2 };
+        const result = stableStringify(input);
+        expect(result).toBe('{"z":1,"ä":2}');
+    });
+
+    test("deterministic across multiple calls", () => {
+        const input = { c: 3, a: 1, b: 2 };
+        const first = stableStringify(input);
+        const second = stableStringify(input);
+        const third = stableStringify(input);
+        expect(first).toBe(second);
+        expect(second).toBe(third);
+    });
+});

package/src/shared/stable-json.ts

@@ -0,0 +1,37 @@
+/**
+ * Process-local deterministic JSON serialization for JSON-like plain
+ * objects. Keys are sorted by code-point order (NOT locale-sensitive).
+ *
+ * Contract:
+ * - Stable for plain objects, arrays, primitives, and `null`.
+ * - `undefined` serialized as the string "undefined".
+ * - Circular references serialized as the string `"[Circular]"`.
+ * - **NOT** a canonical cross-runtime / cross-locale JSON serializer.
+ *   Two different runtimes that disagree on `JSON.stringify` of primitives
+ *   (none known today) would produce different output.
+ *
+ * Used for:
+ * - `tool_definition_measurements` fingerprint hashing
+ * - `pending_compaction_marker_state` CAS comparison
+ *
+ * If a future use case needs true canonical JSON (e.g. cross-process
+ * signing), build a separate utility — do NOT widen this contract.
+ */
+export function stableStringify(value: unknown, seen = new WeakSet<object>()): string {
+    if (value === undefined) return "undefined";
+    if (value === null || typeof value !== "object") return JSON.stringify(value) ?? String(value);
+    if (seen.has(value)) return '"[Circular]"';
+    seen.add(value);
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item, seen)).join(",")}]`;
+    }
+    // Code-point sort (NOT localeCompare). Stable across runtimes/locales.
+    const entries = Object.entries(value as Record<string, unknown>).sort(([a], [b]) => {
+        if (a < b) return -1;
+        if (a > b) return 1;
+        return 0;
+    });
+    return `{${entries
+        .map(([key, child]) => `${JSON.stringify(key)}:${stableStringify(child, seen)}`)
+        .join(",")}}`;
+}

package/src/shared/tag-transcript.ts

@@ -159,9 +159,10 @@ export function tagTranscript(
         const messageId = message.info.id;
 
         let textOrdinal = 0;
+        const parts = message.parts;
 
-        for (let partIndex = 0; partIndex < message.parts.length; partIndex += 1) {
-            const part = message.parts[partIndex];
+        for (let partIndex = 0; partIndex < parts.length; partIndex += 1) {
+            const part = parts[partIndex];
             if (part === undefined) continue;
 
             if (part.kind === "text") {

package/src/tui/data/context-db.ts

@@ -10,6 +10,7 @@ import type { RpcNotificationMessage, SidebarSnapshot, StatusDetail } from "../.
 export type { SidebarSnapshot, StatusDetail };
 
 let rpcClient: MagicContextRpcClient | null = null;
+let lastReceivedNotificationId = 0;
 
 function getStorageDir(): string {
     // Plugin v0.16+ uses the shared cortexkit/magic-context path so OpenCode
@@ -30,6 +31,7 @@ export function initRpcClient(directory: string): void {
 export function closeRpc(): void {
     rpcClient?.reset();
     rpcClient = null;
+    lastReceivedNotificationId = 0;
 }
 
 const EMPTY_SNAPSHOT: SidebarSnapshot = {
@@ -103,9 +105,19 @@ function recallSidebarSnapshot(sessionId: string, fallback: SidebarSnapshot): Si
         stickySidebarCache.delete(sessionId);
         return fallback;
     }
+    if (!hasInFlightEvidence(fallback)) {
+        stickySidebarCache.delete(sessionId);
+        return fallback;
+    }
     return cached.snapshot;
 }
 
+function hasInFlightEvidence(snapshot: SidebarSnapshot): boolean {
+    return (
+        snapshot.compartmentInProgress || snapshot.historianRunning || snapshot.pendingOpsCount > 0
+    );
+}
+
 /** Fetch sidebar snapshot from the server via RPC. */
 export async function loadSidebarSnapshot(
     sessionId: string,
@@ -225,8 +237,15 @@ export async function consumeTuiMessages(): Promise<TuiMessage[]> {
     try {
         const result = await rpcClient.call<{ messages: RpcNotificationMessage[] }>(
             "pending-notifications",
+            { lastReceivedId: lastReceivedNotificationId },
         );
-        return (result.messages ?? []).map((m) => ({
+        const messages = result.messages ?? [];
+        for (const message of messages) {
+            if (message.id > lastReceivedNotificationId) {
+                lastReceivedNotificationId = message.id;
+            }
+        }
+        return messages.map((m) => ({
             type: m.type,
             payload: m.payload,
             sessionId: m.sessionId,

package/src/tui/index.tsx

@@ -453,6 +453,111 @@ function showStatusDialog(api: TuiPluginApi) {
     })
 }
 
+/**
+ * Register Magic Context command palette entries, preferring the v1.14.42+
+ * `keymap.registerLayer` API and falling back to the legacy
+ * `api.command.register` for older hosts.
+ *
+ * The `keymap.registerLayer` shape uses `name`/`title`/`run`/`namespace`
+ * (see `@opencode-ai/plugin/tui` types) and is what the host's own legacy
+ * command-shim translates into. Calling it directly skips the deprecation
+ * warning and works without depending on the (now-deprecated) `api.command`
+ * namespace existing at all.
+ *
+ * Version coverage:
+ *   1.14.0–1.14.41 — `api.command.register` only
+ *   1.14.42–1.14.43 — both surfaces broken (api.command removed, keymap landed
+ *                     but with bugs); plugins crash on init either way
+ *   1.14.44+        — `api.keymap.registerLayer` canonical, `api.command` shim
+ */
+function registerCommandPaletteEntries(api: TuiPluginApi): void {
+    type ApiAny = {
+        keymap?: {
+            registerLayer?: (layer: {
+                commands: Array<Record<string, unknown>>
+                bindings: Array<Record<string, unknown>>
+            }) => unknown
+        }
+        command?: {
+            register?: (cb: () => Array<Record<string, unknown>>) => unknown
+        }
+    }
+    const apiAny = api as unknown as ApiAny
+
+    if (typeof apiAny.keymap?.registerLayer === "function") {
+        // Audit Finding #2 hardening: even when registerLayer exists as a
+        // function, the underlying keymap implementation in OpenCode TUI
+        // 1.14.42-1.14.43 can throw at call time. Without the try-catch the
+        // `return` below would propagate the throw and the legacy
+        // `command.register` fallback path (~20 lines down) would be
+        // unreachable. The cost is one debug log on the rare broken-TUI
+        // build; the benefit is that older command.register-only TUIs
+        // running alongside a partially-broken keymap surface still get
+        // their command palette entries.
+        try {
+            apiAny.keymap.registerLayer({
+                commands: [
+                    {
+                        namespace: "palette",
+                        name: "magic-context.status",
+                        title: "Magic Context: Status",
+                        category: "Magic Context",
+                        run() {
+                            showStatusDialog(api)
+                        },
+                    },
+                    {
+                        namespace: "palette",
+                        name: "magic-context.recomp",
+                        title: "Magic Context: Recomp",
+                        category: "Magic Context",
+                        run() {
+                            showRecompDialog(api)
+                        },
+                    },
+                ],
+                bindings: [],
+            })
+            return
+        } catch (err) {
+            console.debug(
+                "[magic-context-tui] keymap.registerLayer threw; falling back to command.register",
+                err,
+            )
+            // Fall through to legacy registration.
+        }
+    }
+
+    if (typeof apiAny.command?.register === "function") {
+        apiAny.command.register(() => [
+            {
+                title: "Magic Context: Status",
+                value: "magic-context.status",
+                category: "Magic Context",
+                onSelect() {
+                    showStatusDialog(api)
+                },
+            },
+            {
+                title: "Magic Context: Recomp",
+                value: "magic-context.recomp",
+                category: "Magic Context",
+                onSelect() {
+                    showRecompDialog(api)
+                },
+            },
+        ])
+        return
+    }
+
+    // Neither API surface is present. The TUI host can still load — we only
+    // lose the command palette entry points. The sidebar (registered above
+    // via api.slots.register) remains visible. Status/Recomp are still
+    // reachable through the server-side `/ctx-status` and `/ctx-recomp`
+    // slash commands, which the server handler bridges to the TUI dialogs
+    // via RPC.
+}
+
 const tui: TuiPlugin = async (api, _options, meta) => {
     // Initialize RPC client for server communication
     const directory = api.state.path.directory ?? ""
@@ -465,24 +570,15 @@ const tui: TuiPlugin = async (api, _options, meta) => {
     // are registered server-side so there's only one /ctx-* registration).
     // The server detects TUI mode and sends dialog requests via RPC instead
     // of sendIgnoredMessage.
-    api.command.register(() => [
-        {
-            title: "Magic Context: Status",
-            value: "magic-context.status",
-            category: "Magic Context",
-            onSelect() {
-                showStatusDialog(api)
-            },
-        },
-        {
-            title: "Magic Context: Recomp",
-            value: "magic-context.recomp",
-            category: "Magic Context",
-            onSelect() {
-                showRecompDialog(api)
-            },
-        },
-    ])
+    //
+    // OpenCode 1.14.42 removed `api.command.register` entirely
+    // (anomalyco/opencode#26053). A later patch (1.14.44+) reinstated it as
+    // a deprecated shim that translates to `api.keymap.registerLayer`. To
+    // work across all hosts (1.14.0–1.14.41 with command-only, the broken
+    // 1.14.42–1.14.43, and 1.14.44+ where both exist), we prefer
+    // `api.keymap.registerLayer` and fall back to `api.command.register`
+    // only when keymap is missing.
+    registerCommandPaletteEntries(api)
 
     // Poll for server→TUI messages: toasts and dialog requests.
     // Single poller because consumeTuiMessages() is destructive (deletes consumed rows).