@cortexkit/opencode-magic-context 0.31.2 → 0.31.4

package/src/tui-compiled/badge-contrast.ts

@@ -0,0 +1,84 @@
+/**
+ * Pick the text color for the sidebar header badge (a bold label drawn on a
+ * `theme.accent` background).
+ *
+ * Primary rule (matches AFT's sidebar by construction): paint the theme's own
+ * `background` color as the label, the inverse-of-panel look. Because it is a
+ * fixed theme token rather than an accent-derived computation, MC's badge and
+ * AFT's badge agree on EVERY accent automatically, so the same theme can never
+ * make one badge black and the other white (issue #198).
+ *
+ * Fallback rule (the reason a luminance pick exists at all): `theme.background`
+ * can be unusable as a label color in two degenerate cases, where it would
+ * render the label invisible on the accent:
+ *   1. Transparent background. Themes that respect terminal transparency set
+ *      `background: "none"`, which resolves to `RGBA(0,0,0,0)`; drawing it as
+ *      text renders fully transparent and the label disappears (issue #186).
+ *   2. Background ~= accent. If the theme's background and accent are nearly the
+ *      same color, background-on-accent text has no contrast.
+ * In either case we fall back to a black/white pick that is guaranteed visible
+ * on the always-opaque accent.
+ *
+ * `RGBA` channels from @opentui/core are normalized 0..1 floats (alpha included).
+ * We accept the minimal `{ r, g, b, a? }` shape so this stays a pure, trivially
+ * testable function independent of the native color class, and we return the
+ * passed-in `background` object unchanged on the primary path so it stays the
+ * exact same theme token AFT uses.
+ */
+
+type Color = { r: number; g: number; b: number; a?: number };
+
+// Below this alpha the theme background is too transparent to read as a label on
+// the accent (issue #186: background:"none" resolves to alpha 0).
+const MIN_OPAQUE_ALPHA = 0.5;
+
+// If the theme background and accent are within this per-channel distance they
+// are effectively the same color, so background-on-accent text is unreadable.
+const MIN_CHANNEL_DISTANCE = 0.06;
+
+// Luminance midpoint for the fallback pick: accents below this keep white text,
+// accents at/above it (light/pastel/near-white) get black. White-biased relative
+// to the strict equal-contrast crossover (~0.179) so saturated mid-tone accents
+// stay white. Only consulted on the degenerate fallback path.
+const LIGHT_ACCENT_LUMINANCE = 0.5;
+
+function srgbChannelToLinear(c: number): number {
+    return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+
+function relativeLuminance(bg: Color): number {
+    return (
+        0.2126 * srgbChannelToLinear(bg.r) +
+        0.7152 * srgbChannelToLinear(bg.g) +
+        0.0722 * srgbChannelToLinear(bg.b)
+    );
+}
+
+function nearlyEqual(a: Color, b: Color): boolean {
+    return (
+        Math.abs(a.r - b.r) < MIN_CHANNEL_DISTANCE &&
+        Math.abs(a.g - b.g) < MIN_CHANNEL_DISTANCE &&
+        Math.abs(a.b - b.b) < MIN_CHANNEL_DISTANCE
+    );
+}
+
+/**
+ * Pure black/white pick by accent luminance. Used as the badge fallback and kept
+ * exported for callers that only have the accent.
+ */
+export function readableTextColorOn(bg: Color): string {
+    return relativeLuminance(bg) < LIGHT_ACCENT_LUMINANCE ? "#ffffff" : "#000000";
+}
+
+/**
+ * Badge label color on the accent: the theme background (AFT parity) when it is
+ * usable, else a guaranteed-visible black/white fallback. Returns the passed-in
+ * `background` reference unchanged on the primary path.
+ */
+export function badgeTextColor<T extends Color>(accent: T, background: T): T | string {
+    const alpha = background.a ?? 1;
+    if (alpha >= MIN_OPAQUE_ALPHA && !nearlyEqual(accent, background)) {
+        return background;
+    }
+    return readableTextColorOn(accent);
+}

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

@@ -0,0 +1,353 @@
+/**
+ * TUI data layer — pure RPC client, no direct SQLite access.
+ * All data is fetched from the server plugin via HTTP RPC.
+ */
+import os from "node:os";
+import path from "node:path";
+import { MagicContextRpcClient } from "../../shared/rpc-client";
+import type { EmbedDetail, SidebarSnapshot, StatusDetail } from "../../shared/rpc-types";
+
+export type { EmbedDetail, SidebarSnapshot, StatusDetail };
+
+let rpcClient: MagicContextRpcClient | null = null;
+let rpcGeneration = 0;
+
+function getStorageDir(): string {
+    // Plugin v0.16+ uses the shared cortexkit/magic-context path so OpenCode
+    // and Pi can share state. The TUI just needs to point its RPC client at
+    // the same storage directory the server plugin uses for the lock-file
+    // discovery convention.
+    const dataDir = process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
+    return path.join(dataDir, "cortexkit", "magic-context");
+}
+
+/** Initialize the RPC client. Call once on TUI startup. */
+export function initRpcClient(directory: string): void {
+    const storageDir = getStorageDir();
+    // Bump the generation before replacing the client so late notification
+    // responses from a disposed client are ignored (the WS socket observes the
+    // new generation and abandons its in-flight connect).
+    rpcGeneration += 1;
+    rpcClient = new MagicContextRpcClient(storageDir, directory);
+}
+
+export function getRpcGeneration(): number {
+    return rpcGeneration;
+}
+
+/** The live RPC client (for the WS notification socket's endpoint discovery).
+ *  Null before init / after close. */
+export function getRpcClient(): MagicContextRpcClient | null {
+    return rpcClient;
+}
+
+/** Clean up the RPC client. */
+export function closeRpc(): void {
+    // Closing invalidates any already-issued RPC calls; their callbacks must
+    // observe the new generation and abandon (the WS socket checks it too).
+    rpcGeneration += 1;
+    rpcClient?.reset();
+    rpcClient = null;
+}
+
+const EMPTY_SNAPSHOT: SidebarSnapshot = {
+    sessionId: "",
+    usagePercentage: 0,
+    inputTokens: 0,
+    contextLimit: 0,
+    systemPromptTokens: 0,
+    compartmentCount: 0,
+    memoryCount: 0,
+    memoryBlockCount: 0,
+    pendingOpsCount: 0,
+    historianRunning: false,
+    compartmentInProgress: false,
+    sessionNoteCount: 0,
+    readySmartNoteCount: 0,
+    cacheTtl: "5m",
+    lastDreamerRunAt: null,
+    projectIdentity: null,
+    compartmentTokens: 0,
+    factTokens: 0,
+    memoryTokens: 0,
+    docsTokens: 0,
+    profileTokens: 0,
+    conversationTokens: 0,
+    toolCallTokens: 0,
+    toolDefinitionTokens: 0,
+    executeThreshold: 65,
+    newWorkTokens: null,
+    totalInputTokens: null,
+};
+
+/**
+ * Per-session client-side sticky cache. Mirrors the server-side cache in
+ * `sidebar-snapshot-cache.ts` but covers the cases the server can't:
+ *   - RPC call fails entirely (timeout, abort, parse error) → server is never reached
+ *   - RPC server is not yet up (port file missing, retries exhausted)
+ *   - Server returns an error envelope
+ *
+ * In all three cases the breakdown bar would otherwise disappear until the
+ * next successful refresh. With this cache, the client returns the most
+ * recent good snapshot for the same session so the UI stays stable through
+ * transient RPC blips. 5-minute staleness ceiling keeps it from showing
+ * obviously old data after long disconnects.
+ */
+interface CachedSnapshot {
+    snapshot: SidebarSnapshot;
+    cachedAt: number;
+}
+const STICKY_TTL_MS = 5 * 60 * 1000;
+const STICKY_MAX_ENTRIES = 100;
+const stickySidebarCache = new Map<string, CachedSnapshot>();
+
+function rememberSidebarSnapshot(snapshot: SidebarSnapshot): void {
+    if (!snapshot.sessionId || snapshot.inputTokens <= 0) return;
+    // LRU-style bound: drop the oldest entry once we hit the cap. With a
+    // 5-min TTL most stale entries time out naturally; this just prevents
+    // unbounded growth across many session switches in a long TUI session.
+    if (
+        stickySidebarCache.size >= STICKY_MAX_ENTRIES &&
+        !stickySidebarCache.has(snapshot.sessionId)
+    ) {
+        const firstKey = stickySidebarCache.keys().next().value;
+        if (firstKey) stickySidebarCache.delete(firstKey);
+    }
+    stickySidebarCache.set(snapshot.sessionId, {
+        snapshot,
+        cachedAt: Date.now(),
+    });
+}
+
+function recallSidebarSnapshot(sessionId: string, fallback: SidebarSnapshot): SidebarSnapshot {
+    const cached = stickySidebarCache.get(sessionId);
+    if (!cached) return fallback;
+    if (Date.now() - cached.cachedAt > STICKY_TTL_MS) {
+        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,
+    directory: string,
+): Promise<SidebarSnapshot> {
+    const empty: SidebarSnapshot = { ...EMPTY_SNAPSHOT, sessionId };
+    if (!rpcClient) return recallSidebarSnapshot(sessionId, empty);
+    try {
+        const result = await rpcClient.call<SidebarSnapshot>("sidebar-snapshot", {
+            sessionId,
+            directory,
+        });
+        if ((result as unknown as Record<string, unknown>).error) {
+            return recallSidebarSnapshot(sessionId, empty);
+        }
+        // Trust successful server responses. The server has its own sticky
+        // sidebar cache (`sidebar-snapshot-cache.ts`) that handles transient
+        // zero-token windows by hybriding cached breakdown values into a
+        // fresh snapshot, AND clears that cache on `session.deleted`. If the
+        // server reaches us with `inputTokens === 0`, that's its considered
+        // answer — typically because the session was deleted, reverted, or
+        // is brand-new with no responses yet.
+        //
+        // Falling back to the client cache here would resurrect old token
+        // data for a deleted session (the client never sees `session.deleted`
+        // events, so its cache TTL is the only expiry). Sticky behavior is
+        // owned exclusively by the server side.
+        rememberSidebarSnapshot(result);
+        return result;
+    } catch {
+        return recallSidebarSnapshot(sessionId, empty);
+    }
+}
+
+/** Fetch full status detail from the server via RPC. */
+export async function loadStatusDetail(
+    sessionId: string,
+    directory: string,
+    modelKey?: string,
+): Promise<StatusDetail> {
+    const emptyDetail: StatusDetail = {
+        ...EMPTY_SNAPSHOT,
+        sessionId,
+        tagCounter: 0,
+        activeTags: 0,
+        droppedTags: 0,
+        totalTags: 0,
+        activeBytes: 0,
+        lastResponseTime: 0,
+        lastNudgeTokens: 0,
+        lastTransformError: null,
+        isSubagent: false,
+        pendingOps: [],
+        contextLimit: 0,
+        cacheTtlMs: 0,
+        cacheRemainingMs: 0,
+        cacheExpired: false,
+        executeThreshold: 65,
+        executeThresholdMode: "percentage",
+        protectedTagCount: 20,
+        historyBudgetPercentage: 0.15,
+        historyBlockTokens: 0,
+        compressionBudget: null,
+        compressionUsage: null,
+        toastDurationMs: 5000,
+    };
+
+    if (!rpcClient) return emptyDetail;
+    try {
+        const result = await rpcClient.call<StatusDetail>("status-detail", {
+            sessionId,
+            directory,
+            modelKey,
+        });
+        if ((result as unknown as Record<string, unknown>).error) {
+            return emptyDetail;
+        }
+        return result;
+    } catch {
+        return emptyDetail;
+    }
+}
+
+const EMPTY_EMBED_DETAIL: EmbedDetail = {
+    enabled: false,
+    model: "off",
+    provider: "off",
+    session: { embedded: 0, total: 0 },
+    memories: { embedded: 0, total: 0 },
+    commits: { embedded: 0, total: 0, gitEnabled: false },
+    statusText: "Embedding is off (no provider configured).",
+};
+
+/** Fetch embedding coverage status for `/ctx-embed` via RPC. */
+export async function loadEmbedDetail(sessionId: string, directory: string): Promise<EmbedDetail> {
+    if (!rpcClient) return EMPTY_EMBED_DETAIL;
+    try {
+        const result = await rpcClient.call<EmbedDetail>("embed-detail", {
+            sessionId,
+            directory,
+        });
+        if ((result as unknown as Record<string, unknown>).error) {
+            return EMPTY_EMBED_DETAIL;
+        }
+        return result;
+    } catch {
+        return EMPTY_EMBED_DETAIL;
+    }
+}
+
+/** Get compartment count via RPC. */
+export async function getCompartmentCount(sessionId: string): Promise<number> {
+    if (!rpcClient) return 0;
+    try {
+        const result = await rpcClient.call<{ count: number }>("compartment-count", { sessionId });
+        return result.count ?? 0;
+    } catch {
+        return 0;
+    }
+}
+
+/** Send recomp request to server via RPC. */
+export async function requestRecomp(sessionId: string): Promise<boolean> {
+    if (!rpcClient) return false;
+    try {
+        const result = await rpcClient.call<{ ok: boolean }>("recomp", { sessionId });
+        return result.ok ?? false;
+    } catch {
+        return false;
+    }
+}
+
+/** Run `/ctx-session-upgrade` for the session (full recomp + once-per-project
+ *  memory migration). Fired from the upgrade dialog's "Run upgrade now" action. */
+export async function requestUpgrade(sessionId: string): Promise<boolean> {
+    if (!rpcClient) return false;
+    try {
+        const result = await rpcClient.call<{ ok: boolean }>("upgrade", { sessionId });
+        return result.ok ?? false;
+    } catch {
+        return false;
+    }
+}
+
+/** Mark the upgrade reminder dismissed (the user made an explicit Confirm/Cancel
+ *  choice), setting the durable stamp so the FRESH dialog won't re-show. Resume
+ *  prompts are staging-driven and unaffected. */
+export async function dismissUpgradeReminder(sessionId: string): Promise<boolean> {
+    if (!rpcClient) return false;
+    try {
+        const result = await rpcClient.call<{ ok: boolean }>("dismiss-upgrade-reminder", {
+            sessionId,
+        });
+        return result.ok ?? false;
+    } catch {
+        return false;
+    }
+}
+
+/** Resolve global toast duration from server config via RPC. */
+export async function loadToastDurationMs(): Promise<number> {
+    if (!rpcClient) return 5000;
+    try {
+        const result = await rpcClient.call<{ toastDurationMs?: number }>("toast-duration", {});
+        return typeof result.toastDurationMs === "number" ? result.toastDurationMs : 5000;
+    } catch {
+        return 5000;
+    }
+}
+
+/**
+ * Fetch the current startup announcement from the server, if any.
+ * Returns `{show: false}` when there's nothing to announce or when the
+ * configured ANNOUNCEMENT_VERSION has already been dismissed.
+ */
+export interface AnnouncementResponse {
+    show: boolean;
+    version?: string;
+    features?: string[];
+    footer?: string;
+}
+
+export async function getAnnouncement(): Promise<AnnouncementResponse> {
+    if (!rpcClient) return { show: false };
+    try {
+        const result = await rpcClient.call<{
+            show?: boolean;
+            version?: string;
+            features?: string[];
+            footer?: string;
+        }>("get-announcement", {});
+        return {
+            show: result.show === true,
+            version: result.version,
+            features: Array.isArray(result.features) ? result.features : undefined,
+            footer: typeof result.footer === "string" ? result.footer : undefined,
+        };
+    } catch {
+        return { show: false };
+    }
+}
+
+/** Mark the current ANNOUNCEMENT_VERSION as dismissed on the server. */
+export async function markAnnounced(): Promise<boolean> {
+    if (!rpcClient) return false;
+    try {
+        const result = await rpcClient.call<{ ok?: boolean }>("mark-announced", {});
+        return result.ok === true;
+    } catch {
+        return false;
+    }
+}