@aliou/pi-synthetic 0.4.6 → 0.5.0

package/src/components/tabbed-panel.ts

@@ -0,0 +1,161 @@
+import type { Theme } from "@mariozechner/pi-coding-agent";
+import { DynamicBorder } from "@mariozechner/pi-coding-agent";
+import type { Component, TUI } from "@mariozechner/pi-tui";
+import { matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
+
+export interface PanelTab {
+  label: string;
+  buildContent: () => string[];
+}
+
+export interface TabbedScrollablePanelOptions {
+  title: string;
+  tabs: PanelTab[];
+  onClose: () => void;
+  maxVisible?: number;
+  keymap?: "vim" | "default";
+}
+
+export class TabbedScrollablePanel implements Component {
+  private activeTab = 0;
+  private scrollOffset = 0;
+  private cachedLines: string[] | null = null;
+  private cachedWidth = 0;
+  private border: DynamicBorder;
+  private options: TabbedScrollablePanelOptions;
+  private theme: Theme;
+
+  constructor(options: TabbedScrollablePanelOptions, _tui: TUI, theme: Theme) {
+    this.options = options;
+    this.theme = theme;
+    this.border = new DynamicBorder((segment) => theme.fg("border", segment));
+  }
+
+  handleInput(data: string): boolean {
+    if (matchesKey(data, "escape") || data === "q") {
+      this.options.onClose();
+      return true;
+    }
+
+    if (matchesKey(data, "tab")) {
+      this.activeTab = (this.activeTab + 1) % this.options.tabs.length;
+      this.scrollOffset = 0;
+      this.invalidate();
+      return true;
+    }
+
+    if (matchesKey(data, "shift+tab")) {
+      this.activeTab =
+        (this.activeTab - 1 + this.options.tabs.length) %
+        this.options.tabs.length;
+      this.scrollOffset = 0;
+      this.invalidate();
+      return true;
+    }
+
+    const maxVisible = this.options.maxVisible ?? 16;
+    const totalLines = this.cachedLines?.length ?? 0;
+    const maxScroll = Math.max(0, totalLines - maxVisible);
+
+    if (data === "j" || matchesKey(data, "down")) {
+      if (this.scrollOffset < maxScroll) {
+        this.scrollOffset++;
+      }
+      return true;
+    }
+
+    if (data === "k" || matchesKey(data, "up")) {
+      if (this.scrollOffset > 0) {
+        this.scrollOffset--;
+      }
+      return true;
+    }
+
+    if (data === " " || matchesKey(data, "pageDown")) {
+      this.scrollOffset = Math.min(this.scrollOffset + maxVisible, maxScroll);
+      return true;
+    }
+
+    if (matchesKey(data, "pageUp")) {
+      this.scrollOffset = Math.max(0, this.scrollOffset - maxVisible);
+      return true;
+    }
+
+    if (matchesKey(data, "home")) {
+      this.scrollOffset = 0;
+      return true;
+    }
+
+    if (matchesKey(data, "end")) {
+      this.scrollOffset = maxScroll;
+      return true;
+    }
+
+    return false;
+  }
+
+  invalidate(): void {
+    this.cachedLines = null;
+    this.cachedWidth = 0;
+  }
+
+  render(width: number): string[] {
+    const tab = this.options.tabs[this.activeTab];
+
+    if (!this.cachedLines || this.cachedWidth !== width) {
+      this.cachedLines = tab ? tab.buildContent() : [];
+      this.cachedWidth = width;
+    }
+
+    const lines: string[] = [];
+
+    lines.push(...this.border.render(width));
+    lines.push(
+      truncateToWidth(
+        ` ${this.theme.fg("accent", this.theme.bold(this.options.title))}`,
+        width,
+      ),
+    );
+    lines.push(this.renderTabBar(width));
+    lines.push("");
+
+    // Content - no forced padding, just render what we have
+    for (const line of this.cachedLines) {
+      lines.push(truncateToWidth(`  ${line}`, width));
+    }
+
+    // Footer directly after content
+    lines.push("");
+    lines.push(
+      truncateToWidth(
+        this.theme.fg("dim", "  Tab/S-Tab switch tabs  q/Esc close"),
+        width,
+      ),
+    );
+    lines.push(...this.border.render(width));
+
+    return lines;
+  }
+
+  private renderTabBar(width: number): string {
+    const parts: string[] = [];
+
+    for (let i = 0; i < this.options.tabs.length; i++) {
+      const tab = this.options.tabs[i];
+      if (!tab) continue;
+      const active = i === this.activeTab;
+
+      if (active) {
+        parts.push(this.theme.fg("accent", this.theme.bold(` ${tab.label} `)));
+      } else {
+        parts.push(this.theme.fg("dim", ` ${tab.label} `));
+      }
+
+      if (i < this.options.tabs.length - 1) {
+        parts.push(this.theme.fg("borderMuted", "│"));
+      }
+    }
+
+    return truncateToWidth(`  ${parts.join("")}`, width);
+  }
+}

package/src/hooks/search-tool-availability.ts

@@ -1,13 +1,6 @@
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-} from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { SYNTHETIC_WEB_SEARCH_TOOL } from "../tools/search";
 
-function notifyDebug(ctx: ExtensionContext, message: string): void {
-  ctx.ui.notify(`[pi-synthetic:web-search] ${message}`, "info");
-}
-
 async function checkSubscriptionAccess(
   apiKey: string,
 ): Promise<{ ok: true } | { ok: false; reason: string }> {
@@ -51,48 +44,36 @@ export function registerSyntheticWebSearchHooks(pi: ExtensionAPI): void {
   let didNotifyDenied = false;
 
   // Keep tool inactive at session start. Availability is decided before each agent run.
-  pi.on("session_start", (_event, ctx) => {
-    notifyDebug(ctx, "session_start: preparing web search tool");
-
+  pi.on("session_start", () => {
     const current = pi.getActiveTools();
     if (current.includes(SYNTHETIC_WEB_SEARCH_TOOL)) {
       pi.setActiveTools(
         current.filter((toolName) => toolName !== SYNTHETIC_WEB_SEARCH_TOOL),
       );
-      notifyDebug(ctx, "session_start: tool disabled until subscription check");
     }
   });
 
   // Verify subscription only when user starts agent execution.
   pi.on("before_agent_start", async (_event, ctx) => {
-    notifyDebug(ctx, "before_agent_start: ensuring tool availability");
-
     const apiKey = process.env.SYNTHETIC_API_KEY;
     if (!apiKey) {
       hasAccess = false;
       deniedReason = "SYNTHETIC_API_KEY is not configured";
       accessCheckPromise = undefined;
-      notifyDebug(ctx, "before_agent_start: access denied (missing API key)");
     } else {
       if (deniedReason === "SYNTHETIC_API_KEY is not configured") {
         deniedReason = undefined;
       }
 
       if (!hasAccess && !deniedReason) {
-        notifyDebug(ctx, "before_agent_start: checking subscription access");
         accessCheckPromise ??= checkSubscriptionAccess(apiKey);
         const access = await accessCheckPromise;
 
         if (!access.ok) {
           deniedReason = access.reason;
-          notifyDebug(
-            ctx,
-            `before_agent_start: access denied (${access.reason})`,
-          );
         } else {
           hasAccess = true;
           didNotifyDenied = false;
-          notifyDebug(ctx, "before_agent_start: access granted");
         }
       }
     }
@@ -103,7 +84,6 @@ export function registerSyntheticWebSearchHooks(pi: ExtensionAPI): void {
         pi.setActiveTools(
           current.filter((toolName) => toolName !== SYNTHETIC_WEB_SEARCH_TOOL),
         );
-        notifyDebug(ctx, "before_agent_start: tool kept disabled");
       }
 
       if (ctx.hasUI && !didNotifyDenied) {
@@ -112,10 +92,6 @@ export function registerSyntheticWebSearchHooks(pi: ExtensionAPI): void {
           "warning",
         );
         didNotifyDenied = true;
-        notifyDebug(
-          ctx,
-          "before_agent_start: user notified about disabled tool",
-        );
       }
       return;
     }
@@ -123,7 +99,6 @@ export function registerSyntheticWebSearchHooks(pi: ExtensionAPI): void {
     const current = pi.getActiveTools();
     if (!current.includes(SYNTHETIC_WEB_SEARCH_TOOL)) {
       pi.setActiveTools([...current, SYNTHETIC_WEB_SEARCH_TOOL]);
-      notifyDebug(ctx, "before_agent_start: tool enabled");
     }
   });
 }

package/src/hooks/sub-integration.ts

@@ -0,0 +1,145 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { QuotasResponse } from "../types/quotas";
+import { fetchQuotas, formatResetTime } from "../utils/quotas";
+
+interface RateWindow {
+  label: string;
+  usedPercent: number;
+  resetDescription?: string;
+  resetAt?: string;
+}
+
+interface UsageSnapshot {
+  provider: string;
+  displayName: string;
+  windows: RateWindow[];
+  lastSuccessAt?: number;
+}
+
+interface SubCoreSettingsPayload {
+  settings?: {
+    behavior?: {
+      refreshInterval: number;
+    };
+  };
+}
+
+function toUsageSnapshot(quotas: QuotasResponse): UsageSnapshot {
+  const windows: RateWindow[] = [];
+
+  if (quotas.subscription) {
+    const pct =
+      (quotas.subscription.requests / quotas.subscription.limit) * 100;
+    windows.push({
+      label: "5h",
+      usedPercent: Math.round(pct),
+      resetDescription: formatResetTime(quotas.subscription.renewsAt),
+      resetAt: quotas.subscription.renewsAt,
+    });
+  }
+
+  if (quotas.search?.hourly) {
+    const pct =
+      (quotas.search.hourly.requests / quotas.search.hourly.limit) * 100;
+    windows.push({
+      label: "Search",
+      usedPercent: Math.round(pct),
+      resetDescription: formatResetTime(quotas.search.hourly.renewsAt),
+      resetAt: quotas.search.hourly.renewsAt,
+    });
+  }
+
+  if (quotas.freeToolCalls) {
+    const pct =
+      (quotas.freeToolCalls.requests / quotas.freeToolCalls.limit) * 100;
+    windows.push({
+      label: "Free",
+      usedPercent: Math.round(pct),
+      resetDescription: formatResetTime(quotas.freeToolCalls.renewsAt),
+      resetAt: quotas.freeToolCalls.renewsAt,
+    });
+  }
+
+  return {
+    provider: "synthetic",
+    displayName: "Synthetic",
+    windows,
+    lastSuccessAt: Date.now(),
+  };
+}
+
+async function emitCurrentUsage(pi: ExtensionAPI): Promise<void> {
+  const quotas = await fetchQuotas();
+  if (!quotas) return;
+  pi.events.emit("sub-core:update-current", {
+    state: { provider: "synthetic", usage: toUsageSnapshot(quotas) },
+  });
+}
+
+export function registerSubIntegration(pi: ExtensionAPI): void {
+  if (!process.env.SYNTHETIC_API_KEY) return;
+
+  let interval: NodeJS.Timeout | undefined;
+  let refreshMs = 60000;
+  let subCoreReady = false;
+  let currentProvider: string | undefined;
+
+  function isSynthetic(): boolean {
+    return currentProvider === "synthetic";
+  }
+
+  function stop(): void {
+    if (interval) {
+      clearInterval(interval);
+      interval = undefined;
+    }
+  }
+
+  function start(): void {
+    stop();
+    if (!subCoreReady || !isSynthetic()) {
+      return;
+    }
+    emitCurrentUsage(pi);
+    const ms = Math.max(10000, refreshMs);
+    interval = setInterval(() => {
+      if (isSynthetic()) emitCurrentUsage(pi);
+    }, ms);
+    interval.unref?.();
+  }
+
+  // Custom events (inter-extension bus)
+  pi.events.on("sub-core:ready", () => {
+    subCoreReady = true;
+    start();
+  });
+
+  pi.events.on("sub-core:settings:updated", (data: unknown) => {
+    const payload = data as SubCoreSettingsPayload;
+    if (payload.settings?.behavior?.refreshInterval) {
+      refreshMs = payload.settings.behavior.refreshInterval * 1000;
+      if (interval) start();
+    }
+  });
+
+  // Lifecycle events (pi.on, not pi.events.on)
+  pi.on("session_start", (_event, ctx) => {
+    currentProvider = ctx.model?.provider;
+    start();
+  });
+
+  pi.on("model_select", (event, _ctx) => {
+    currentProvider = event.model?.provider;
+    if (isSynthetic()) {
+      emitCurrentUsage(pi);
+      start();
+    } else {
+      stop();
+    }
+  });
+
+  pi.on("session_shutdown", () => {
+    currentProvider = undefined;
+    stop();
+  });
+}

package/src/index.ts

@@ -1,6 +1,7 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { registerQuotasCommand } from "./commands/quotas";
 import { registerSyntheticWebSearchHooks } from "./hooks/search-tool-availability";
+import { registerSubIntegration } from "./hooks/sub-integration";
 import { registerSyntheticProvider } from "./providers/index";
 import { registerSyntheticWebSearchTool } from "./tools/search";
 
@@ -11,5 +12,6 @@ export default async function (pi: ExtensionAPI) {
 
   if (process.env.SYNTHETIC_API_KEY) {
     registerQuotasCommand(pi);
+    registerSubIntegration(pi);
   }
 }

package/src/providers/models.ts

@@ -235,4 +235,19 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
     contextWindow: 262144,
     maxTokens: 32000,
   },
+  // API: hf:Qwen/Qwen3.5-397B-A17B → ctx=262144, out=32000
+  {
+    id: "hf:Qwen/Qwen3.5-397B-A17B",
+    name: "Qwen/Qwen3.5-397B-A17B",
+    reasoning: false,
+    input: ["text"],
+    cost: {
+      input: 0.6,
+      output: 3,
+      cacheRead: 0.6,
+      cacheWrite: 0,
+    },
+    contextWindow: 262144,
+    maxTokens: 32000,
+  },
 ];

package/src/types/quotas.ts

@@ -4,4 +4,16 @@ export interface QuotasResponse {
     requests: number;
     renewsAt: string;
   };
+  search: {
+    hourly: {
+      limit: number;
+      requests: number;
+      renewsAt: string;
+    };
+  };
+  freeToolCalls: {
+    limit: number;
+    requests: number;
+    renewsAt: string;
+  };
 }

package/src/utils/quotas.ts

@@ -0,0 +1,33 @@
+import type { QuotasResponse } from "../types/quotas";
+
+const API_KEY = process.env.SYNTHETIC_API_KEY;
+
+export async function fetchQuotas(): Promise<QuotasResponse | null> {
+  if (!API_KEY) return null;
+
+  try {
+    const response = await fetch("https://api.synthetic.new/v2/quotas", {
+      headers: { Authorization: `Bearer ${API_KEY}` },
+    });
+
+    if (!response.ok) return null;
+    return (await response.json()) as QuotasResponse;
+  } catch {
+    return null;
+  }
+}
+
+export function formatResetTime(renewsAt: string): string {
+  const date = new Date(renewsAt);
+  const now = new Date();
+  const diffMs = date.getTime() - now.getTime();
+
+  if (diffMs <= 0) return "soon";
+
+  const diffHours = Math.ceil(diffMs / (1000 * 60 * 60));
+  const diffDays = Math.ceil(diffMs / (1000 * 60 * 60 * 24));
+
+  if (diffHours < 24) return `in ${diffHours}h`;
+  if (diffDays < 7) return `in ${diffDays}d`;
+  return date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}

package/.changeset/config.json

@@ -1,11 +0,0 @@
-{
-  "$schema": "https://unpkg.com/@changesets/config@3.1.2/schema.json",
-  "changelog": "@changesets/cli/changelog",
-  "commit": false,
-  "fixed": [],
-  "linked": [],
-  "access": "public",
-  "baseBranch": "main",
-  "updateInternalDependencies": "patch",
-  "ignore": []
-}

package/.github/workflows/ci.yml

@@ -1,30 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  check:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: pnpm/action-setup@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: "22"
-          cache: "pnpm"
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Lint
-        run: pnpm lint
-
-      - name: Typecheck
-        run: pnpm typecheck

package/.github/workflows/publish.yml

@@ -1,151 +0,0 @@
-name: Publish
-
-on:
-  push:
-    branches:
-      - main
-  workflow_dispatch:
-    inputs:
-      skip-checks:
-        description: "Skip lint and typecheck"
-        type: boolean
-        default: false
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  check:
-    if: ${{ !(github.event_name == 'workflow_dispatch' && inputs.skip-checks) }}
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: pnpm/action-setup@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: "22"
-          cache: "pnpm"
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Lint
-        run: pnpm lint
-
-      - name: Typecheck
-        run: pnpm typecheck
-
-  publish:
-    name: Publish
-    needs: check
-    if: ${{ always() && (needs.check.result == 'success' || needs.check.result == 'skipped') }}
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      packages: write
-      pull-requests: write
-      id-token: write
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "22"
-          registry-url: "https://registry.npmjs.org"
-          scope: "@aliou"
-          cache: "pnpm"
-
-      - name: Upgrade npm for OIDC support
-        run: npm install -g npm@latest
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Get release info
-        id: release-info
-        run: |
-          pnpm changeset status --output=release.json 2>/dev/null || echo '{"releases":[]}' > release.json
-          node <<NODE
-          const fs = require('fs');
-          const release = JSON.parse(fs.readFileSync('release.json', 'utf8'));
-          const releases = release.releases?.filter(r => r.type !== 'none') || [];
-
-          let title = 'Version Packages';
-          let commit = 'Version Packages';
-          if (releases.length === 1) {
-            const { name, newVersion } = releases[0];
-            title = 'Updating ' + name + ' to version ' + newVersion;
-            commit = name + '@' + newVersion;
-          } else if (releases.length > 1) {
-            const summary = releases.map(r => r.name + '@' + r.newVersion).join(', ');
-            title = 'Updating ' + summary;
-            commit = summary;
-          }
-
-          fs.appendFileSync(process.env.GITHUB_OUTPUT, 'title=' + title + '\n');
-          fs.appendFileSync(process.env.GITHUB_OUTPUT, 'commit=' + commit + '\n');
-          NODE
-          rm -f release.json
-        continue-on-error: true
-
-      - name: Create Release PR or Publish
-        id: changesets
-        uses: changesets/action@v1
-        with:
-          version: pnpm changeset version
-          publish: pnpm changeset publish
-          title: ${{ steps.release-info.outputs.title || 'Version Packages' }}
-          commit: ${{ steps.release-info.outputs.commit || 'Version Packages' }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_CONFIG_PROVENANCE: true
-
-      - name: Create GitHub releases
-        if: steps.changesets.outputs.published == 'true'
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          PUBLISHED_PACKAGES: ${{ steps.changesets.outputs.publishedPackages }}
-        run: |
-          node <<'NODE'
-          const { execSync } = require("node:child_process");
-
-          const published = JSON.parse(process.env.PUBLISHED_PACKAGES || "[]");
-
-          for (const pkg of published) {
-            const shortName = pkg.name.replace(/^@[^/]+\//, "");
-            const tag = `${shortName}@${pkg.version}`;
-
-            const existing = execSync(`git tag --list ${tag}`, { encoding: "utf8" }).trim();
-            if (!existing) {
-              execSync(`git tag ${tag}`);
-              execSync(`git push origin ${tag}`);
-            }
-
-            let hasRelease = false;
-            try {
-              const output = execSync(`gh release view ${tag} --json tagName --jq .tagName`, {
-                stdio: ["ignore", "pipe", "ignore"],
-              }).toString().trim();
-              hasRelease = output.length > 0;
-            } catch {
-              hasRelease = false;
-            }
-
-            if (!hasRelease) {
-              execSync(`gh release create ${tag} --title ${tag} --notes "Release ${tag}"`, {
-                stdio: "inherit",
-              });
-            }
-          }
-          NODE

package/.husky/pre-commit

@@ -1,3 +0,0 @@
-pnpm run typecheck
-pnpm run lint
-pnpm run format