@cortexkit/opencode-magic-context 0.24.0 → 0.24.1

package/src/shared/tui-preferences.ts

@@ -0,0 +1,303 @@
+import { readFileSync, watch } from "node:fs";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { parse, stringify } from "comment-json";
+
+// Shared preferences file for OpenCode TUI plugins. One top-level key per plugin
+// (short, non-integer-like name, e.g. "magic-context"). The file is OPTIONAL:
+// every reader falls back to defaults when it is missing or malformed.
+//
+// Cross-plugin convention (anthropic-auth / aft / magic-context all mirror it):
+//   - same file name + env override + lookup order,
+//   - byte-identical `computeEffectiveOrder` so the three sort consistently,
+//   - a coordinated default-order ladder (anthropic-auth 160, AFT 180, MC 200).
+//
+// MC uses `comment-json` (already a dep, Bun-safe) for the WRITE path — a full
+// parse → mutate-one-key → stringify round-trip that preserves comments and
+// sibling plugins' keys. (anthropic-auth uses jsonc-parser's surgical `modify`;
+// AFT and MC use comment-json. Both are interop-safe as long as a sibling key's
+// values AND comments survive — asserted by the interop test.)
+
+export const TUI_PREFS_FILE_ENV = "OPENCODE_TUI_PREFERENCES_FILE";
+const FILE_NAME = "tui-preferences.jsonc";
+
+export function getTuiPreferencesFile(): string {
+    const override = process.env[TUI_PREFS_FILE_ENV];
+    if (override) return override;
+    const configDir =
+        process.env.OPENCODE_CONFIG_DIR ||
+        join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "opencode");
+    return join(configDir, FILE_NAME);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// Tolerant read: a missing file, parse error, or non-object root all resolve to
+// {} so the sidebar never crashes on hand-edited content. Never throws.
+export async function readTuiPreferencesFile(): Promise<Record<string, unknown>> {
+    try {
+        const raw = await readFile(getTuiPreferencesFile(), "utf8");
+        if (raw.trim() === "") return {};
+        const root: unknown = parse(raw);
+        return isRecord(root) ? (root as Record<string, unknown>) : {};
+    } catch {
+        return {};
+    }
+}
+
+// Synchronous tolerant read — used once at slot mount to seed the initial
+// collapse state and effective order WITHOUT a frame of async flicker (the
+// sidebar must render at its final width/collapse on the very first paint).
+// Same tolerance contract as the async reader. Never throws.
+export function readTuiPreferencesFileSync(): Record<string, unknown> {
+    try {
+        const raw = readFileSync(getTuiPreferencesFile(), "utf8");
+        if (raw.trim() === "") return {};
+        const root: unknown = parse(raw);
+        return isRecord(root) ? (root as Record<string, unknown>) : {};
+    } catch {
+        return {};
+    }
+}
+
+export const PLUGIN_KEY = "magic-context";
+export const DEFAULT_SLOT_ORDER = 200;
+
+export interface MagicContextTuiPrefs {
+    forceToTop: boolean;
+    order: number;
+    startCollapsed: boolean;
+    rememberCollapsed: boolean;
+    // null = never persisted; seed the UI from `startCollapsed` instead.
+    collapsed: boolean | null;
+    header: {
+        label: string;
+    };
+    sections: {
+        historian: boolean;
+        memory: boolean;
+        status: boolean;
+        dreamer: boolean;
+        stats: boolean;
+    };
+}
+
+export type TuiSections = MagicContextTuiPrefs["sections"];
+
+export const DEFAULT_PREFS: MagicContextTuiPrefs = {
+    forceToTop: false,
+    order: DEFAULT_SLOT_ORDER,
+    startCollapsed: false,
+    rememberCollapsed: true,
+    collapsed: null,
+    header: { label: "Magic Context" },
+    sections: {
+        historian: true,
+        memory: true,
+        status: true,
+        dreamer: true,
+        stats: true,
+    },
+};
+
+function bool(value: unknown, fallback: boolean): boolean {
+    return typeof value === "boolean" ? value : fallback;
+}
+
+function int(value: unknown, fallback: number, min: number, max: number): number {
+    if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+    return Math.min(Math.max(Math.round(value), min), max);
+}
+
+function label(value: unknown, fallback: string, maxLength: number): string {
+    if (typeof value !== "string" || value.length === 0) return fallback;
+    return value.slice(0, maxLength);
+}
+
+// Per-key validation: every value is independently clamped/defaulted so one bad
+// entry never poisons the rest. Never throws. A missing/non-object MC key →
+// full defaults clone.
+export function resolveMagicContextPrefs(root: Record<string, unknown>): MagicContextTuiPrefs {
+    const entry = root[PLUGIN_KEY];
+    if (!isRecord(entry)) return structuredClone(DEFAULT_PREFS);
+
+    const d = DEFAULT_PREFS;
+    const header = isRecord(entry.header) ? entry.header : {};
+    const sections = isRecord(entry.sections) ? entry.sections : {};
+
+    return {
+        forceToTop: bool(entry.forceToTop, d.forceToTop),
+        order: int(entry.order, d.order, -10000, 10000),
+        startCollapsed: bool(entry.startCollapsed, d.startCollapsed),
+        rememberCollapsed: bool(entry.rememberCollapsed, d.rememberCollapsed),
+        collapsed: typeof entry.collapsed === "boolean" ? entry.collapsed : null,
+        header: {
+            label: label(header.label, d.header.label, 24),
+        },
+        sections: {
+            historian: bool(sections.historian, d.sections.historian),
+            memory: bool(sections.memory, d.sections.memory),
+            status: bool(sections.status, d.sections.status),
+            dreamer: bool(sections.dreamer, d.sections.dreamer),
+            stats: bool(sections.stats, d.sections.stats),
+        },
+    };
+}
+
+const FORCE_TOP_BASE = -100000;
+
+// Shared forceToTop convention — MUST stay byte-identical across anthropic-auth,
+// AFT, and magic-context or the three sort inconsistently against each other.
+// Forced plugins sort below FORCE_TOP_BASE, ordered among themselves by their
+// top-level key's position in the file, so users reprioritize by reordering
+// keys. The user-facing `order` knob clamps to -10000..10000, strictly above the
+// forced band, so a manual order can never beat forceToTop. Host slots render
+// ascending by order; OpenCode's built-ins occupy 100-500.
+//
+// Key-naming requirement: plugin keys must be non-integer-like short names (e.g.
+// "magic-context"). JS object key iteration hoists integer-like keys ("0", "42")
+// ahead of string keys, which would skew the indexOf-based ordering of forced
+// plugins. The shared convention requires non-numeric names.
+export function computeEffectiveOrder(
+    root: Record<string, unknown>,
+    pluginKey: string,
+    defaultOrder: number,
+): number {
+    const entry = root[pluginKey];
+    if (!isRecord(entry)) return defaultOrder;
+    if (entry.forceToTop === true) {
+        return FORCE_TOP_BASE + Object.keys(root).indexOf(pluginKey);
+    }
+    return int(entry.order, defaultOrder, -10000, 10000);
+}
+
+const TEMPLATE = `// Shared preferences for OpenCode TUI plugins.
+// One top-level key per plugin (short name). See each plugin's README for its
+// supported settings. This file is safe to hand-edit; plugins update individual
+// keys and preserve the rest (values and comments).
+{}
+`;
+
+type JsonValue = string | number | boolean | null;
+
+// Set a nested path on a comment-json root, creating intermediate plain objects
+// as needed. Mutating an existing leaf preserves its comments; sibling keys are
+// untouched. Returns false when the path is blocked by a non-object value.
+function setDeep(root: Record<string, unknown>, path: string[], value: JsonValue): boolean {
+    let node: Record<string, unknown> = root;
+    for (let i = 0; i < path.length - 1; i += 1) {
+        const key = path[i];
+        const child = node[key];
+        if (child === undefined || child === null) {
+            node[key] = {};
+        } else if (!isRecord(child)) {
+            return false;
+        }
+        node = node[key] as Record<string, unknown>;
+    }
+    node[path[path.length - 1]] = value;
+    return true;
+}
+
+async function writePreference(pluginKey: string, path: string[], value: JsonValue): Promise<void> {
+    const file = getTuiPreferencesFile();
+    await mkdir(dirname(file), { recursive: true });
+    let text: string;
+    try {
+        text = await readFile(file, "utf8");
+    } catch {
+        text = "";
+    }
+    if (text.trim() === "") text = TEMPLATE;
+
+    let root: unknown;
+    try {
+        root = parse(text);
+    } catch {
+        // The shared file is currently malformed. Skip the write rather than
+        // clobber sibling plugins' keys — the user fixes the file, persistence
+        // resumes. (Collapse just won't survive restart until then.)
+        return;
+    }
+    if (!isRecord(root)) root = {};
+    if (!setDeep(root as Record<string, unknown>, [pluginKey, ...path], value)) {
+        return;
+    }
+
+    const next = `${stringify(root, null, 2)}\n`;
+    const tmp = `${file}.${process.pid}.tmp`;
+    await writeFile(tmp, next, "utf8");
+    await rename(tmp, file);
+}
+
+let writeChain: Promise<void> = Promise.resolve();
+
+// Writes are serialized on a promise chain: each update re-reads the file,
+// applies a comment-preserving edit to one property, and replaces the file
+// atomically (temp + rename in the same directory — the only safe cross-process
+// swap). Best-effort by design; preferences are never worth crashing the TUI.
+export function queueTuiPreferenceUpdate(
+    pluginKey: string,
+    path: string[],
+    value: JsonValue,
+): Promise<void> {
+    writeChain = writeChain.then(() => writePreference(pluginKey, path, value)).catch(() => {});
+    return writeChain;
+}
+
+const WATCH_DEBOUNCE_MS = 150;
+
+// Watches the DIRECTORY, not the file: editors and our own atomic writes replace
+// the file via rename, which kills file-level watchers.
+//
+// Two-stage filtering: (1) a cheap filename pre-filter on the prefs name or our
+// `.tmp`; (2) inside the debounce, re-read and compare against last-seen content
+// — the authority. Some platforms (macOS FSEvents, some inotify backends)
+// misattribute a sibling rename to the real filename, so a name filter alone
+// still produces strays; the content compare is robust against that, coalesced
+// events, and mtime granularity.
+//
+// Returns a disposer; never throws.
+export function watchTuiPreferences(onChange: () => void): () => void {
+    const file = getTuiPreferencesFile();
+    const name = basename(file);
+    let timer: ReturnType<typeof setTimeout> | null = null;
+    let lastSeen: string | null = null;
+    // Seed asynchronously; a real change before the seed resolves still wins
+    // because the debounce re-reads fresh and compares against `lastSeen` (null
+    // → does not match → fires).
+    void readFile(file, "utf8")
+        .then((text) => {
+            if (lastSeen === null) lastSeen = text;
+        })
+        .catch(() => {});
+    try {
+        const watcher = watch(dirname(file), (_event, filename) => {
+            const isOurs =
+                filename === name ||
+                (filename?.startsWith(`${name}.`) && filename.endsWith(".tmp"));
+            if (filename != null && !isOurs) return;
+            if (timer) clearTimeout(timer);
+            timer = setTimeout(() => {
+                timer = null;
+                void readFile(file, "utf8")
+                    .catch(() => null)
+                    .then((text) => {
+                        if (text === null) return;
+                        if (text === lastSeen) return;
+                        lastSeen = text;
+                        onChange();
+                    });
+            }, WATCH_DEBOUNCE_MS);
+        });
+        return () => {
+            if (timer) clearTimeout(timer);
+            watcher.close();
+        };
+    } catch {
+        return () => {};
+    }
+}

package/src/tui/slots/sidebar-content.tsx

@@ -4,6 +4,17 @@ import type { TuiSlotPlugin, TuiPluginApi, TuiThemeCurrent } from "@opencode-ai/
 import packageJson from "../../../package.json"
 import { loadSidebarSnapshot, type SidebarSnapshot } from "../data/context-db"
 import { formatThresholdPercent } from "../../shared/format-threshold"
+import {
+    computeEffectiveOrder,
+    DEFAULT_SLOT_ORDER,
+    type MagicContextTuiPrefs,
+    PLUGIN_KEY,
+    queueTuiPreferenceUpdate,
+    readTuiPreferencesFile,
+    readTuiPreferencesFileSync,
+    resolveMagicContextPrefs,
+    watchTuiPreferences,
+} from "../../shared/tui-preferences"
 
 // Module-level hook so the upgrade/recomp dialog can kick the sidebar into its
 // fast recomp self-poll the INSTANT the user confirms — without waiting for a
@@ -17,6 +28,64 @@ export function kickRecompProgressRefresh(): void {
 const SINGLE_BORDER = { type: "single" } as any
 const REFRESH_DEBOUNCE_MS = 150
 
+export interface SidebarController {
+    prefs: () => MagicContextTuiPrefs
+    collapsed: () => boolean
+    toggleCollapsed: () => void
+}
+
+// The TUI may unmount and remount sidebar_content when the user switches views
+// (main -> subagent -> main). A remount re-runs the component body, so a signal
+// created inside the component would reset to its seed. The controller lives in
+// the slot-factory closure (plugin/process lifetime) and owns the durable
+// prefs/collapse signals plus the single shared file watcher, so collapse state
+// and live pref reloads survive remounts. No Solid effects/memos here — those
+// need an owner; the poll-interval effect stays inside the component.
+function createSidebarController(initialPrefs: MagicContextTuiPrefs): SidebarController {
+    const [prefs, setPrefs] = createSignal<MagicContextTuiPrefs>(initialPrefs)
+    const seedCollapsed =
+        initialPrefs.rememberCollapsed && initialPrefs.collapsed != null
+            ? initialPrefs.collapsed
+            : initialPrefs.startCollapsed
+    const [collapsed, setCollapsed] = createSignal(seedCollapsed)
+    let lastPersistedCollapsed: boolean | null = initialPrefs.collapsed
+    let lastApplied = JSON.stringify(initialPrefs)
+
+    // Watcher lives for the process lifetime — intentionally never disposed.
+    // Collapse echo guard: lastPersistedCollapsed advances only once our own
+    // write lands, so a watcher echo of the value we just wrote is rejected by
+    // the `!==` check and cannot revert a user click.
+    watchTuiPreferences(() => {
+        void (async () => {
+            const next = resolveMagicContextPrefs(await readTuiPreferencesFile())
+            const serialized = JSON.stringify(next)
+            if (serialized === lastApplied) return
+            lastApplied = serialized
+            setPrefs(next)
+            if (
+                next.rememberCollapsed &&
+                next.collapsed != null &&
+                next.collapsed !== lastPersistedCollapsed
+            ) {
+                lastPersistedCollapsed = next.collapsed
+                setCollapsed(next.collapsed)
+            }
+        })()
+    })
+
+    function toggleCollapsed() {
+        const next = !collapsed()
+        setCollapsed(next)
+        if (prefs().rememberCollapsed) {
+            void queueTuiPreferenceUpdate(PLUGIN_KEY, ["collapsed"], next).then(() => {
+                lastPersistedCollapsed = next
+            })
+        }
+    }
+
+    return { prefs, collapsed, toggleCollapsed }
+}
+
 function compactTokens(value: number): string {
     if (value >= 1_000_000) return `${(value / 1_000_000).toFixed(1)}M`
     if (value >= 1_000) return `${(value / 1_000).toFixed(0)}K`
@@ -382,12 +451,15 @@ const SidebarContent = (props: {
     api: TuiPluginApi
     sessionID: () => string
     theme: TuiThemeCurrent
+    controller: SidebarController
 }) => {
     const [snapshot, setSnapshot] = createSignal<SidebarSnapshot | null>(null)
-    // Collapsed view: progress bar + 3 summary lines (Historian / Memories /
-    // Status), no per-category legend or section grid. In-memory only (resets
-    // to expanded on TUI restart), mirroring the native MCP sidebar toggle.
-    const [collapsed, setCollapsed] = createSignal(false)
+    // Collapse state + section visibility prefs live in the controller (plugin
+    // closure), so they survive view-switch remounts and persist across restarts
+    // via ~/.config/opencode/tui-preferences.jsonc. Read reactively.
+    const collapsed = props.controller.collapsed
+    const sections = () => props.controller.prefs().sections
+    const headerLabel = () => props.controller.prefs().header.label
     let refreshTimer: ReturnType<typeof setTimeout> | undefined
     // Self-sustaining poll while a recomp/upgrade is running. Recomp work
     // happens in CHILD sessions whose message events are filtered out of the
@@ -610,11 +682,11 @@ const SidebarContent = (props: {
                 flexDirection="row"
                 justifyContent="space-between"
                 alignItems="center"
-                onMouseDown={() => setCollapsed((x) => !x)}
+                onMouseDown={() => props.controller.toggleCollapsed()}
             >
                 <box paddingLeft={1} paddingRight={1} backgroundColor={props.theme.accent}>
                     <text fg={props.theme.background}>
-                        <b>{collapsed() ? "▶ " : "▼ "}Magic Context</b>
+                        <b>{collapsed() ? "▶ " : "▼ "}{headerLabel()}</b>
                     </text>
                 </box>
                 <text fg={props.theme.textMuted}>v{packageJson.version}</text>
@@ -688,6 +760,8 @@ const SidebarContent = (props: {
             {!collapsed() && (
                 <>
             {/* Historian section */}
+            {sections().historian && (
+                <>
             <box width="100%" marginTop={1} flexDirection="row" justifyContent="space-between">
                 <text fg={props.theme.text}>
                     <b>Historian</b>
@@ -713,8 +787,12 @@ const SidebarContent = (props: {
             {s()?.recompProgress && (
                 <RecompProgressSection theme={props.theme} progress={s()!.recompProgress!} />
             )}
+                </>
+            )}
 
             {/* Memory section */}
+            {sections().memory && (
+                <>
             <SectionHeader theme={props.theme} title="Memory" />
             <StatRow
                 theme={props.theme}
@@ -730,9 +808,12 @@ const SidebarContent = (props: {
                     dim
                 />
             )}
+                </>
+            )}
 
             {/* Queue & Status */}
-            {((s()?.pendingOpsCount ?? 0) > 0 ||
+            {sections().status &&
+                ((s()?.pendingOpsCount ?? 0) > 0 ||
                 (s()?.sessionNoteCount ?? 0) > 0 ||
                 (s()?.readySmartNoteCount ?? 0) > 0) && (
                 <>
@@ -764,7 +845,7 @@ const SidebarContent = (props: {
             )}
 
             {/* Dreamer */}
-            {s()?.lastDreamerRunAt && (
+            {sections().dreamer && s()?.lastDreamerRunAt && (
                 <>
                     <SectionHeader theme={props.theme} title="Dreamer" />
                     <StatRow
@@ -782,7 +863,7 @@ const SidebarContent = (props: {
                 snapshot fields (newWorkTokens, totalInputTokens) and the
                 session_meta columns are still populated; only the UI is
                 simplified for now. */}
-            {s()?.totalInputTokens != null && (
+            {sections().stats && s()?.totalInputTokens != null && (
                 <>
                     <SectionHeader theme={props.theme} title="Stats" />
                     <StatRow
@@ -800,8 +881,15 @@ const SidebarContent = (props: {
 }
 
 export function createSidebarContentSlot(api: TuiPluginApi): TuiSlotPlugin {
+    // Seed synchronously at slot construction so the sidebar renders at its
+    // final collapse state + order on the first paint (no async flicker). The
+    // controller lives here in the factory closure for the plugin lifetime, so
+    // collapse state and live pref reloads survive sidebar_content remounts.
+    const seedRoot = readTuiPreferencesFileSync()
+    const controller = createSidebarController(resolveMagicContextPrefs(seedRoot))
+    const effectiveOrder = computeEffectiveOrder(seedRoot, PLUGIN_KEY, DEFAULT_SLOT_ORDER)
     return {
-        order: 150,
+        order: effectiveOrder,
         slots: {
             sidebar_content: (ctx, value) => {
                 const theme = createMemo(() => ctx.theme.current)
@@ -810,6 +898,7 @@ export function createSidebarContentSlot(api: TuiPluginApi): TuiSlotPlugin {
                         api={api}
                         sessionID={() => value.session_id}
                         theme={theme()}
+                        controller={controller}
                     />
                 )
             },