@groeponline/pi-wishcraft 0.17.3

package/src/usage/rates.ts

@@ -0,0 +1,155 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { getAgentPath } from "../paths/agent-dirs.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 SYMBOLS: Record<CostCurrencyCode, string> = {
+  USD: "$",
+  CNY: "¥",
+  EUR: "€",
+  GBP: "£",
+  JPY: "¥",
+  CAD: "CA$",
+  AUD: "A$",
+  CHF: "CHF ",
+  INR: "₹",
+  KRW: "₩",
+};
+
+const TTL_MS = 24 * 60 * 60 * 1000;
+const ENDPOINT = "https://cdn.jsdelivr.net/npm/@fawazahmed0/currency-api@latest/v1/currencies/usd.min.json";
+const CACHE_FILE = getAgentPath("powerline-footer", "currency-rates.json");
+
+export type CurrencyDisplayMode = "symbol" | "code" | "both";
+
+export function currencySymbol(currency: CostCurrencyCode): string {
+  return SYMBOLS[currency];
+}
+
+export function normalizeCostCurrency(value: unknown): CostCurrencyCode | undefined {
+  if (typeof value !== "string") return undefined;
+  const upper = value.trim().toUpperCase();
+  return (SUPPORTED_COST_CURRENCIES as readonly string[]).includes(upper)
+    ? (upper as CostCurrencyCode)
+    : undefined;
+}
+
+interface CacheData {
+  timestamp: number;
+  rates: Partial<Record<CostCurrencyCode, number>>;
+}
+
+let activeCache: CacheData | null = null;
+let updatePromise: Promise<void> | null = null;
+
+async function loadFromDisk(): Promise<CacheData | null> {
+  try {
+    const raw = await readFile(CACHE_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed && typeof parsed.timestamp === "number" && typeof parsed.rates === "object" && parsed.rates) {
+      return parsed as CacheData;
+    }
+  } catch {
+    // Ignore read errors
+  }
+  return null;
+}
+
+async function saveToDisk(data: CacheData): Promise<void> {
+  try {
+    await mkdir(dirname(CACHE_FILE), { recursive: true });
+    await writeFile(CACHE_FILE, JSON.stringify(data));
+  } catch {
+    // Ignore write errors
+  }
+}
+
+async function fetchRatesFromNetwork(): Promise<CacheData> {
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), 10000); // 10s timeout
+  try {
+    const res = await fetch(ENDPOINT, { signal: controller.signal });
+    if (!res.ok) throw new Error("Fetch failed");
+    const body = await res.json();
+    if (!body || typeof body !== "object" || !body.usd) throw new Error("Invalid response format");
+    const rates: Partial<Record<CostCurrencyCode, number>> = { USD: 1 };
+    for (const code of SUPPORTED_COST_CURRENCIES) {
+      if (code === "USD") continue;
+      const rate = body.usd[code.toLowerCase()];
+      if (typeof rate === "number" && Number.isFinite(rate) && rate > 0) {
+        rates[code] = rate;
+      }
+    }
+    return { timestamp: Date.now(), rates };
+  } finally {
+    clearTimeout(id);
+  }
+}
+
+function triggerRefresh(now: number): void {
+  if (updatePromise) return;
+  if (activeCache && now - activeCache.timestamp < TTL_MS) return;
+
+  updatePromise = (async () => {
+    if (!activeCache) activeCache = await loadFromDisk();
+    if (activeCache && Date.now() - activeCache.timestamp < TTL_MS) return;
+    
+    try {
+      const latest = await fetchRatesFromNetwork();
+      activeCache = latest;
+      void saveToDisk(latest);
+    } catch {
+      if (!activeCache) activeCache = await loadFromDisk();
+    }
+  })().finally(() => {
+    updatePromise = null;
+  });
+}
+
+function getConversionRate(currency: CostCurrencyCode): number | null {
+  if (currency === "USD") return 1;
+  const r = activeCache?.rates[currency];
+  triggerRefresh(Date.now());
+  return typeof r === "number" && Number.isFinite(r) && r > 0 ? r : null;
+}
+
+export function convertCost(amountUsd: number, currency: CostCurrencyCode): number | null {
+  const rate = getConversionRate(currency);
+  if (!rate) return null;
+  return amountUsd * rate;
+}
+
+export function formatDisplayCost(amountUsd: number, currency: CostCurrencyCode = "USD"): string | null {
+  const converted = convertCost(amountUsd, currency);
+  if (converted === null) return `-- ${currency}`;
+  const decimals = (currency === "JPY" || currency === "KRW") ? 0 : 2;
+  return `${currencySymbol(currency)}${converted.toFixed(decimals)}`;
+}
+
+export function formatUsdCost(amountUsd: number, currency: CostCurrencyCode = "USD"): string | null {
+  return formatDisplayCost(amountUsd, currency);
+}
+
+export function __setCurrencyRatesForTest(rates: Partial<Record<CostCurrencyCode, number>>, timestamp = Date.now()): void {
+  activeCache = { timestamp, rates: { USD: 1, ...rates } };
+  updatePromise = null;
+}
+
+export function __resetCurrencyRatesForTest(): void {
+  activeCache = null;
+  updatePromise = null;
+}

package/src/welcome/auto-dismiss.ts

@@ -0,0 +1,43 @@
+export interface WelcomeDismissScheduler<Context> {
+  schedule(ctx: Context): void;
+  cancel(): void;
+}
+
+interface WelcomeDismissSchedulerOptions<Context> {
+  dismiss(ctx: Context): void;
+  getGeneration(): number;
+  isEnabled(): boolean;
+}
+
+export function createWelcomeDismissScheduler<Context>(
+  options: WelcomeDismissSchedulerOptions<Context>,
+): WelcomeDismissScheduler<Context> {
+  let activeTimer: ReturnType<typeof setTimeout> | null = null;
+
+  return {
+    schedule(ctx) {
+      if (activeTimer !== null) {
+        return;
+      }
+
+      const capturedGeneration = options.getGeneration();
+
+      activeTimer = setTimeout(() => {
+        activeTimer = null;
+
+        if (!options.isEnabled() || capturedGeneration !== options.getGeneration()) {
+          return;
+        }
+
+        options.dismiss(ctx);
+      }, 0);
+    },
+    cancel() {
+      if (activeTimer === null) {
+        return;
+      }
+      clearTimeout(activeTimer);
+      activeTimer = null;
+    },
+  };
+}

package/src/welcome/banner.ts

@@ -0,0 +1,68 @@
+import type { Component } from "@earendil-works/pi-tui";
+import { dim, renderWelcomeBox } from "./renderer.ts";
+import type { WelcomeData } from "./types.ts";
+import type { LoadedCounts, RecentSession } from "./types.ts";
+
+/**
+ * Welcome header - same layout as overlay but persistent (no countdown).
+ * Used when quietStartup: true.
+ */
+export class WelcomeHeader implements Component {
+  private data: WelcomeData;
+
+  constructor(
+    modelName: string,
+    providerName: string,
+    recentSessions: RecentSession[] = [],
+    loadedCounts: LoadedCounts = {
+      contextFiles: 0,
+      extensions: 0,
+      skills: 0,
+      promptTemplates: 0,
+    },
+    initialContextTokens: number | null = null,
+    queueCount?: number,
+    hasStash?: boolean,
+  ) {
+    this.data = {
+      modelName,
+      providerName,
+      recentSessions,
+      loadedCounts,
+      initialContextTokens,
+      queueCount,
+      hasStash,
+    };
+  }
+
+  invalidate(): void {}
+
+  render(termWidth: number): string[] {
+    // Minimum width for two-column layout (must match renderWelcomeBox)
+    const minLayoutWidth = 44;
+    if (termWidth < minLayoutWidth) {
+      return [];
+    }
+
+    const minWidth = 76;
+    const maxWidth = 96;
+    // Clamp to termWidth to prevent crash on narrow terminals
+    const boxWidth = Math.min(
+      termWidth,
+      Math.max(minWidth, Math.min(termWidth - 2, maxWidth)),
+    );
+    const hChar = "─";
+
+    // Bottom line with column separator (leftCol=26, rightCol=boxWidth-29)
+    const leftCol = 26;
+    const rightCol = Math.max(1, boxWidth - leftCol - 3);
+    const bottomLine =
+      dim(hChar.repeat(leftCol)) + dim("┴") + dim(hChar.repeat(rightCol));
+
+    const lines = renderWelcomeBox(this.data, termWidth, bottomLine);
+    if (lines.length > 0) {
+      lines.push(""); // Add empty line for spacing only if we rendered content
+    }
+    return lines;
+  }
+}

package/src/welcome/discover.ts

@@ -0,0 +1,234 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join, basename } from "node:path";
+import { getAgentPath, getHomeDir } from "../paths/agent-dirs.ts";
+import type { LoadedCounts } from "./types.ts";
+
+const loggedDiscoveryErrors = new Set<string>();
+
+export function logDiscoveryError(scope: string, error: unknown): void {
+  if (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    (error as { code?: unknown }).code === "ENOENT"
+  ) {
+    return;
+  }
+
+  const message = error instanceof Error ? error.message : String(error);
+  const key = `${scope}:${message}`;
+  if (loggedDiscoveryErrors.has(key)) {
+    return;
+  }
+
+  loggedDiscoveryErrors.add(key);
+  if (loggedDiscoveryErrors.size > 500) {
+    loggedDiscoveryErrors.clear();
+  }
+
+  console.debug(`[powerline-welcome] ${scope}:`, error);
+}
+
+function scanContextFiles(homeDir: string, cwd: string): number {
+  let count = 0;
+  const agentsMdPaths = [
+    getAgentPath("AGENTS.md"),
+    join(homeDir, ".claude", "AGENTS.md"),
+    join(cwd, "AGENTS.md"),
+    join(cwd, ".pi", "AGENTS.md"),
+    join(cwd, ".claude", "AGENTS.md"),
+  ];
+
+  for (const path of agentsMdPaths) {
+    if (existsSync(path)) count++;
+  }
+  return count;
+}
+
+function scanExtensions(cwd: string): number {
+  let count = 0;
+  const countedExtensions = new Set<string>();
+  const settingsPaths = [
+    getAgentPath("settings.json"),
+    join(cwd, ".pi", "settings.json"),
+  ];
+
+  for (const settingsPath of settingsPaths) {
+    if (!existsSync(settingsPath)) continue;
+
+    try {
+      const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+      let packages: unknown = null;
+      if (typeof settings === "object" && settings !== null && !Array.isArray(settings)) {
+        packages = "packages" in settings ? (settings as { packages: unknown }).packages : null;
+      }
+
+      if (Array.isArray(packages)) {
+        for (const pkg of packages) {
+          let source: unknown = null;
+          let extensionsFilter: unknown = null;
+
+          if (typeof pkg === "string") {
+            source = pkg;
+          } else if (typeof pkg === "object" && pkg !== null && !Array.isArray(pkg)) {
+            source = "source" in pkg ? (pkg as { source: unknown }).source : null;
+            extensionsFilter = "extensions" in pkg ? (pkg as { extensions: unknown }).extensions : null;
+          }
+
+          if (typeof source !== "string") continue;
+          
+          const normalizedSource = source.trim();
+          if (!normalizedSource.startsWith("npm:")) continue;
+          if (Array.isArray(extensionsFilter) && extensionsFilter.length === 0) continue;
+
+          const body = normalizedSource.slice(4);
+          const versionIndex = body.lastIndexOf("@");
+          const name = versionIndex > 0 ? body.slice(0, versionIndex) : body;
+          
+          if (!name || countedExtensions.has(name)) continue;
+
+          countedExtensions.add(name);
+          count++;
+        }
+      }
+    } catch (error) {
+      logDiscoveryError(`Failed to read settings at ${settingsPath}`, error);
+    }
+  }
+
+  const extensionDirs = [
+    getAgentPath("extensions"),
+    join(cwd, "extensions"),
+    join(cwd, ".pi", "extensions"),
+  ];
+
+  for (const dir of extensionDirs) {
+    if (!existsSync(dir)) continue;
+    
+    try {
+      const entries = readdirSync(dir);
+      for (const entry of entries) {
+        const entryPath = join(dir, entry);
+        try {
+          const stats = statSync(entryPath);
+          if (stats.isDirectory()) {
+            if (
+              existsSync(join(entryPath, "index.ts")) ||
+              existsSync(join(entryPath, "index.js")) ||
+              existsSync(join(entryPath, "package.json"))
+            ) {
+              if (!countedExtensions.has(entry)) {
+                countedExtensions.add(entry);
+                count++;
+              }
+            }
+          } else if ((entry.endsWith(".ts") || entry.endsWith(".js")) && !entry.startsWith(".")) {
+            const ext = entry.endsWith(".ts") ? ".ts" : ".js";
+            const name = basename(entry, ext);
+            if (!countedExtensions.has(name)) {
+              countedExtensions.add(name);
+              count++;
+            }
+          }
+        } catch (error) {
+          logDiscoveryError(`Failed to inspect extension entry ${entryPath}`, error);
+        }
+      }
+    } catch (error) {
+      logDiscoveryError(`Failed to scan extensions dir ${dir}`, error);
+    }
+  }
+
+  return count;
+}
+
+function scanSkills(cwd: string): number {
+  let count = 0;
+  const countedSkills = new Set<string>();
+  const skillDirs = [
+    getAgentPath("skills"),
+    join(cwd, ".pi", "skills"),
+    join(cwd, "skills"),
+  ];
+
+  for (const dir of skillDirs) {
+    if (!existsSync(dir)) continue;
+    
+    try {
+      const entries = readdirSync(dir);
+      for (const entry of entries) {
+        const entryPath = join(dir, entry);
+        try {
+          if (statSync(entryPath).isDirectory() && existsSync(join(entryPath, "SKILL.md"))) {
+            if (!countedSkills.has(entry)) {
+              countedSkills.add(entry);
+              count++;
+            }
+          }
+        } catch (error) {
+          logDiscoveryError(`Failed to inspect skill entry ${entryPath}`, error);
+        }
+      }
+    } catch (error) {
+      logDiscoveryError(`Failed to scan skills dir ${dir}`, error);
+    }
+  }
+
+  return count;
+}
+
+function scanPromptTemplates(homeDir: string, cwd: string): number {
+  const countedTemplates = new Set<string>();
+  let count = 0;
+
+  function countTemplatesInDir(dir: string) {
+    if (!existsSync(dir)) return;
+    try {
+      const entries = readdirSync(dir);
+      for (const entry of entries) {
+        const entryPath = join(dir, entry);
+        try {
+          const stats = statSync(entryPath);
+          if (stats.isDirectory()) {
+            countTemplatesInDir(entryPath);
+          } else if (entry.endsWith(".md")) {
+            const name = basename(entry, ".md");
+            if (!countedTemplates.has(name)) {
+              countedTemplates.add(name);
+              count++;
+            }
+          }
+        } catch (error) {
+          logDiscoveryError(`Failed to inspect prompt template entry ${entryPath}`, error);
+        }
+      }
+    } catch (error) {
+      logDiscoveryError(`Failed to scan prompt template dir ${dir}`, error);
+    }
+  }
+
+  const templateDirs = [
+    getAgentPath("commands"),
+    join(homeDir, ".claude", "commands"),
+    join(cwd, ".pi", "commands"),
+    join(cwd, ".claude", "commands"),
+  ];
+
+  for (const dir of templateDirs) {
+    countTemplatesInDir(dir);
+  }
+
+  return count;
+}
+
+export function discoverLoadedCounts(): LoadedCounts {
+  const homeDir = getHomeDir();
+  const cwd = process.cwd();
+
+  const contextFiles = scanContextFiles(homeDir, cwd);
+  const extensions = scanExtensions(cwd);
+  const skills = scanSkills(cwd);
+  const promptTemplates = scanPromptTemplates(homeDir, cwd);
+
+  return { contextFiles, extensions, skills, promptTemplates };
+}

package/src/welcome/format.ts

@@ -0,0 +1,18 @@
+export function formatTokens(tokens: number): string {
+  if (tokens < 1000) return tokens.toString();
+  if (tokens < 10000) return `${(tokens / 1000).toFixed(1)}k`;
+  if (tokens < 1000000) return `${Math.round(tokens / 1000)}k`;
+  return `${(tokens / 1000000).toFixed(tokens < 10000000 ? 1 : 0)}M`;
+}
+
+export function formatTimeAgo(ms: number): string {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (minutes > 0) return `${minutes}m ago`;
+  return "just now";
+}

package/src/welcome/index.ts

@@ -0,0 +1,5 @@
+export type { LoadedCounts, RecentSession } from "./types.ts";
+export { WelcomeComponent } from "./overlay.ts";
+export { WelcomeHeader } from "./banner.ts";
+export { discoverLoadedCounts } from "./discover.ts";
+export { getRecentSessions } from "./sessions.ts";

package/src/welcome/layout.ts

@@ -0,0 +1,36 @@
+import { visibleWidth, truncateToWidth } from "@earendil-works/pi-tui";
+
+export function fitToWidth(str: string, width: number): string {
+  const visLen = visibleWidth(str);
+  if (visLen > width) return truncateToWidth(str, width, "…");
+  return str + " ".repeat(width - visLen);
+}
+
+export function centerText(text: string, width: number): string {
+  const visLen = visibleWidth(text);
+  if (visLen > width) return truncateToWidth(text, width, "…");
+  if (visLen === width) return text;
+  const leftPad = Math.floor((width - visLen) / 2);
+  const rightPad = width - visLen - leftPad;
+  return " ".repeat(leftPad) + text + " ".repeat(rightPad);
+}
+
+export function getBoxLayout(termWidth: number) {
+  const minLayoutWidth = 44;
+  
+  if (termWidth < minLayoutWidth) {
+    return null;
+  }
+  
+  const minWidth = 76;
+  const maxWidth = 96;
+  const boxWidth = Math.min(
+    termWidth,
+    Math.max(minWidth, Math.min(termWidth - 2, maxWidth))
+  );
+  
+  const leftCol = 26;
+  const rightCol = Math.max(1, boxWidth - leftCol - 3);
+  
+  return { boxWidth, leftCol, rightCol };
+}

package/src/welcome/overlay.ts

@@ -0,0 +1,80 @@
+import type { Component } from "@earendil-works/pi-tui";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { dim, renderWelcomeBox } from "./renderer.ts";
+import type { WelcomeData } from "./types.ts";
+import type { LoadedCounts, RecentSession } from "./types.ts";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Welcome Components
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Welcome overlay component for pi agent.
+ * Displays a branded splash screen with logo, tips, and loaded counts.
+ */
+export class WelcomeComponent implements Component {
+  private data: WelcomeData;
+  private countdown: number = 30;
+
+  constructor(
+    modelName: string,
+    providerName: string,
+    recentSessions: RecentSession[] = [],
+    loadedCounts: LoadedCounts = {
+      contextFiles: 0,
+      extensions: 0,
+      skills: 0,
+      promptTemplates: 0,
+    },
+    initialContextTokens: number | null = null,
+    queueCount?: number,
+    hasStash?: boolean,
+  ) {
+    this.data = {
+      modelName,
+      providerName,
+      recentSessions,
+      loadedCounts,
+      initialContextTokens,
+      queueCount,
+      hasStash,
+    };
+  }
+
+  setCountdown(seconds: number): void {
+    this.countdown = seconds;
+  }
+
+  invalidate(): void {}
+
+  render(termWidth: number): string[] {
+    // Minimum width for two-column layout (must match renderWelcomeBox)
+    const minLayoutWidth = 44;
+    if (termWidth < minLayoutWidth) {
+      return [];
+    }
+
+    const minWidth = 76;
+    const maxWidth = 96;
+    // Clamp to termWidth to prevent crash on narrow terminals
+    const boxWidth = Math.min(
+      termWidth,
+      Math.max(minWidth, Math.min(termWidth - 2, maxWidth)),
+    );
+
+    // Bottom line with countdown
+    const countdownText = ` Press any key to continue (${this.countdown}s) `;
+    const countdownStyled = dim(countdownText);
+    const bottomContentWidth = boxWidth - 2;
+    const countdownVisLen = visibleWidth(countdownText);
+    const leftPad = Math.floor((bottomContentWidth - countdownVisLen) / 2);
+    const rightPad = bottomContentWidth - countdownVisLen - leftPad;
+    const hChar = "─";
+    const bottomLine =
+      dim(hChar.repeat(Math.max(0, leftPad))) +
+      countdownStyled +
+      dim(hChar.repeat(Math.max(0, rightPad)));
+
+    return renderWelcomeBox(this.data, termWidth, bottomLine);
+  }
+}