@cortexkit/opencode-magic-context 0.29.0 → 0.30.0

package/src/tui/badge-contrast.ts

@@ -1,39 +1,52 @@
 /**
- * Pick a readable text color (black or white) for text drawn ON TOP of a given
- * background color.
+ * Pick the text color for the sidebar header badge (a bold label drawn on a
+ * `theme.accent` background).
  *
- * The sidebar header badge previously drew its label with `fg={theme.background}`
- * on a `theme.accent` background. That breaks for themes that set
- * `background: "none"` (transparent) to respect terminal transparency: the
- * resolved background is `RGBA(0,0,0,0)`, so the badge text renders fully
- * transparent and disappears (issue #186). The badge background (`accent`) is
- * always opaque, so deriving the text color from it is transparency-proof.
+ * 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).
  *
- * The pick is WHITE-BIASED off the accent's relative luminance: white for any
- * accent in the dark half (luminance < 0.5), black only for genuinely light
- * accents. A strict "higher-contrast-wins" pick (crossover at luminance 0.179)
- * flips ordinary mid-tone accents to black: a typical orange/amber sidebar
- * accent (luminance ~0.3) reads black ~5:1 vs white ~3.7:1, so contrast-wins
- * picks black even though white at ~3.7:1 is perfectly legible for a short bold
- * label. That looks heavy and clashes with the sibling status badges, so we
- * prefer white across the whole dark half and only fall to black once the accent
- * is actually light (pale/pastel/near-white), where white would be unreadable.
+ * 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. We accept the
- * minimal `{ r, g, b }` shape so this stays a pure, trivially testable function
- * independent of the native color class.
+ * `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.
  */
 
-// Luminance midpoint: 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.
+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: { r: number; g: number; b: number }): number {
+function relativeLuminance(bg: Color): number {
     return (
         0.2126 * srgbChannelToLinear(bg.r) +
         0.7152 * srgbChannelToLinear(bg.g) +
@@ -41,6 +54,31 @@ function relativeLuminance(bg: { r: number; g: number; b: number }): number {
     );
 }
 
-export function readableTextColorOn(bg: { r: number; g: number; b: number }): string {
+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/slots/sidebar-content.tsx

@@ -2,7 +2,7 @@
 import { Show, createEffect, createMemo, createSignal, on, onCleanup } from "solid-js"
 import type { TuiSlotPlugin, TuiPluginApi, TuiThemeCurrent } from "@opencode-ai/plugin/tui"
 import packageJson from "../../../package.json"
-import { readableTextColorOn } from '../badge-contrast';
+import { badgeTextColor } from '../badge-contrast';
 import { loadSidebarSnapshot, type SidebarSnapshot } from "../data/context-db"
 import { formatThresholdPercent } from "../../shared/format-threshold"
 import {
@@ -695,7 +695,7 @@ const SidebarContent = (props: {
                 onMouseDown={() => props.controller.toggleCollapsed()}
             >
                 <box paddingLeft={1} paddingRight={1} backgroundColor={props.theme.accent}>
-                    <text fg={readableTextColorOn(props.theme.accent)}>
+                    <text fg={badgeTextColor(props.theme.accent, props.theme.background)}>
                         <b>{collapsed() ? "▶ " : "▼ "}{headerLabel()}</b>
                     </text>
                 </box>

package/dist/hooks/is-anthropic-provider.d.ts

@@ -1,2 +0,0 @@
-export declare function isAnthropicProvider(providerID: string): boolean;
-//# sourceMappingURL=is-anthropic-provider.d.ts.map

package/dist/hooks/is-anthropic-provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-anthropic-provider.d.ts","sourceRoot":"","sources":["../../src/hooks/is-anthropic-provider.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAE/D"}

package/dist/shared/live-server-client.d.ts

@@ -1,50 +0,0 @@
-/**
- * Live-server client for the Channel 2 ctx_reduce ceiling nudge (a synthetic
- * user `<system-reminder>` delivered via `promptAsync`).
- *
- * WHY a separate client instead of the plugin-provided `input.client`:
- * OpenCode's plugin `input.client` routes through `Server.Default().app.fetch`,
- * which uses a SEPARATE Effect `memoMap` from the live HTTP listener the UI
- * uses. `SessionRunState` lives per-memoMap, so a plugin-origin `promptAsync`
- * observes an "idle" runner while the live turn is still running, `ensureRunning`
- * fails to coalesce, and OpenCode persists duplicate assistant children
- * (upstream bug anomalyco/opencode#28202). Building a `createOpencodeClient`
- * aimed at `input.serverUrl` via `globalThis.fetch` enters the SAME live
- * listener, so `ensureRunning` sees the real run and coalesces — the synthetic
- * message lands at the tail after the current assistant step.
- *
- * The live listener is only reachable on OpenCode Desktop (Electron+Node) and
- * TUI launched with `--port 0`; plain TUI binds an internal listener that 404s
- * `/session/*`. We probe once at init and cache per `serverUrl`. When
- * unreachable, Channel 2 is DISABLED (Channel 1 + 85% force-materialization
- * remain the backstop) — MC deliberately does NOT fall back to the in-process
- * client because that would knowingly trigger #28202.
- */
-import { createOpencodeClient } from "@opencode-ai/sdk";
-export type LiveServerClient = ReturnType<typeof createOpencodeClient>;
-/**
- * Cached `createOpencodeClient` aimed at the live HTTP listener for the given
- * `(serverUrl, directory)`. One client is reused across deliveries.
- */
-export declare function getLiveServerClient(serverUrl: string, directory: string): LiveServerClient;
-/**
- * Probe whether `serverUrl` serves OpenCode's HTTP API within `timeoutMs`.
- * `true` only when `/session` proves the API is usable: any 2xx, or 401/403
- * (auth-protected listener still exists). `false` for 404 (plain TUI internal
- * listener), 5xx, connection refused, DNS failure, timeout, or malformed URL.
- * Records the result + timestamp in the per-serverUrl cache.
- */
-export declare function probeServerReachable(serverUrl: string | undefined, timeoutMs?: number): Promise<boolean>;
-/** Record a probe result directly (test helper / explicit override). */
-export declare function setLiveServerWakeAvailable(serverUrl: string | undefined, available: boolean): void;
-/**
- * Should Channel 2 deliver through the live-server client for `serverUrl`?
- * Returns false when never probed or the last probe failed. A stale decision
- * (older than the TTL) returns false so the caller re-probes before delivering.
- */
-export declare function useLiveServerWake(serverUrl?: string): boolean;
-/** True when a usable (non-stale) probe decision exists, regardless of outcome. */
-export declare function hasFreshProbe(serverUrl?: string): boolean;
-/** Test helper — reset both caches between cases. */
-export declare function __resetLiveServerClientForTests(): void;
-//# sourceMappingURL=live-server-client.d.ts.map

package/dist/shared/live-server-client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"live-server-client.d.ts","sourceRoot":"","sources":["../../src/shared/live-server-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;AA0BvE;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAY1F;AAcD;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACtC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,SAAS,SAAO,GACjB,OAAO,CAAC,OAAO,CAAC,CAqBlB;AAED,wEAAwE;AACxE,wBAAgB,0BAA0B,CACtC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,SAAS,EAAE,OAAO,GACnB,IAAI,CAMN;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAM7D;AAED,mFAAmF;AACnF,wBAAgB,aAAa,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAKzD;AAED,qDAAqD;AACrD,wBAAgB,+BAA+B,IAAI,IAAI,CAGtD"}

package/src/shared/live-server-client.ts

@@ -1,152 +0,0 @@
-/**
- * Live-server client for the Channel 2 ctx_reduce ceiling nudge (a synthetic
- * user `<system-reminder>` delivered via `promptAsync`).
- *
- * WHY a separate client instead of the plugin-provided `input.client`:
- * OpenCode's plugin `input.client` routes through `Server.Default().app.fetch`,
- * which uses a SEPARATE Effect `memoMap` from the live HTTP listener the UI
- * uses. `SessionRunState` lives per-memoMap, so a plugin-origin `promptAsync`
- * observes an "idle" runner while the live turn is still running, `ensureRunning`
- * fails to coalesce, and OpenCode persists duplicate assistant children
- * (upstream bug anomalyco/opencode#28202). Building a `createOpencodeClient`
- * aimed at `input.serverUrl` via `globalThis.fetch` enters the SAME live
- * listener, so `ensureRunning` sees the real run and coalesces — the synthetic
- * message lands at the tail after the current assistant step.
- *
- * The live listener is only reachable on OpenCode Desktop (Electron+Node) and
- * TUI launched with `--port 0`; plain TUI binds an internal listener that 404s
- * `/session/*`. We probe once at init and cache per `serverUrl`. When
- * unreachable, Channel 2 is DISABLED (Channel 1 + 85% force-materialization
- * remain the backstop) — MC deliberately does NOT fall back to the in-process
- * client because that would knowingly trigger #28202.
- */
-
-import { createOpencodeClient } from "@opencode-ai/sdk";
-
-export type LiveServerClient = ReturnType<typeof createOpencodeClient>;
-
-const clientCache = new Map<string, LiveServerClient>();
-
-function cacheKey(serverUrl: string, directory: string): string {
-    return `${serverUrl}|${directory}`;
-}
-
-function normalizeServerUrl(serverUrl: string): string {
-    try {
-        return new URL(serverUrl).toString();
-    } catch {
-        return serverUrl;
-    }
-}
-
-/** Basic-auth header OpenCode expects when `OPENCODE_SERVER_PASSWORD` is set. */
-function serverAuthHeaders(): Record<string, string> | undefined {
-    const password = process.env.OPENCODE_SERVER_PASSWORD;
-    if (!password) return undefined;
-    const username = process.env.OPENCODE_SERVER_USERNAME ?? "opencode";
-    return {
-        Authorization: `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`,
-    };
-}
-
-/**
- * Cached `createOpencodeClient` aimed at the live HTTP listener for the given
- * `(serverUrl, directory)`. One client is reused across deliveries.
- */
-export function getLiveServerClient(serverUrl: string, directory: string): LiveServerClient {
-    const key = cacheKey(serverUrl, directory);
-    const cached = clientCache.get(key);
-    if (cached) return cached;
-    const client = createOpencodeClient({
-        baseUrl: serverUrl,
-        directory,
-        headers: serverAuthHeaders(),
-        fetch: globalThis.fetch,
-    });
-    clientCache.set(key, client);
-    return client;
-}
-
-// Per-serverUrl wake decision + probe TTL. One plugin process can host multiple
-// OpenCode windows with different listener URLs, so the decision must be keyed.
-interface ProbeDecision {
-    reachable: boolean;
-    probedAt: number;
-}
-const wakeDecisionByServerUrl = new Map<string, ProbeDecision>();
-
-// Re-probe window: a transient 404/timeout shouldn't permanently disable
-// Channel 2 for the whole session lifetime (per council-r3).
-const PROBE_TTL_MS = 10 * 60_000;
-
-/**
- * Probe whether `serverUrl` serves OpenCode's HTTP API within `timeoutMs`.
- * `true` only when `/session` proves the API is usable: any 2xx, or 401/403
- * (auth-protected listener still exists). `false` for 404 (plain TUI internal
- * listener), 5xx, connection refused, DNS failure, timeout, or malformed URL.
- * Records the result + timestamp in the per-serverUrl cache.
- */
-export async function probeServerReachable(
-    serverUrl: string | undefined,
-    timeoutMs = 1500,
-): Promise<boolean> {
-    if (!serverUrl) return false;
-    const normalized = normalizeServerUrl(serverUrl);
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    let reachable = false;
-    try {
-        const probeUrl = new URL("/session", serverUrl).toString();
-        const res = await globalThis.fetch(probeUrl, {
-            method: "GET",
-            headers: serverAuthHeaders(),
-            signal: controller.signal,
-        });
-        reachable = res.ok || res.status === 401 || res.status === 403;
-    } catch {
-        reachable = false;
-    } finally {
-        clearTimeout(timer);
-        wakeDecisionByServerUrl.set(normalized, { reachable, probedAt: Date.now() });
-    }
-    return reachable;
-}
-
-/** Record a probe result directly (test helper / explicit override). */
-export function setLiveServerWakeAvailable(
-    serverUrl: string | undefined,
-    available: boolean,
-): void {
-    if (!serverUrl) return;
-    wakeDecisionByServerUrl.set(normalizeServerUrl(serverUrl), {
-        reachable: available,
-        probedAt: Date.now(),
-    });
-}
-
-/**
- * Should Channel 2 deliver through the live-server client for `serverUrl`?
- * Returns false when never probed or the last probe failed. A stale decision
- * (older than the TTL) returns false so the caller re-probes before delivering.
- */
-export function useLiveServerWake(serverUrl?: string): boolean {
-    if (!serverUrl) return false;
-    const decision = wakeDecisionByServerUrl.get(normalizeServerUrl(serverUrl));
-    if (!decision) return false;
-    if (Date.now() - decision.probedAt > PROBE_TTL_MS) return false;
-    return decision.reachable;
-}
-
-/** True when a usable (non-stale) probe decision exists, regardless of outcome. */
-export function hasFreshProbe(serverUrl?: string): boolean {
-    if (!serverUrl) return false;
-    const decision = wakeDecisionByServerUrl.get(normalizeServerUrl(serverUrl));
-    if (!decision) return false;
-    return Date.now() - decision.probedAt <= PROBE_TTL_MS;
-}
-
-/** Test helper — reset both caches between cases. */
-export function __resetLiveServerClientForTests(): void {
-    clientCache.clear();
-    wakeDecisionByServerUrl.clear();
-}