@mevsgame/pi-model-alias-profiles 0.1.0 → 0.1.1

package/README.md

@@ -110,6 +110,10 @@ Other processes do not change this process's active profile. After a process
 crash, a stale `.lock` may require removal after confirming no writer is active.
 Local atomic-rename/lock semantics are assumed; network filesystems may differ.
 
+## Optional pi-usage integration
+
+When `@narumitw/pi-usage` is installed, selecting a tier queries its mapped physical provider through `usage:query:v1`. The separate `model-profiles-usage` footer item is cleared when the tier changes or its report expires. Queries may perform network requests. Without pi-usage there is no usage item. The installed pi-usage settings have no global status enable switch: its Anthropic status is gated by `anthropicExtraUsage`, and xAI is menu-only. The bridge respects these gates and Codex percentage/countdown preferences in `pi-usage.json`. Its compact formatter currently covers percentage buckets and Anthropic remaining spend; it does not reproduce pi-usage's full provider-specific formatting or custom `statuslineDisplay` templates.
+
 ## Known limitations and troubleshooting
 
 - Another extension registering `tier/large`, `tier/medium`, or `tier/small`
@@ -138,6 +142,19 @@ Installed Pi-Bolt smoke checks confirm extension loading, `--model tier/medium`,
 and all three aliases in `--list-models tier` without sending model requests.
 See `VERIFICATION.md` for exact results and remaining manual checks.
 
+## Publishing
+
+`.github/workflows/publish.yml` tests and publishes the package to npm when a
+GitHub Release is published. Configure npm Trusted Publishing once for
+`@mevsgame/pi-model-alias-profiles` with GitHub Actions, owner `mevsgame`,
+repository `pi-model-alias-profiles`, and workflow `publish.yml` (no environment).
+No npm token secret is needed. Stable releases publish under `latest`; GitHub
+prereleases publish under `next`.
+
+For each release, update `version` in `package.json` and `package-lock.json`,
+push the change and a matching `vX.Y.Z` tag, then publish a GitHub Release for
+that tag. The workflow checks the tag/version match before publishing.
+
 ## License and links
 
 MIT. [Source and issues](https://github.com/mevsgame/pi-model-alias-profiles).

package/index.ts

@@ -4,6 +4,7 @@ import { ALIASES, ConfigStore, type Config, type Alias } from "./src/config.ts";
 import { route, validateProfile } from "./src/profiles.ts";
 import { branchProfile, STATE_ENTRY } from "./src/state.ts";
 import { manage, quickPicker, type Controller } from "./src/ui.ts";
+import { createUsageBridge } from "./src/usage.ts";
 
 export default function modelProfiles(pi: ExtensionAPI) {
   const store = new ConfigStore(join(getAgentDir(), "model-profiles.json"));
@@ -15,12 +16,14 @@ export default function modelProfiles(pi: ExtensionAPI) {
     if (ctx.hasUI) ctx.ui.notify(message, error ? "error" : "info");
     else console.error(`[model-profiles] ${message}`);
   };
+  const usage = createUsageBridge(pi, () => config, () => active);
   const status = (ctx: ExtensionContext) => {
     if (!ctx.hasUI) return;
     const alias = ctx.model?.provider === "tier" ? ctx.model.id as Alias : undefined;
     ctx.ui.setStatus("model-profiles", alias
       ? `${active ?? "no profile"} · ${alias} → ${active && config.profiles[active]?.[alias] || "(unconfigured)"}`
       : undefined);
+    if (pi.events) usage.update(ctx);
   };
   const record = () => pi.appendEntry(STATE_ENTRY, { profile: active ?? null });
   const controller: Controller = {
@@ -71,11 +74,14 @@ export default function modelProfiles(pi: ExtensionAPI) {
   };
   pi.on("session_start", (_event, ctx) => {
     restore(ctx);
+    if (pi.events) usage.start(ctx);
     if (loadError) report(ctx, String(loadError), true);
     else if (!Object.keys(config.profiles).length) report(ctx, "No model profiles configured. Run /model-profiles to create your first profile.");
   });
+  pi.on("session_shutdown", (_event, ctx) => { if (pi.events) usage.stop(ctx); });
   pi.on("session_tree", (_event, ctx) => restore(ctx));
   pi.on("model_select", (_event, ctx) => status(ctx));
+  pi.on("agent_end", (_event, ctx) => { if (pi.events) usage.update(ctx); });
   for (const alias of ALIASES) pi.registerVirtualModel({
     provider: "tier", id: alias, name: `Tier ${alias}`,
     thinkingLevels: ["off", "minimal", "low", "medium", "high", "xhigh"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mevsgame/pi-model-alias-profiles",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "description": "Deterministic Pi model aliases with switchable, persistent profiles",
   "license": "MIT",

package/src/usage-query.ts

@@ -0,0 +1,41 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export type QueryOutcome = { kind: "result"; value: unknown } | { kind: "no-service" | "cancelled" | "timeout" | "protocol-error" };
+
+/** The response offer is synchronous even when the offered result is asynchronous. */
+export function queryUsage(pi: ExtensionAPI, session: ExtensionContext["sessionManager"], sessionId: string,
+  providerId: string, controller: AbortController, timeoutMs = 15_000): Promise<QueryOutcome> {
+  return new Promise(resolve => {
+    const signal = controller.signal;
+    if (signal.aborted) { resolve({ kind: "cancelled" }); return; }
+    let open = true, accepted = false, settled = false;
+    let deadline: ReturnType<typeof setTimeout> | undefined;
+    const finish = (outcome: QueryOutcome) => {
+      if (settled) return;
+      settled = true;
+      if (deadline) clearTimeout(deadline);
+      signal.removeEventListener("abort", onAbort);
+      resolve(outcome);
+    };
+    const onAbort = () => finish({ kind: "cancelled" });
+    signal.addEventListener("abort", onAbort, { once: true });
+    deadline = setTimeout(() => { finish({ kind: "timeout" }); controller.abort(); }, timeoutMs);
+    try {
+      pi.events.emit("usage:query:v1", {
+        session, sessionId, providerId, refresh: true, signal,
+        respond(offered: unknown) {
+          // Even a rejected duplicate or late promise must have its rejection observed.
+          const promise = Promise.resolve(offered);
+          if (!open || accepted || settled || signal.aborted) { void promise.catch(() => {}); return false; }
+          accepted = true;
+          void promise.then(value => finish({ kind: "result", value }), () => finish({ kind: "protocol-error" }));
+          return true;
+        },
+      });
+    } catch {
+      finish({ kind: "protocol-error" });
+      controller.abort();
+    } finally { open = false; }
+    if (!accepted && !settled) { finish({ kind: "no-service" }); controller.abort(); }
+  });
+}

package/src/usage.ts

@@ -0,0 +1,99 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { resolveTarget } from "./profiles.ts";
+import type { Alias, Config } from "./config.ts";
+import { queryUsage } from "./usage-query.ts";
+
+// pi-usage has no global status switch. Its Anthropic status is explicitly opt-in;
+// xAI is deliberately menu-only. Do not start a query for either when disabled.
+function settings() {
+  try {
+    const value = JSON.parse(readFileSync(join(getAgentDir(), "pi-usage.json"), "utf8"));
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  } catch { return {}; }
+}
+
+export function formatUsage(value: any, provider: string, opts: any): string | undefined {
+  if (value?.status !== "ready" || value.providerId !== provider || value.report?.providerId !== provider ||
+      !Number.isFinite(value.expiresAt) || value.expiresAt <= Date.now() || !Array.isArray(value.report.buckets)) return;
+  if (provider === "anthropic") {
+    const metric = Array.isArray(value.report.metrics) && value.report.metrics.find((m: any) => m?.id === "extra-usage-remaining");
+    return typeof metric?.value === "number" && Number.isFinite(metric.value) ? `anthropic $${metric.value.toFixed(2)} left` : undefined;
+  }
+  const buckets = value.report.buckets.filter((b: any) => b?.unit === "percent" && Number.isFinite(b.remaining));
+  if (!buckets.length) return;
+  const label = provider === "openai-codex" ? "codex" : provider.replace(/[^a-zA-Z0-9._-]/g, "");
+  const parts = buckets.slice(0, 4).map((b: any) => {
+    const amount = provider === "openai-codex" && opts.codexStatusPercentage === "used"
+      ? (Number.isFinite(b.used) ? b.used : 100 - b.remaining) : b.remaining;
+    const percent = `${Math.max(0, Math.min(100, amount)).toFixed(0)}%`;
+    const mins = b.windowMinutes;
+    const window = Number.isFinite(mins) && mins > 0 ? mins === 10080 ? "wk" : mins % 1440 === 0 ? `${mins / 1440}d` : mins % 60 === 0 ? `${mins / 60}h` : `${mins}m` : "";
+    const reset = provider === "openai-codex" && opts.codexStatusResetCountdown !== false && Number.isFinite(b.resetsAt)
+      ? Math.max(0, Math.ceil((b.resetsAt - Date.now()) / 60000)) : undefined;
+    return reset !== undefined ? `${percent} ↻ ${reset >= 60 ? `${Math.floor(reset / 60)}h${reset % 60 ? `${reset % 60}m` : ""}` : `${reset}m`}` : `${window ? `${window} ` : ""}${percent}`;
+  });
+  return `${label} ${parts.join(" · ")}`;
+}
+
+export function createUsageBridge(pi: ExtensionAPI, getConfig: () => Config, getActive: () => string | undefined,
+  timing: { timeoutMs?: number; retryBaseMs?: number; retryMaxMs?: number; minRefreshMs?: number } = {}) {
+  let generation = 0;
+  let controller: AbortController | undefined;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let running = false;
+  let failures = 0;
+  const clear = (ctx: ExtensionContext) => { if (ctx.hasUI) ctx.ui.setStatus("model-profiles-usage", undefined); };
+  const cancel = () => { generation++; controller?.abort(); controller = undefined; if (timer) clearTimeout(timer); timer = undefined; };
+  const update = (ctx: ExtensionContext) => {
+    cancel();
+    clear(ctx);
+    if (!running || !ctx.hasUI || !pi.events || ctx.model?.provider !== "tier") return;
+    let model;
+    try { model = resolveTarget(getActive(), ctx.model.id as Alias, getConfig(), ctx.modelRegistry); } catch { return; }
+    const opts = settings();
+    if (model.provider === "xai" || (model.provider === "anthropic" && opts.anthropicExtraUsage !== true)) return;
+    const session = ctx.sessionManager;
+    if (typeof session.getSessionId !== "function") return;
+    const sessionId = session.getSessionId();
+    const current = generation;
+    const abort = new AbortController(); controller = abort;
+    void queryUsage(pi, session, sessionId, model.provider, abort, timing.timeoutMs).then(outcome => {
+      if (!running || current !== generation || session.getSessionId() !== sessionId) return;
+      if (ctx.model?.provider !== "tier" || JSON.stringify(settings()) !== JSON.stringify(opts)) return;
+      try {
+        const target = resolveTarget(getActive(), ctx.model.id as Alias, getConfig(), ctx.modelRegistry);
+        if (target.provider !== model.provider || target.id !== model.id) return;
+      } catch { return; }
+      if (controller === abort) controller = undefined;
+      const result = outcome.kind === "result" ? outcome.value : undefined;
+      const value = formatUsage(result, model.provider, opts);
+      if (value) {
+        failures = 0;
+        ctx.ui.setStatus("model-profiles-usage", value);
+        const expiresAt = (result as any).expiresAt as number;
+        const remaining = Math.max(0, expiresAt - Date.now());
+        timer = setTimeout(() => {
+          if (current !== generation) return;
+          clear(ctx);
+          const delay = Math.max(0, (timing.minRefreshMs ?? 1000) - remaining);
+          if (delay) timer = setTimeout(() => { if (current === generation) update(ctx); }, delay);
+          else update(ctx);
+        }, Math.min(2147483647, remaining));
+      } else {
+        // No service and all unavailable/malformed results are retried with capped backoff.
+        // External lifecycle/model changes can trigger an earlier attempt.
+        const max = timing.retryMaxMs ?? 60_000;
+        const delay = outcome.kind === "no-service" ? max : Math.min(max, (timing.retryBaseMs ?? 1000) * 2 ** Math.min(failures++, 16));
+        timer = setTimeout(() => { if (current === generation) update(ctx); }, delay);
+      }
+    }).catch(() => {});
+  };
+  return {
+    start(ctx: ExtensionContext) { running = true; const started = ++generation; queueMicrotask(() => { if (running && started === generation) update(ctx); }); },
+    update,
+    stop(ctx: ExtensionContext) { running = false; cancel(); clear(ctx); },
+  };
+}