pi-opencode-go-provider 1.1.0 → 1.1.1

package/README.md

@@ -139,6 +139,7 @@ so that trailing segment appears only if a response ever carries a
 /opencode-go-usage off        # hide the widget (persisted)
 /opencode-go-usage on         # show it again
 /opencode-go-usage debug      # config, last fetch/error, endpoint
+/opencode-go-usage glyphs auto|unicode|ascii   # footer glyph set (persisted)
 ```
 
 Polling runs every 60 seconds, plus after every turn and whenever the selected
@@ -151,7 +152,8 @@ model changes. Settings are read from `~/.pi/agent/opencode-go-provider.json`:
     "refreshIntervalMs": 60000,
     "showOnlyOnProvider": true,
     "showResetTimes": true,
-    "placement": "belowEditor"
+    "placement": "belowEditor",
+    "glyphs": "auto"
   }
 }
 ```
@@ -159,6 +161,8 @@ model changes. Settings are read from `~/.pi/agent/opencode-go-provider.json`:
 `placement` accepts `belowEditor` (default) or `aboveEditor`. Every key is
 optional; `/opencode-go-usage on|off` writes only `enabled`.
 
+`glyphs` accepts `auto` (default), `unicode`, or `ascii`. Older mintty/Cygwin builds measure ambiguous-width codepoints (the `·` separators, the `↺` reset marker) with their own cell-width tables, which can shift the row and desync pi’s renderer. `auto` switches the widget to ASCII equivalents on those terminals and the widget never paints the terminal’s last column; an explicit `unicode` is clamped to ASCII for widget content there (the status line is not row-budgeted and keeps the choice).
+
 ### Pooled accounts
 
 When [pi-multiprovider](https://github.com/monotykamary/pi-multiprovider)

package/config.ts

@@ -9,6 +9,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { GLYPH_MODES, type GlyphMode } from "./glyphs.ts";
 
 export const PROVIDER_ID = "opencode-go";
 export const CONFIG_BASENAME = "opencode-go-provider.json";
@@ -26,6 +27,8 @@ export interface UsageConfig {
   showOnlyOnProvider: boolean;
   /** Include reset countdowns in the widget line. */
   showResetTimes: boolean;
+  /** Footer glyph set. "auto" degrades to ASCII on legacy terminals (mintty/Cygwin). */
+  glyphs: GlyphMode;
   placement: UsagePlacement;
 }
 
@@ -35,6 +38,7 @@ export const DEFAULT_USAGE_CONFIG: UsageConfig = {
   showOnlyOnProvider: true,
   showResetTimes: true,
   placement: "belowEditor",
+  glyphs: "auto",
 };
 
 export const MIN_USAGE_REFRESH_MS = 15_000;
@@ -90,6 +94,9 @@ export function readUsageConfig(env: NodeJS.ProcessEnv = process.env): UsageConf
   if (typeof file.refreshIntervalMs === "number") {
     config.refreshIntervalMs = clampRefreshInterval(file.refreshIntervalMs);
   }
+  if (GLYPH_MODES.includes(file.glyphs as GlyphMode)) {
+    config.glyphs = file.glyphs as GlyphMode;
+  }
   if (USAGE_PLACEMENTS.includes(file.placement as UsagePlacement)) {
     config.placement = file.placement as UsagePlacement;
   }

package/glyphs.ts

@@ -0,0 +1,57 @@
+/**
+ * Footer glyph policy for the usage widget.
+ *
+ * Older mintty/Cygwin builds measure emoji and ambiguous-width codepoints with
+ * their own cell-width tables, which can disagree with pi's. The widget line is
+ * truncated to (now) width - 1 and never padded to the edge, but a glyph the
+ * terminal measures wider than expected still shifts everything after it and
+ * can desync pi's differential renderer. "auto" swaps the footer glyphs for
+ * ASCII on detected legacy terminals; "unicode"/"ascii" force a set.
+ */
+
+export type GlyphMode = "auto" | "unicode" | "ascii";
+
+export interface GlyphSet {
+  /** Separator between usage atoms. */
+  sep: string;
+  /** Reset-countdown prefix. */
+  reset: string;
+  /** Progress-bar fill / remainder (command output). */
+  barFilled: string;
+  barHollow: string;
+  /** Truncation marker. */
+  ellipsis: string;
+}
+
+export const UNICODE_GLYPHS: GlyphSet = { sep: "\u00b7", reset: "\u21ba", barFilled: "\u2588", barHollow: "\u2591", ellipsis: "\u2026" };
+export const ASCII_GLYPHS: GlyphSet = { sep: "-", reset: "~", barFilled: "#", barHollow: "-", ellipsis: "..." };
+
+export const GLYPH_MODES: GlyphMode[] = ["auto", "unicode", "ascii"];
+
+/** True for terminals whose cell-width tables are known to disagree with the
+ * width math in format.ts (older mintty/Cygwin builds). */
+export function detectLegacyTerminal(env: NodeJS.ProcessEnv = process.env): boolean {
+  const termProgram = env.TERM_PROGRAM ?? "";
+  const term = env.TERM ?? "";
+  return (
+    termProgram === "mintty" ||
+    termProgram === "cygwin" ||
+    termProgram === "msys" ||
+    term.startsWith("cygwin") ||
+    term.startsWith("msys")
+  );
+}
+
+export function resolveGlyphSet(mode: GlyphMode, env: NodeJS.ProcessEnv = process.env): GlyphSet {
+  if (mode === "unicode") return UNICODE_GLYPHS;
+  if (mode === "ascii") return ASCII_GLYPHS;
+  return detectLegacyTerminal(env) ? ASCII_GLYPHS : UNICODE_GLYPHS;
+}
+
+/** Widget-safe variant. The widget renders inside the editor's row budget, so
+ * an over-wide glyph there can desync pi's renderer; status fallback text is
+ * not row-budgeted and keeps an explicit choice. */
+export function resolveWidgetGlyphSet(mode: GlyphMode, env: NodeJS.ProcessEnv = process.env): GlyphSet {
+  if (mode === "unicode" && detectLegacyTerminal(env)) return ASCII_GLYPHS;
+  return resolveGlyphSet(mode, env);
+}

package/index.ts

@@ -29,8 +29,9 @@ import {
   type ModelRegistry,
   type ThemeColor,
 } from "@earendil-works/pi-coding-agent";
-import { USAGE_WIDGET_KEY, readUsageConfig, writeUsageConfig } from "./config.ts";
+import { USAGE_WIDGET_KEY, readUsageConfig, writeUsageConfig, type UsageConfig } from "./config.ts";
 import { sanitizeStatusText, truncateToWidth } from "./format.ts";
+import { resolveGlyphSet, resolveWidgetGlyphSet, type GlyphSet } from "./glyphs.ts";
 import { usageSegments, type UsageSegment, type UsageSeverity } from "./usage.ts";
 import { UsageController } from "./usage-controller.ts";
 import {
@@ -426,6 +427,7 @@ export default function (pi: ExtensionAPI) {
 
   let usageConfig = readUsageConfig();
   let usageWidgetInstalled = false;
+  let usageClampNotified = false;
   const usageController = new UsageController(() => usageConfig, updateUsageWidget);
   let usageContext: ExtensionContext | undefined;
 
@@ -463,17 +465,25 @@ export default function (pi: ExtensionAPI) {
     muted: "dim",
   };
 
-  function usageSegmentsFor(ctx: ExtensionContext): UsageSegment[] | undefined {
+  function usageSegmentsFor(ctx: ExtensionContext, glyphs: GlyphSet): UsageSegment[] | undefined {
     const snapshot = usageController.snapshot;
     if (!snapshot || !usageConfig.enabled || !usageController.isEligible(ctx)) return undefined;
-    const segments = usageSegments(snapshot, { showResetTimes: usageConfig.showResetTimes });
-    if (usageController.isStale()) segments.push({ text: " · stale", severity: "warning" });
+    const segments = usageSegments(snapshot, { showResetTimes: usageConfig.showResetTimes, glyphs });
+    if (usageController.isStale()) segments.push({ text: ` ${glyphs.sep} stale`, severity: "warning" });
     return segments;
   }
 
   function updateUsageWidget(ctx: ExtensionContext): void {
     try {
-      const segments = usageSegmentsFor(ctx);
+      // Legacy terminals measure the footer glyphs with their own tables; widget
+      // content clamps to ASCII there, the status fallback keeps the choice.
+      const glyphs = resolveGlyphSet(usageConfig.glyphs);
+      const widgetGlyphs = resolveWidgetGlyphSet(usageConfig.glyphs);
+      if (widgetGlyphs !== glyphs && !usageClampNotified) {
+        usageClampNotified = true;
+        ctx.ui.notify("OpenCode Go: widget glyphs stay ASCII on this terminal — unicode glyphs overflow legacy mintty/Cygwin cell widths. The status line is unaffected.", "info");
+      }
+      const segments = usageSegmentsFor(ctx, widgetGlyphs);
       if (!segments) {
         if (usageWidgetInstalled) {
           ctx.ui.setWidget(USAGE_WIDGET_KEY, undefined);
@@ -494,14 +504,18 @@ export default function (pi: ExtensionAPI) {
               const line = segments
                 .map((segment) => theme.fg(USAGE_SEVERITY_COLORS[segment.severity], segment.text))
                 .join("");
-              return [truncateToWidth(line, width, theme.fg("dim", "\u2026"))];
+              // Budget width - 1: never paint the terminal’s last column (a
+              // pending wrap there desyncs pi’s renderer on legacy terminals).
+              const w = Math.max(1, width - 1);
+              return [truncateToWidth(line, w, theme.fg("dim", widgetGlyphs.ellipsis))];
             },
           }),
           { placement: usageConfig.placement },
         );
       } else {
         ctx.ui.setWidget(USAGE_WIDGET_KEY, undefined);
-        ctx.ui.setStatus(USAGE_WIDGET_KEY, sanitizeStatusText(segments.map((s) => s.text).join("")));
+        const barSegments = usageSegmentsFor(ctx, glyphs) ?? segments;
+        ctx.ui.setStatus(USAGE_WIDGET_KEY, sanitizeStatusText(barSegments.map((s) => s.text).join("")));
       }
       usageWidgetInstalled = true;
     } catch {
@@ -513,6 +527,15 @@ export default function (pi: ExtensionAPI) {
     description: "Show, refresh, or toggle the OpenCode Go 5h / 7d / 30d usage widget",
     handler: async (args, ctx) => {
       const action = args.trim().toLowerCase();
+      if (action === "glyphs auto" || action === "glyphs unicode" || action === "glyphs ascii") {
+        const glyphs = action.slice("glyphs ".length) as UsageConfig["glyphs"];
+        usageConfig = { ...usageConfig, glyphs };
+        const persisted = writeUsageConfig({ glyphs });
+        updateUsageWidget(ctx);
+        const suffix = persisted ? "" : " for this session (could not write the config file)";
+        ctx.ui.notify(`OpenCode Go footer glyphs: ${glyphs}${suffix}.`, "info");
+        return;
+      }
       if (action === "on" || action === "off") {
         const enabled = action === "on";
         usageConfig = { ...usageConfig, enabled };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-opencode-go-provider",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Opencode Go provider extension for pi - Fast, efficient GLM, Kimi, and MiniMax models through the opencode.ai API",
   "type": "module",
   "main": "index.ts",

package/tests/glyphs.test.ts

@@ -0,0 +1,76 @@
+/**
+ * Glyph policy: legacy terminals (mintty/Cygwin) get an ASCII footer so an
+ * over-wide glyph cannot shift the widget line and desync pi's renderer.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { DEFAULT_USAGE_CONFIG } from "../config.ts";
+import { ASCII_GLYPHS, UNICODE_GLYPHS, detectLegacyTerminal, resolveGlyphSet, resolveWidgetGlyphSet } from "../glyphs.ts";
+import { formatBar, parseUsageSnapshot, usageSegments } from "../usage.ts";
+import { truncateToWidth } from "../format.ts";
+
+const mintty = { TERM_PROGRAM: "mintty", TERM: "xterm" } as NodeJS.ProcessEnv;
+const cygwin = { TERM: "cygwin" } as NodeJS.ProcessEnv;
+const wt = { TERM_PROGRAM: "Windows_Terminal", TERM: "xterm-256color" } as NodeJS.ProcessEnv;
+const isAscii = (value: string) => [...value].every((char) => char.charCodeAt(0) < 128);
+
+test("detects legacy terminals", () => {
+  assert.equal(detectLegacyTerminal(mintty), true);
+  assert.equal(detectLegacyTerminal(cygwin), true);
+  assert.equal(detectLegacyTerminal(wt), false);
+  assert.equal(detectLegacyTerminal({} as NodeJS.ProcessEnv), false);
+});
+
+test("auto degrades on legacy terminals; explicit modes win for the status line", () => {
+  assert.equal(resolveGlyphSet("auto", mintty), ASCII_GLYPHS);
+  assert.equal(resolveGlyphSet("auto", wt), UNICODE_GLYPHS);
+  assert.equal(resolveGlyphSet("unicode", mintty), UNICODE_GLYPHS);
+  assert.equal(resolveGlyphSet("ascii", wt), ASCII_GLYPHS);
+});
+
+test("widget content clamps an explicit unicode choice on legacy terminals", () => {
+  assert.equal(resolveWidgetGlyphSet("unicode", mintty), ASCII_GLYPHS);
+  assert.equal(resolveWidgetGlyphSet("unicode", wt), UNICODE_GLYPHS);
+  assert.equal(resolveWidgetGlyphSet("auto", mintty), ASCII_GLYPHS);
+  assert.equal(resolveWidgetGlyphSet("ascii", wt), ASCII_GLYPHS);
+});
+
+test("the default config is auto", () => {
+  assert.equal(DEFAULT_USAGE_CONFIG.glyphs, "auto");
+});
+
+test("the ASCII set is pure ASCII and renders an ASCII usage line", () => {
+  assert.equal(isAscii(Object.values(ASCII_GLYPHS).join("")), true);
+  assert.equal(isAscii(Object.values(UNICODE_GLYPHS).join("")), false);
+
+  // Built through the real parser so the fixture cannot drift from the wire shape.
+  const now = Date.now();
+  const snapshot = parseUsageSnapshot(
+    {
+      usage: {
+        rolling: { status: "ok", percent: 37, resetsAt: new Date(now + 3_600_000).toISOString() },
+        weekly: { status: "ok", percent: 59, resetsAt: new Date(now + 86_400_000).toISOString() },
+      },
+    },
+    now,
+  );
+  assert.ok(snapshot);
+  const asciiLine = usageSegments(snapshot, { showResetTimes: true, glyphs: ASCII_GLYPHS }, now)
+    .map((segment) => segment.text)
+    .join("");
+  const unicodeLine = usageSegments(snapshot, { showResetTimes: true }, now)
+    .map((segment) => segment.text)
+    .join("");
+  assert.equal(isAscii(asciiLine), true);
+  assert.equal(asciiLine.includes("5h: 63% - 7d: 41%"), true);
+  assert.equal(unicodeLine.includes("\u00b7"), true);
+  assert.equal(unicodeLine.includes("\u21ba"), true);
+});
+
+test("bars and truncation take the ASCII glyphs too", () => {
+  assert.equal(formatBar(50, 4, ASCII_GLYPHS), "##--");
+  assert.equal(formatBar(50, 4), "\u2588\u2588\u2591\u2591");
+  const cut = truncateToWidth("abcdefghij", 5, ASCII_GLYPHS.ellipsis);
+  assert.equal(cut, "ab...");
+  assert.equal(isAscii(cut), true);
+});

package/usage.ts

@@ -24,6 +24,8 @@
  *   30d ↺ 20d0h
  */
 
+import { UNICODE_GLYPHS, type GlyphSet } from "./glyphs.ts";
+
 export const USAGE_URL = "https://opencode.ai/zen/go/v1/usage";
 
 /** Published Go budget per window; informational only, not sent by the API. */
@@ -66,6 +68,8 @@ export interface UsageSegment {
 export interface UsageFormatOptions {
   showResetTimes: boolean;
   showBankedResets?: boolean;
+  /** Glyph set for separators and reset markers; defaults to unicode. */
+  glyphs?: GlyphSet;
 }
 
 export const USAGE_WINDOW_LABELS: Record<UsageWindowKey, string> = {
@@ -256,9 +260,10 @@ function formatCompactReset(
   label: string | undefined,
   resetAt: number | null,
   now: number,
+  glyphs: GlyphSet = UNICODE_GLYPHS,
 ): string | null {
   if (resetAt === null) return null;
-  return `${label ? `${label} ` : ""}↺ ${formatCountdown(resetAt - now)}`;
+  return `${label ? `${label} ` : ""}${glyphs.reset} ${formatCountdown(resetAt - now)}`;
 }
 
 /** "3 banked resets", or null when the count is absent or zero. */
@@ -285,11 +290,12 @@ export function usageSegments(
   options: UsageFormatOptions,
   now = Date.now(),
 ): UsageSegment[] {
+  const glyphs = options.glyphs ?? UNICODE_GLYPHS;
   const windows = snapshot.windows;
   const labelled = windows.length > 1;
   const segments: UsageSegment[] = [{ text: "Usage: ", severity: "muted" }];
   windows.forEach((window, index) => {
-    if (index > 0) segments.push({ text: " · ", severity: "muted" });
+    if (index > 0) segments.push({ text: ` ${glyphs.sep} `, severity: "muted" });
     segments.push({ text: `${window.label}: `, severity: "muted" });
     segments.push({
       text: formatPercent(window.remainingPercent),
@@ -298,13 +304,13 @@ export function usageSegments(
   });
   if (options.showResetTimes) {
     for (const window of windows) {
-      const reset = formatCompactReset(labelled ? window.label : undefined, window.resetsAt, now);
-      if (reset) segments.push({ text: ` · ${reset}`, severity: "muted" });
+      const reset = formatCompactReset(labelled ? window.label : undefined, window.resetsAt, now, glyphs);
+      if (reset) segments.push({ text: ` ${glyphs.sep} ${reset}`, severity: "muted" });
     }
   }
   if (options.showBankedResets !== false) {
     const banked = formatBankedResetsSuffix(snapshot.bankedResets);
-    if (banked) segments.push({ text: ` · ${banked}`, severity: "muted" });
+    if (banked) segments.push({ text: ` ${glyphs.sep} ${banked}`, severity: "muted" });
   }
   return segments;
 }
@@ -320,13 +326,13 @@ export function formatUsageLine(
 }
 
 /** Progress bar: 20 cells, filled by the remaining percentage. */
-export function formatBar(percent: number, width = 20): string {
+export function formatBar(percent: number, width = 20, glyphs: GlyphSet = UNICODE_GLYPHS): string {
   const filled = Math.round((clampPercent(percent) / 100) * width);
-  return `${"█".repeat(filled)}${"░".repeat(width - filled)}`;
+  return `${glyphs.barFilled.repeat(filled)}${glyphs.barHollow.repeat(width - filled)}`;
 }
 
 /** Multi-line breakdown with bars, used by the command output. */
-export function formatUsageDetail(snapshot: UsageSnapshot, now = Date.now()): string[] {
+export function formatUsageDetail(snapshot: UsageSnapshot, now = Date.now(), glyphs: GlyphSet = UNICODE_GLYPHS): string[] {
   return snapshot.windows.map((window) => {
     const clock = window.resetsAt === null
       ? null
@@ -334,8 +340,8 @@ export function formatUsageDetail(snapshot: UsageSnapshot, now = Date.now()): st
     const reset =
       window.resetsAt === null || clock === null
         ? ""
-        : `  ↺ ${formatCountdown(window.resetsAt - now)} - ${clock}`;
+        : `  ${glyphs.reset} ${formatCountdown(window.resetsAt - now)} - ${clock}`;
     const limited = window.status === "rate-limited" ? "  RATE LIMITED" : "";
-    return `${window.label.padEnd(3)} ${formatBar(window.remainingPercent)} ${formatPercent(window.remainingPercent).padStart(4)} left${reset}${limited}`;
+    return `${window.label.padEnd(3)} ${formatBar(window.remainingPercent, 20, glyphs)} ${formatPercent(window.remainingPercent).padStart(4)} left${reset}${limited}`;
   });
 }