@aliou/pi-neuralwatt 0.0.1 → 0.1.0

package/src/extensions/command-quotas/components/quota-tabs.ts

@@ -0,0 +1,251 @@
+import type { Theme } from "@mariozechner/pi-coding-agent";
+import { truncateToWidth } from "@mariozechner/pi-tui";
+import type { NeuralwattQuotas } from "../../../types/quota-api";
+import {
+  percentCreditsRemaining,
+  percentEnergyRemaining,
+  renderProgressBar,
+  severityFromPercent,
+} from "../../../utils/quota-bar";
+import {
+  formatKwh,
+  formatTokens,
+  formatUsd,
+} from "../../../utils/quota-format";
+
+/**
+ * Subscription tab — plan details, energy quota, billing period.
+ * Shown only when an active subscription exists.
+ */
+export function renderSubscriptionTab(
+  quotas: NeuralwattQuotas,
+  contentWidth: number,
+  maxWidth: number,
+  theme: Theme,
+): string[] {
+  const sub = quotas.subscription;
+  if (!sub) return [];
+  const lines: string[] = [];
+  const barWidth = Math.min(40, Math.max(20, contentWidth - 30));
+
+  // --- Plan info ---
+  lines.push("");
+  lines.push(
+    truncateToWidth(`  ${theme.fg("accent", theme.bold("Plan"))}`, maxWidth),
+  );
+  lines.push(labelValue("Name", sub.plan, maxWidth, theme));
+  lines.push(labelValue("Status", sub.status, maxWidth, theme));
+  lines.push(
+    labelValue("Billing", sub.billing_interval ?? "\u2014", maxWidth, theme),
+  );
+  lines.push(
+    labelValue("Auto-renew", sub.auto_renew ? "yes" : "no", maxWidth, theme),
+  );
+
+  // --- Energy quota ---
+  lines.push("");
+  lines.push(
+    truncateToWidth(
+      `  ${theme.fg("accent", theme.bold("Energy Quota"))}`,
+      maxWidth,
+    ),
+  );
+  const energyPct = percentEnergyRemaining(sub);
+  const energyColor = severityFromPercent(energyPct);
+  const energyBar = renderProgressBar(energyPct, barWidth, theme, energyColor);
+  lines.push(
+    truncateToWidth(
+      `  ${energyBar} ${theme.fg(energyColor, `${energyPct}%`)}`,
+      maxWidth,
+    ),
+  );
+  lines.push(
+    labelValue(
+      "Remaining",
+      `${formatKwh(sub.kwh_remaining)} of ${formatKwh(sub.kwh_included)}`,
+      maxWidth,
+      theme,
+    ),
+  );
+  lines.push(labelValue("Used", formatKwh(sub.kwh_used), maxWidth, theme));
+
+  if (sub.in_overage) {
+    lines.push(
+      truncateToWidth(
+        `  ${theme.fg("error", "In overage \u2014 pay-per-use rates apply")}`,
+        maxWidth,
+      ),
+    );
+  }
+
+  // --- Billing period ---
+  lines.push("");
+  lines.push(
+    truncateToWidth(
+      `  ${theme.fg("accent", theme.bold("Billing Period"))}`,
+      maxWidth,
+    ),
+  );
+  const start = sub.current_period_start?.slice(0, 10) ?? "\u2014";
+  const end = sub.current_period_end?.slice(0, 10) ?? "\u2014";
+  lines.push(labelValue("Start", start, maxWidth, theme));
+  lines.push(labelValue("End", end, maxWidth, theme));
+
+  return lines;
+}
+
+/**
+ * Credits tab — credit balance only.
+ */
+export function renderCreditsTab(
+  quotas: NeuralwattQuotas,
+  contentWidth: number,
+  maxWidth: number,
+  theme: Theme,
+): string[] {
+  const lines: string[] = [];
+  const barWidth = Math.min(40, Math.max(20, contentWidth - 30));
+
+  // --- Credit balance ---
+  lines.push("");
+  lines.push(
+    truncateToWidth(`  ${theme.fg("accent", theme.bold("Credits"))}`, maxWidth),
+  );
+  const creditsPct = percentCreditsRemaining(quotas);
+  const creditsColor = severityFromPercent(creditsPct);
+  const creditsBar = renderProgressBar(
+    creditsPct,
+    barWidth,
+    theme,
+    creditsColor,
+  );
+  lines.push(
+    truncateToWidth(
+      `  ${creditsBar} ${theme.fg(creditsColor, `${creditsPct}%`)}`,
+      maxWidth,
+    ),
+  );
+  lines.push(
+    labelValue(
+      "Remaining",
+      `${formatUsd(quotas.balance.credits_remaining_usd)} of ${formatUsd(quotas.balance.total_credits_usd)}`,
+      maxWidth,
+      theme,
+    ),
+  );
+  lines.push(
+    labelValue(
+      "Used",
+      formatUsd(quotas.balance.credits_used_usd),
+      maxWidth,
+      theme,
+    ),
+  );
+  lines.push(
+    labelValue("Accounting", quotas.balance.accounting_method, maxWidth, theme),
+  );
+
+  return lines;
+}
+
+/**
+ * Usage & Key tab — usage this month, API key info, key allowance, rate limits.
+ * Shared data that doesn't belong exclusively to subscription or credits.
+ */
+export function renderUsageKeyTab(
+  quotas: NeuralwattQuotas,
+  _contentWidth: number,
+  maxWidth: number,
+  theme: Theme,
+): string[] {
+  const lines: string[] = [];
+
+  // --- Usage this month ---
+  lines.push("");
+  lines.push(
+    truncateToWidth(
+      `  ${theme.fg("accent", theme.bold("Usage (this month)"))}`,
+      maxWidth,
+    ),
+  );
+  const usage = quotas.usage.current_month;
+  lines.push(labelValue("Cost", formatUsd(usage.cost_usd), maxWidth, theme));
+  lines.push(
+    labelValue("Requests", usage.requests.toLocaleString(), maxWidth, theme),
+  );
+  lines.push(labelValue("Tokens", formatTokens(usage.tokens), maxWidth, theme));
+  lines.push(
+    labelValue("Energy", formatKwh(usage.energy_kwh), maxWidth, theme),
+  );
+
+  // --- API Key ---
+  lines.push("");
+  lines.push(
+    truncateToWidth(`  ${theme.fg("accent", theme.bold("API Key"))}`, maxWidth),
+  );
+  lines.push(
+    labelValue("Name", quotas.key.name || "(unnamed)", maxWidth, theme),
+  );
+
+  // --- Key allowance ---
+  if (quotas.key.allowance) {
+    lines.push("");
+    lines.push(
+      truncateToWidth(
+        `  ${theme.fg("accent", theme.bold("Key Allowance"))}`,
+        maxWidth,
+      ),
+    );
+    const alw = quotas.key.allowance;
+    lines.push(labelValue("Limit", formatUsd(alw.limit_usd), maxWidth, theme));
+    lines.push(labelValue("Spent", formatUsd(alw.spent_usd), maxWidth, theme));
+    lines.push(
+      labelValue("Remaining", formatUsd(alw.remaining_usd), maxWidth, theme),
+    );
+    lines.push(labelValue("Period", alw.period, maxWidth, theme));
+    if (alw.blocked) {
+      lines.push(
+        truncateToWidth(
+          `  ${theme.fg("error", "BLOCKED \u2014 spending limit reached")}`,
+          maxWidth,
+        ),
+      );
+    }
+  }
+
+  // --- Rate Limits ---
+  lines.push("");
+  lines.push(
+    truncateToWidth(
+      `  ${theme.fg("accent", theme.bold("Rate Limits"))}`,
+      maxWidth,
+    ),
+  );
+  lines.push(
+    labelValue("Tier", quotas.limits.rate_limit_tier, maxWidth, theme),
+  );
+  lines.push(
+    labelValue(
+      "Overage cap",
+      quotas.limits.overage_limit_usd !== null
+        ? formatUsd(quotas.limits.overage_limit_usd)
+        : "none",
+      maxWidth,
+      theme,
+    ),
+  );
+
+  return lines;
+}
+
+/** Format a label: value pair with aligned labels. */
+function labelValue(
+  label: string,
+  value: string,
+  maxWidth: number,
+  theme: Theme,
+): string {
+  const labelWidth = 14;
+  const padded = label.padEnd(labelWidth);
+  return truncateToWidth(`  ${theme.fg("dim", padded)} ${value}`, maxWidth);
+}

package/src/extensions/command-quotas/components/quotas-display.ts

@@ -0,0 +1,192 @@
+import type { Theme } from "@mariozechner/pi-coding-agent";
+import { DynamicBorder } from "@mariozechner/pi-coding-agent";
+import type { Component, TUI } from "@mariozechner/pi-tui";
+import { Loader, matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
+import type { NeuralwattQuotas } from "../../../types/quota-api";
+import {
+  renderCreditsTab,
+  renderSubscriptionTab,
+  renderUsageKeyTab,
+} from "./quota-tabs";
+
+type QuotasState =
+  | { type: "loading" }
+  | { type: "error"; message: string }
+  | { type: "loaded"; quotas: NeuralwattQuotas };
+
+export class QuotasComponent implements Component {
+  private state: QuotasState = { type: "loading" };
+  private theme: Theme;
+  private tui: TUI;
+  private onClose: () => void;
+  private onRefetch: () => void;
+  private loader: Loader | null = null;
+  private activeTab = 0;
+
+  constructor(
+    theme: Theme,
+    tui: TUI,
+    onClose: () => void,
+    onRefetch: () => void,
+  ) {
+    this.theme = theme;
+    this.tui = tui;
+    this.onClose = onClose;
+    this.onRefetch = onRefetch;
+    this.startLoader();
+  }
+
+  private startLoader(): void {
+    this.loader = new Loader(
+      this.tui,
+      (s: string) => this.theme.fg("accent", s),
+      (s: string) => this.theme.fg("muted", s),
+      "Fetching quota...",
+    );
+  }
+
+  destroy(): void {
+    this.loader?.stop();
+    this.loader = null;
+  }
+
+  setState(state: QuotasState): void {
+    if (state.type === "loading") {
+      this.loader?.stop();
+      this.startLoader();
+      this.activeTab = 0;
+    } else if (this.state.type === "loading") {
+      this.loader?.stop();
+      this.loader = null;
+    }
+    this.state = state;
+  }
+
+  /** Build the list of active tab labels. */
+  private tabs(): string[] {
+    const hasSub =
+      this.state.type === "loaded" && this.state.quotas.subscription !== null;
+    return hasSub
+      ? ["Subscription", "Credits", "Usage & Key"]
+      : ["Credits", "Usage & Key"];
+  }
+
+  handleInput(data: string): boolean {
+    if (matchesKey(data, "escape") || data === "q") {
+      this.onClose();
+      return true;
+    }
+    if (data === "r") {
+      this.onRefetch();
+      return true;
+    }
+    const tabCount = this.tabs().length;
+    if (tabCount > 1) {
+      if (data === "\t") {
+        this.activeTab = (this.activeTab + 1) % tabCount;
+        return true;
+      }
+      if (data === "\x1b[Z" || data === "\x1b[2Z") {
+        this.activeTab = (this.activeTab - 1 + tabCount) % tabCount;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  render(width: number): string[] {
+    const lines: string[] = [];
+    const border = new DynamicBorder((s: string) => this.theme.fg("border", s));
+    const contentWidth = Math.max(1, width - 4);
+
+    lines.push(...border.render(width));
+    lines.push(
+      truncateToWidth(
+        ` ${this.theme.fg("accent", this.theme.bold("Neuralwatt API Quota"))}`,
+        width,
+      ),
+    );
+
+    switch (this.state.type) {
+      case "loading":
+        if (this.loader) {
+          lines.push(...this.loader.render(width));
+        } else {
+          lines.push(this.theme.fg("muted", "  Fetching quota..."));
+        }
+        break;
+      case "error":
+        lines.push(this.theme.fg("error", `  ${this.state.message}`));
+        break;
+      case "loaded": {
+        const tabLines = this.renderLoaded(
+          this.state.quotas,
+          contentWidth,
+          width,
+        );
+        lines.push(...tabLines);
+        break;
+      }
+    }
+
+    lines.push("");
+    const hints = ["r refresh", "q/Esc close"];
+    if (this.tabs().length > 1) hints.push("Tab/Shift+Tab switch tab");
+    lines.push(this.theme.fg("dim", `  ${hints.join("  ")}`));
+    lines.push(...border.render(width));
+
+    return lines;
+  }
+
+  private renderLoaded(
+    quotas: NeuralwattQuotas,
+    contentWidth: number,
+    maxWidth: number,
+  ): string[] {
+    const lines: string[] = [];
+    const tabs = this.tabs();
+
+    // Render tab bar with bg highlight on active tab
+    lines.push("");
+    const tabParts = tabs.map((label, idx) => {
+      const fullLabel = ` ${label} `;
+      if (idx === this.activeTab) {
+        return this.theme.bg(
+          "selectedBg",
+          this.theme.fg("accent", this.theme.bold(fullLabel)),
+        );
+      }
+      return this.theme.fg("dim", fullLabel);
+    });
+    lines.push(truncateToWidth(`  ${tabParts.join("  ")}`, maxWidth));
+
+    // Render content for each tab, equalize heights, show active
+    const allTabContent = tabs.map((label) => {
+      if (label === "Subscription") {
+        return renderSubscriptionTab(
+          quotas,
+          contentWidth,
+          maxWidth,
+          this.theme,
+        );
+      }
+      if (label === "Credits") {
+        return renderCreditsTab(quotas, contentWidth, maxWidth, this.theme);
+      }
+      // "Usage & Key"
+      return renderUsageKeyTab(quotas, contentWidth, maxWidth, this.theme);
+    });
+
+    // Equalize tab heights so switching doesn't cause layout jumps
+    const maxLen = Math.max(...allTabContent.map((t) => t.length));
+    for (const tabLines of allTabContent) {
+      while (tabLines.length < maxLen) tabLines.push("");
+    }
+
+    lines.push(...allTabContent[this.activeTab]);
+
+    return lines;
+  }
+
+  invalidate(): void {}
+}

package/src/extensions/command-quotas/index.ts

@@ -0,0 +1,23 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import {
+  configLoader,
+  NEURALWATT_EXTENSIONS_REGISTER_EVENT,
+  NEURALWATT_EXTENSIONS_REQUEST_EVENT,
+} from "../../config";
+import { registerQuotasCommand } from "./command";
+
+export default async function (pi: ExtensionAPI) {
+  await configLoader.load();
+
+  const config = configLoader.getConfig();
+
+  if (config.quotaCommand) {
+    registerQuotasCommand(pi);
+  }
+
+  pi.events.on(NEURALWATT_EXTENSIONS_REQUEST_EVENT, () => {
+    pi.events.emit(NEURALWATT_EXTENSIONS_REGISTER_EVENT, {
+      feature: "quotaCommand",
+    });
+  });
+}

package/src/extensions/provider/index.ts

@@ -0,0 +1,146 @@
+import type { AuthStorage, ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import {
+  configLoader,
+  emitConfigUpdated,
+  NEURALWATT_EXTENSIONS_REGISTER_EVENT,
+  NEURALWATT_EXTENSIONS_REQUEST_EVENT,
+  type NeuralwattFeatureId,
+  registerNeuralwattSettings,
+} from "../../config";
+import { getNeuralwattApiKey } from "../../lib/env";
+import type { NeuralwattQuotas } from "../../types/quota-api";
+import {
+  NEURALWATT_QUOTAS_REQUEST_EVENT,
+  NEURALWATT_QUOTAS_UPDATED_EVENT,
+  type NeuralwattQuotasUpdatedPayload,
+  parseQuotaHeaders,
+} from "../../types/quota-events";
+import { fetchQuotas } from "../../utils/quotas";
+import { NEURALWATT_MODELS } from "./models";
+
+export function registerNeuralwattProvider(pi: ExtensionAPI): void {
+  pi.registerProvider("neuralwatt", {
+    baseUrl: "https://api.neuralwatt.com/v1",
+    apiKey: "NEURALWATT_API_KEY",
+    api: "openai-completions",
+    authHeader: true,
+    headers: {
+      Referer: "https://pi.dev",
+      "X-Title": "npm:@aliou/pi-neuralwatt",
+    },
+    models: NEURALWATT_MODELS.map(({ fast: _fast, ...model }) => ({
+      ...model,
+      compat: {
+        supportsDeveloperRole: false,
+        maxTokensField: "max_tokens",
+        ...model.compat,
+      },
+    })),
+  });
+}
+
+export default async function (pi: ExtensionAPI) {
+  await configLoader.load();
+  registerNeuralwattProvider(pi);
+
+  // Track which feature extensions loaded
+  const loadedFeatures = new Set<NeuralwattFeatureId>();
+
+  // Register settings (in the provider, so it's always available)
+  registerNeuralwattSettings(pi, {
+    getLoadedFeatures: () => loadedFeatures,
+  });
+
+  // --- Quota store (event-based) ---
+  let lastHeaderEmitAt = 0;
+  const HEADER_EMIT_THROTTLE_MS = 5_000;
+
+  function emitQuotas(
+    quotas: NeuralwattQuotas,
+    source: NeuralwattQuotasUpdatedPayload["source"],
+  ): void {
+    const now = Date.now();
+    if (source === "header" && now - lastHeaderEmitAt < HEADER_EMIT_THROTTLE_MS)
+      return;
+    if (source === "header") lastHeaderEmitAt = now;
+    pi.events.emit(NEURALWATT_QUOTAS_UPDATED_EVENT, { quotas, source });
+  }
+
+  // Ingest quotas from response headers
+  pi.on("after_provider_response", (event, ctx) => {
+    if (ctx.model?.provider !== "neuralwatt") return;
+    const headerQuotas = parseQuotaHeaders(event.headers);
+    if (!headerQuotas) return;
+
+    const quotas: NeuralwattQuotas = {
+      snapshot_at: new Date().toISOString(),
+      balance: {
+        credits_remaining_usd: headerQuotas.allowanceRemainingUsd,
+        total_credits_usd: 0,
+        credits_used_usd: 0,
+        accounting_method: "token",
+      },
+      usage: {
+        lifetime: { cost_usd: 0, requests: 0, tokens: 0, energy_kwh: 0 },
+        current_month: { cost_usd: 0, requests: 0, tokens: 0, energy_kwh: 0 },
+      },
+      limits: { overage_limit_usd: null, rate_limit_tier: "standard" },
+      subscription:
+        headerQuotas.subscriptionPlan !== "none" &&
+        headerQuotas.energyRemaining !== undefined
+          ? {
+              plan: headerQuotas.subscriptionPlan,
+              status: "active",
+              billing_interval: "month",
+              current_period_start: "",
+              current_period_end: "",
+              auto_renew: false,
+              kwh_included: headerQuotas.energyIncluded ?? 0,
+              kwh_used: headerQuotas.energyUsed ?? 0,
+              kwh_remaining: headerQuotas.energyRemaining,
+              in_overage: false,
+            }
+          : null,
+      key: { name: "", allowance: null },
+    };
+
+    emitQuotas(quotas, "header");
+  });
+
+  // Respond to quota requests from other extensions
+  let quotaRequestInFlight = false;
+  pi.events.on(NEURALWATT_QUOTAS_REQUEST_EVENT, async (data: unknown) => {
+    if (quotaRequestInFlight) return;
+    quotaRequestInFlight = true;
+    try {
+      if (!data || typeof data !== "object") return;
+      const { authStorage } = data as { authStorage?: AuthStorage };
+      if (!authStorage) return;
+      const apiKey = await getNeuralwattApiKey(authStorage);
+      if (!apiKey) return;
+      const result = await fetchQuotas(apiKey);
+      if (result.success) emitQuotas(result.data.quotas, "api");
+    } finally {
+      quotaRequestInFlight = false;
+    }
+  });
+
+  // Collect which feature extensions are loaded
+  pi.events.on(NEURALWATT_EXTENSIONS_REGISTER_EVENT, (data: unknown) => {
+    const { feature } = data as { feature: NeuralwattFeatureId };
+    loadedFeatures.add(feature);
+  });
+
+  // On session start: request extensions to register, then emit config
+  pi.on("session_start", async (_event, ctx) => {
+    loadedFeatures.clear();
+    pi.events.emit(NEURALWATT_EXTENSIONS_REQUEST_EVENT, undefined);
+    emitConfigUpdated(pi);
+
+    if (ctx.model?.provider !== "neuralwatt") return;
+    const apiKey = await getNeuralwattApiKey(ctx.modelRegistry.authStorage);
+    if (!apiKey) return;
+    const result = await fetchQuotas(apiKey);
+    if (result.success) emitQuotas(result.data.quotas, "api");
+  });
+}