@selesai/code 0.7.0 → 0.8.1

package/dist/extensions/pi-powerline-footer/context-usage.ts

@@ -1,11 +1,123 @@
-interface CoreContextUsage {
-  contextTokens: number;
+import { estimateTokens, sessionEntryToContextMessages, type SessionEntry } from "@selesai/code";
+
+export interface CoreContextUsage {
+  contextTokens: number | null;
   contextWindow: number;
-  contextPercent: number;
+  contextPercent: number | null;
+}
+
+interface DisplayContextUsageInput {
+  coreContextUsage: CoreContextUsage | null;
+  unknownCoreFallback: CoreContextUsage | null;
+  fallbackContextTokens: number;
+  fallbackContextWindow: number;
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+interface ContextUsageSource {
+  sessionManager: {
+    getLeafId(): string | null;
+  };
+  getContextUsage(): unknown;
+}
+
+interface UnknownContextEstimateSource {
+  sessionManager: {
+    buildContextEntries(): SessionEntry[];
+  };
+  getContextUsage(): unknown;
+  getSystemPrompt(): string;
+}
+
+function isContextUsageSource(value: unknown): value is ContextUsageSource {
+  if (!isRecord(value) || typeof value.getContextUsage !== "function" || !isRecord(value.sessionManager)) {
+    return false;
+  }
+  return typeof value.sessionManager.getLeafId === "function";
+}
+
+function isUnknownContextEstimateSource(value: unknown): value is UnknownContextEstimateSource {
+  return isRecord(value)
+    && typeof value.getContextUsage === "function"
+    && typeof value.getSystemPrompt === "function"
+    && isRecord(value.sessionManager)
+    && typeof value.sessionManager.buildContextEntries === "function";
+}
+
+export class CoreContextUsageCache {
+  private sessionManager: ContextUsageSource["sessionManager"] | null = null;
+  private leafId: string | null = null;
+  private usage: CoreContextUsage | null = null;
+
+  get(ctx: unknown): CoreContextUsage | null {
+    if (!isContextUsageSource(ctx)) return readCoreContextUsage(ctx);
+
+    const sessionManager = ctx.sessionManager;
+    const leafId = sessionManager.getLeafId();
+    // A reset cache holds sessionManager === null, which never matches a live one.
+    if (this.sessionManager !== sessionManager || this.leafId !== leafId) {
+      this.sessionManager = sessionManager;
+      this.leafId = leafId;
+      this.usage = readCoreContextUsage(ctx);
+    }
+    return this.usage;
+  }
+
+  reset(): void {
+    this.sessionManager = null;
+    this.leafId = null;
+    this.usage = null;
+  }
+}
+
+export function estimateInitialContextTokens(ctx: unknown): number | null {
+  if (!isRecord(ctx) || typeof ctx.getSystemPrompt !== "function") {
+    return null;
+  }
+
+  const prompt = ctx.getSystemPrompt();
+  if (typeof prompt !== "string" || !prompt.trim()) {
+    return null;
+  }
+
+  return Math.ceil(prompt.length / 4);
+}
+
+export function resolveDisplayContextUsage({
+  coreContextUsage,
+  unknownCoreFallback,
+  fallbackContextTokens,
+  fallbackContextWindow,
+}: DisplayContextUsageInput): CoreContextUsage {
+  if (coreContextUsage?.contextTokens === null && unknownCoreFallback) return unknownCoreFallback;
+  if (coreContextUsage) return coreContextUsage;
+
+  return {
+    contextTokens: fallbackContextTokens,
+    contextWindow: fallbackContextWindow,
+    contextPercent: fallbackContextWindow > 0 ? (fallbackContextTokens / fallbackContextWindow) * 100 : 0,
+  };
+}
+
+export function estimateUnknownContextUsage(ctx: unknown): CoreContextUsage | null {
+  if (!isUnknownContextEstimateSource(ctx)) return null;
+
+  const coreContextUsage = readCoreContextUsage(ctx);
+  if (!coreContextUsage || coreContextUsage.contextTokens !== null) return null;
+
+  const messageTokens = ctx.sessionManager.buildContextEntries()
+    .flatMap(sessionEntryToContextMessages)
+    .reduce((total, message) => total + estimateTokens(message), 0);
+  const contextTokens = (estimateInitialContextTokens(ctx) ?? 0) + messageTokens;
+
+  return {
+    contextTokens,
+    contextWindow: coreContextUsage.contextWindow,
+    contextPercent: (contextTokens / coreContextUsage.contextWindow) * 100,
+  };
 }
 
 export function readCoreContextUsage(ctx: unknown): CoreContextUsage | null {
@@ -21,8 +133,7 @@ export function readCoreContextUsage(ctx: unknown): CoreContextUsage | null {
   const tokens = usage.tokens;
   const contextWindow = usage.contextWindow;
   if (
-    typeof tokens !== "number"
-    || !Number.isFinite(tokens)
+    !(tokens === null || (typeof tokens === "number" && Number.isFinite(tokens)))
     || typeof contextWindow !== "number"
     || !Number.isFinite(contextWindow)
     || contextWindow <= 0
@@ -30,6 +141,10 @@ export function readCoreContextUsage(ctx: unknown): CoreContextUsage | null {
     return null;
   }
 
+  if (tokens === null) {
+    return { contextTokens: null, contextWindow, contextPercent: null };
+  }
+
   const percent = usage.percent;
   return {
     contextTokens: tokens,

package/dist/extensions/pi-powerline-footer/currency-rates.ts

@@ -0,0 +1,142 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { getAgentPath } from "./paths.ts";
+
+export const SUPPORTED_COST_CURRENCIES = ["USD", "CNY", "EUR", "GBP", "JPY", "CAD", "AUD", "CHF", "INR", "KRW"] as const;
+export type CostCurrencyCode = typeof SUPPORTED_COST_CURRENCIES[number];
+
+const CURRENCY_SYMBOLS: Record<CostCurrencyCode, string> = {
+  USD: "$",
+  CNY: "¥",
+  EUR: "€",
+  GBP: "£",
+  JPY: "¥",
+  CAD: "CA$",
+  AUD: "A$",
+  CHF: "CHF ",
+  INR: "₹",
+  KRW: "₩",
+};
+
+const RATE_TTL_MS = 24 * 60 * 60 * 1000;
+const RATE_URL = "https://cdn.jsdelivr.net/npm/@fawazahmed0/currency-api@latest/v1/currencies/usd.min.json";
+const RATE_CACHE_PATH = getAgentPath("powerline-footer", "currency-rates.json");
+
+type RateTable = Partial<Record<CostCurrencyCode, number>>;
+
+interface CachedRates {
+  timestamp: number;
+  rates: RateTable;
+}
+
+let cachedRates: CachedRates | null = null;
+let pendingFetch: Promise<void> | null = null;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+export function normalizeCostCurrency(value: unknown): CostCurrencyCode | undefined {
+  if (typeof value !== "string") return undefined;
+  const code = value.trim().toUpperCase();
+  return (SUPPORTED_COST_CURRENCIES as readonly string[]).includes(code) ? code as CostCurrencyCode : undefined;
+}
+
+function parseCachedRates(value: unknown): CachedRates | null {
+  if (!isRecord(value) || typeof value.timestamp !== "number" || !isRecord(value.rates)) return null;
+
+  const rates: RateTable = { USD: 1 };
+  for (const currency of SUPPORTED_COST_CURRENCIES) {
+    const rate = value.rates[currency.toLowerCase()] ?? value.rates[currency];
+    if (typeof rate === "number" && Number.isFinite(rate) && rate > 0) {
+      rates[currency] = rate;
+    }
+  }
+
+  return { timestamp: value.timestamp, rates };
+}
+
+async function readCachedRatesFromDisk(): Promise<CachedRates | null> {
+  try {
+    return parseCachedRates(JSON.parse(await readFile(RATE_CACHE_PATH, "utf8")));
+  } catch {
+    return null;
+  }
+}
+
+async function writeCachedRatesToDisk(rates: CachedRates): Promise<void> {
+  try {
+    await mkdir(dirname(RATE_CACHE_PATH), { recursive: true });
+    await writeFile(RATE_CACHE_PATH, JSON.stringify(rates));
+  } catch {
+    // The footer can still use in-memory rates when the cache file is unavailable.
+  }
+}
+
+async function fetchLatestRates(): Promise<CachedRates> {
+  const response = await fetch(RATE_URL);
+  if (!response.ok) throw new Error(`currency rate fetch failed with HTTP ${response.status}`);
+
+  const body = await response.json();
+  if (!isRecord(body) || !isRecord(body.usd)) throw new Error("currency rate response did not include USD rates");
+
+  const rates: RateTable = { USD: 1 };
+  for (const currency of SUPPORTED_COST_CURRENCIES) {
+    if (currency === "USD") continue;
+    const rate = body.usd[currency.toLowerCase()];
+    if (typeof rate === "number" && Number.isFinite(rate) && rate > 0) {
+      rates[currency] = rate;
+    }
+  }
+
+  return { timestamp: Date.now(), rates };
+}
+
+function ensureRatesRefreshing(now: number): void {
+  if (pendingFetch) return;
+  if (cachedRates && now - cachedRates.timestamp < RATE_TTL_MS) return;
+
+  pendingFetch = (async () => {
+    if (!cachedRates) cachedRates = await readCachedRatesFromDisk();
+    if (cachedRates && Date.now() - cachedRates.timestamp < RATE_TTL_MS) return;
+    if (typeof fetch !== "function") return;
+
+    try {
+      const rates = await fetchLatestRates();
+      cachedRates = rates;
+      void writeCachedRatesToDisk(rates);
+    } catch {
+      if (!cachedRates) cachedRates = await readCachedRatesFromDisk();
+    }
+  })().finally(() => {
+    pendingFetch = null;
+  });
+}
+
+function getRate(currency: CostCurrencyCode): number | null {
+  if (currency === "USD") return 1;
+
+  const rate = cachedRates?.rates[currency];
+  ensureRatesRefreshing(Date.now());
+
+  return typeof rate === "number" && Number.isFinite(rate) && rate > 0 ? rate : null;
+}
+
+export function formatUsdCost(amountUsd: number, currency: CostCurrencyCode = "USD"): string | null {
+  const rate = getRate(currency);
+  if (!rate) return `-- ${currency}`;
+
+  const amount = amountUsd * rate;
+  const decimals = currency === "JPY" || currency === "KRW" ? 0 : 2;
+  return `${CURRENCY_SYMBOLS[currency]}${amount.toFixed(decimals)}`;
+}
+
+export function __setCurrencyRatesForTest(rates: RateTable, timestamp = Date.now()): void {
+  cachedRates = { timestamp, rates: { USD: 1, ...rates } };
+  pendingFetch = null;
+}
+
+export function __resetCurrencyRatesForTest(): void {
+  cachedRates = null;
+  pendingFetch = null;
+}

package/dist/extensions/pi-powerline-footer/editor-composition.ts

@@ -0,0 +1,32 @@
+import type { AutocompleteProvider } from "@earendil-works/pi-tui";
+
+export function getEditorAutocompleteProvider(sourceEditor: unknown): AutocompleteProvider | undefined {
+  const candidate = sourceEditor && typeof sourceEditor === "object" ? Reflect.get(sourceEditor, "autocompleteProvider") : null;
+  if (!candidate || typeof candidate !== "object") {
+    return undefined;
+  }
+  if (typeof Reflect.get(candidate, "getSuggestions") !== "function") {
+    return undefined;
+  }
+  if (typeof Reflect.get(candidate, "applyCompletion") !== "function") {
+    return undefined;
+  }
+  return candidate;
+}
+
+export function passAutocompleteProviderThroughPreviousEditor(
+  provider: AutocompleteProvider,
+  previousEditor: unknown,
+): AutocompleteProvider {
+  if (!previousEditor || typeof previousEditor !== "object") {
+    return provider;
+  }
+
+  const setAutocompleteProvider = Reflect.get(previousEditor, "setAutocompleteProvider");
+  if (typeof setAutocompleteProvider !== "function") {
+    return getEditorAutocompleteProvider(previousEditor) ?? provider;
+  }
+
+  setAutocompleteProvider.call(previousEditor, provider);
+  return getEditorAutocompleteProvider(previousEditor) ?? provider;
+}

package/dist/extensions/pi-powerline-footer/git-status.ts

@@ -13,14 +13,37 @@ interface CachedBranch {
   timestamp: number;
 }
 
+export type GitPollingMode = "full" | "branch" | "off";
+
+/** Known git hosting providers we render a dedicated icon for. */
+export type GitHost = "github" | "gitlab" | "bitbucket" | "other";
+
+interface CachedRemoteHost {
+  host: GitHost | null;
+  timestamp: number;
+}
+
 const CACHE_TTL_MS = 1000; // 1 second for file status
 const BRANCH_TTL_MS = 500; // Shorter TTL so branch updates quickly after invalidation
+const REMOTE_TTL_MS = 60_000; // Origin remote almost never changes within a session
 let cachedStatus: CachedGitStatus | null = null;
 let cachedBranch: CachedBranch | null = null;
+let cachedRemoteHost: CachedRemoteHost | null = null;
+let pendingRemoteFetch: Promise<void> | null = null;
 let pendingFetch: Promise<void> | null = null;
 let pendingBranchFetch: Promise<void> | null = null;
 let invalidationCounter = 0; // Track invalidations to prevent stale updates
 let branchInvalidationCounter = 0;
+const updateListeners = new Set<() => void>();
+
+function notifyGitUpdate(): void {
+  for (const listener of updateListeners) listener();
+}
+
+export function subscribeGitUpdates(listener: () => void): () => void {
+  updateListeners.add(listener);
+  return () => updateListeners.delete(listener);
+}
 
 /**
  * Parse git status --porcelain output
@@ -108,6 +131,73 @@ async function fetchGitBranch(): Promise<string | null> {
   return sha ? `${sha} (detached)` : "detached";
 }
 
+/**
+ * Classify an origin remote URL into a known hosting provider. Handles both
+ * SSH (`git@host:owner/repo`, `ssh://git@host/…`) and HTTP(S) forms, and
+ * treats sub-domains (e.g. `www.github.com`) and any non-empty remote we
+ * don't recognize as a generic git host.
+ */
+export function detectGitHost(remoteUrl: string | null): GitHost | null {
+  if (!remoteUrl) return null;
+  const trimmed = remoteUrl.trim();
+  if (!trimmed) return null;
+
+  let host: string;
+  const scpLike = /^[^/@]+@([^:/]+):/.exec(trimmed);
+  if (scpLike) {
+    host = scpLike[1]!;
+  } else {
+    try {
+      host = new URL(trimmed).hostname;
+    } catch {
+      return "other";
+    }
+  }
+
+  host = host.toLowerCase().replace(/^www\./, "");
+  if (host === "github.com" || host.endsWith(".github.com")) return "github";
+  if (host === "gitlab.com" || host.endsWith(".gitlab.com")) return "gitlab";
+  if (host === "bitbucket.org" || host.endsWith(".bitbucket.org")) return "bitbucket";
+  return "other";
+}
+
+/**
+ * Fetch the origin remote host asynchronously and cache the result.
+ */
+async function fetchRemoteHost(): Promise<GitHost | null> {
+  const url = await runGit(["remote", "get-url", "origin"]);
+  return detectGitHost(url);
+}
+
+/**
+ * Get the origin remote's hosting provider with a long TTL cache. Returns the
+ * cached value immediately (or null before the first fetch completes) and
+ * refreshes in the background, matching the branch/status caching pattern.
+ */
+export function getGitRemoteHost(): GitHost | null {
+  const now = Date.now();
+  if (cachedRemoteHost && now - cachedRemoteHost.timestamp < REMOTE_TTL_MS) {
+    return cachedRemoteHost.host;
+  }
+
+  if (!pendingRemoteFetch) {
+    pendingRemoteFetch = fetchRemoteHost()
+      .then((host) => {
+        cachedRemoteHost = { host, timestamp: Date.now() };
+        notifyGitUpdate();
+      })
+      .catch(() => {
+        cachedRemoteHost = { host: null, timestamp: Date.now() };
+        notifyGitUpdate();
+      })
+      .finally(() => {
+        pendingRemoteFetch = null;
+      });
+  }
+
+  return cachedRemoteHost ? cachedRemoteHost.host : null;
+}
+
 /**
  * Fetch git status asynchronously
  */
@@ -139,6 +229,7 @@ export function getCurrentBranch(providerBranch: string | null): string | null {
           branch: result,
           timestamp: Date.now(),
         };
+        notifyGitUpdate();
       }
       pendingBranchFetch = null;
     });
@@ -154,9 +245,13 @@ export function getCurrentBranch(providerBranch: string | null): string | null {
  * This is designed for synchronous render() calls - returns last known value
  * while refreshing in background.
  */
-export function getGitStatus(providerBranch: string | null): GitStatus {
+export function getGitStatus(providerBranch: string | null, pollingMode: GitPollingMode = "full"): GitStatus {
   const now = Date.now();
-  const branch = getCurrentBranch(providerBranch);
+  const branch = pollingMode === "off" ? providerBranch : getCurrentBranch(providerBranch);
+
+  if (pollingMode !== "full") {
+    return { branch, staged: 0, unstaged: 0, untracked: 0 };
+  }
 
   // Return cached if fresh
   if (cachedStatus && now - cachedStatus.timestamp < CACHE_TTL_MS) {
@@ -177,6 +272,7 @@ export function getGitStatus(providerBranch: string | null): GitStatus {
         cachedStatus = result
           ? { staged: result.staged, unstaged: result.unstaged, untracked: result.untracked, timestamp: Date.now() }
           : { staged: 0, unstaged: 0, untracked: 0, timestamp: Date.now() };
+        notifyGitUpdate();
       }
       pendingFetch = null;
     });
@@ -196,17 +292,23 @@ export function getGitStatus(providerBranch: string | null): GitStatus {
 }
 
 /**
- * Force refresh git status (call when you know files changed)
+ * Force refresh git status (call when you know files changed).
+ * Serve-stale: keep the last known counts on screen while a background
+ * refresh runs, instead of blanking the segment to zeros (footer flicker).
  */
 export function invalidateGitStatus(): void {
-  cachedStatus = null;
+  if (cachedStatus) cachedStatus.timestamp = 0; // expire, but keep serving the stale value
   invalidationCounter++; // Increment to invalidate any pending fetches
 }
 
 /**
- * Force refresh git branch (call when you know branch might have changed)
+ * Force refresh git branch (call when you know branch might have changed).
+ * Serve-stale: keep showing the last known branch until the refresh lands.
  */
 export function invalidateGitBranch(): void {
-  cachedBranch = null;
+  if (cachedBranch) cachedBranch.timestamp = 0; // expire, but keep serving the stale value
   branchInvalidationCounter++;
+  // The origin remote is repo-scoped, so a branch/cwd change may mean a
+  // different repo; drop the host cache so it re-detects.
+  cachedRemoteHost = null;
 }

package/dist/extensions/pi-powerline-footer/guide.ts

@@ -149,7 +149,7 @@ export function getGuidePreferences(settings: unknown): GuidePreferences {
     : {};
 
   return {
-    mode: isGuideMode(raw.mode) ? raw.mode : "full",
+    mode: isGuideMode(raw.mode) ? raw.mode : "compact",
     lastSeenVersion: typeof raw.lastSeenVersion === "string" ? raw.lastSeenVersion : undefined,
   };
 }

package/dist/extensions/pi-powerline-footer/icons.ts

@@ -6,6 +6,9 @@ export interface IconSet {
   folder: string;
   branch: string;
   git: string;
+  github: string;
+  gitlab: string;
+  bitbucket: string;
   tokens: string;
   context: string;
   cost: string;
@@ -56,8 +59,11 @@ export const NERD_ICONS: IconSet = {
   folder: "\uF115",     // nf-fa-folder_open
   branch: "\uF126",     // nf-fa-code_fork (git branch)
   git: "\uF1D3",        // nf-fa-git (git logo)
+  github: "\uF09B",     // nf-fa-github (octocat)
+  gitlab: "\uF296",     // nf-fa-gitlab (tanuki)
+  bitbucket: "\uF171",  // nf-fa-bitbucket
   tokens: "\uE26B",     // nf-seti-html (tokens symbol)
-  context: "\uE70F",    // nf-dev-database (database)
+  context: "\uF1C0",    // nf-fa-database (stable Nerd Fonts v3 database)
   cost: "\uF155",       // nf-fa-dollar
   time: "\uF017",       // nf-fa-clock_o
   agents: "\uF0C0",     // nf-fa-users
@@ -77,6 +83,9 @@ export const ASCII_ICONS: IconSet = {
   folder: "dir",
   branch: "⎇",
   git: "⎇",
+  github: "⎇",
+  gitlab: "⎇",
+  bitbucket: "⎇",
   tokens: "⊛",
   context: "◫",
   cost: "$",
@@ -101,7 +110,7 @@ function sanitizeUserIconOverrides(value: unknown): PartialIconSet {
   const sanitized: PartialIconSet = {};
   const validKeys = Object.keys(NERD_ICONS) as Array<keyof IconSet>;
   for (const key of validKeys) {
-    const icon = value[key];
+    const icon = Reflect.get(value, key);
     if (typeof icon === "string") {
       sanitized[key] = icon;
     }