@selesai/code 0.1.0

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

@@ -0,0 +1,212 @@
+import { spawn } from "node:child_process";
+import type { GitStatus } from "./types.ts";
+
+interface CachedGitStatus {
+  staged: number;
+  unstaged: number;
+  untracked: number;
+  timestamp: number;
+}
+
+interface CachedBranch {
+  branch: string | 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
+let cachedStatus: CachedGitStatus | null = null;
+let cachedBranch: CachedBranch | 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;
+
+/**
+ * Parse git status --porcelain output
+ * 
+ * Format: XY filename
+ * X = index status, Y = working tree status
+ * ?? = untracked
+ * Other X values = staged
+ * Other Y values = unstaged
+ */
+function parseGitStatusOutput(output: string): { staged: number; unstaged: number; untracked: number } {
+  let staged = 0;
+  let unstaged = 0;
+  let untracked = 0;
+
+  for (const line of output.split("\n")) {
+    if (!line) continue;
+    const x = line[0];
+    const y = line[1];
+
+    if (x === "?" && y === "?") {
+      untracked++;
+      continue;
+    }
+
+    // X position (index/staged)
+    if (x && x !== " " && x !== "?") {
+      staged++;
+    }
+
+    // Y position (working tree/unstaged)
+    if (y && y !== " ") {
+      unstaged++;
+    }
+  }
+
+  return { staged, unstaged, untracked };
+}
+
+function runGit(args: string[], timeoutMs = 200): Promise<string | null> {
+  return new Promise((resolve) => {
+    const proc = spawn("git", args, {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let resolved = false;
+
+    const finish = (result: string | null) => {
+      if (resolved) return;
+      resolved = true;
+      clearTimeout(timeoutId);
+      resolve(result);
+    };
+
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    proc.on("close", (code) => {
+      finish(code === 0 ? stdout.trim() : null);
+    });
+
+    proc.on("error", () => {
+      finish(null);
+    });
+
+    const timeoutId = setTimeout(() => {
+      proc.kill();
+      finish(null);
+    }, timeoutMs);
+  });
+}
+
+/**
+ * Fetch current git branch asynchronously.
+ * For detached HEAD, returns the short commit SHA (matches provider's "detached" behavior).
+ */
+async function fetchGitBranch(): Promise<string | null> {
+  const branch = await runGit(["branch", "--show-current"]);
+  if (branch === null) return null;
+  if (branch) return branch;
+
+  const sha = await runGit(["rev-parse", "--short", "HEAD"]);
+  return sha ? `${sha} (detached)` : "detached";
+}
+
+/**
+ * Fetch git status asynchronously
+ */
+async function fetchGitStatus(): Promise<{ staged: number; unstaged: number; untracked: number } | null> {
+  const output = await runGit(["status", "--porcelain"], 500);
+  if (output === null) return null;
+  return parseGitStatusOutput(output);
+}
+
+/**
+ * Get the current git branch with caching.
+ * Falls back to provider branch if our cache is empty.
+ */
+export function getCurrentBranch(providerBranch: string | null): string | null {
+  const now = Date.now();
+
+  // Return cached if fresh
+  if (cachedBranch && now - cachedBranch.timestamp < BRANCH_TTL_MS) {
+    return cachedBranch.branch;
+  }
+
+  // Trigger background fetch if not already pending
+  if (!pendingBranchFetch) {
+    const fetchId = branchInvalidationCounter;
+    pendingBranchFetch = fetchGitBranch().then((result) => {
+      // Cache result if no invalidation happened (including null for non-git dirs)
+      if (fetchId === branchInvalidationCounter) {
+        cachedBranch = {
+          branch: result,
+          timestamp: Date.now(),
+        };
+      }
+      pendingBranchFetch = null;
+    });
+  }
+
+  // Return stale cache while refreshing; only use provider before first fetch
+  return cachedBranch ? cachedBranch.branch : providerBranch;
+}
+
+/**
+ * Get git status with caching.
+ * Returns cached value if within TTL, otherwise triggers async fetch.
+ * This is designed for synchronous render() calls - returns last known value
+ * while refreshing in background.
+ */
+export function getGitStatus(providerBranch: string | null): GitStatus {
+  const now = Date.now();
+  const branch = getCurrentBranch(providerBranch);
+
+  // Return cached if fresh
+  if (cachedStatus && now - cachedStatus.timestamp < CACHE_TTL_MS) {
+    return { 
+      branch, 
+      staged: cachedStatus.staged,
+      unstaged: cachedStatus.unstaged,
+      untracked: cachedStatus.untracked,
+    };
+  }
+
+  // Trigger background fetch if not already pending
+  if (!pendingFetch) {
+    const fetchId = invalidationCounter; // Capture current counter
+    pendingFetch = fetchGitStatus().then((result) => {
+      // Cache result if no invalidation happened (including null for non-git dirs)
+      if (fetchId === invalidationCounter) {
+        cachedStatus = result
+          ? { staged: result.staged, unstaged: result.unstaged, untracked: result.untracked, timestamp: Date.now() }
+          : { staged: 0, unstaged: 0, untracked: 0, timestamp: Date.now() };
+      }
+      pendingFetch = null;
+    });
+  }
+
+  // Return last cached or empty
+  if (cachedStatus) {
+    return { 
+      branch, 
+      staged: cachedStatus.staged,
+      unstaged: cachedStatus.unstaged,
+      untracked: cachedStatus.untracked,
+    };
+  }
+
+  return { branch, staged: 0, unstaged: 0, untracked: 0 };
+}
+
+/**
+ * Force refresh git status (call when you know files changed)
+ */
+export function invalidateGitStatus(): void {
+  cachedStatus = null;
+  invalidationCounter++; // Increment to invalidate any pending fetches
+}
+
+/**
+ * Force refresh git branch (call when you know branch might have changed)
+ */
+export function invalidateGitBranch(): void {
+  cachedBranch = null;
+  branchInvalidationCounter++;
+}

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

@@ -0,0 +1,181 @@
+import { loadThemeConfig } from "./theme.ts";
+
+export interface IconSet {
+  pi: string;
+  model: string;
+  folder: string;
+  branch: string;
+  git: string;
+  tokens: string;
+  context: string;
+  cost: string;
+  time: string;
+  agents: string;
+  cache: string;
+  input: string;
+  output: string;
+  host: string;
+  session: string;
+  auto: string;
+  warning: string;
+}
+
+// Separator characters
+export const SEP_DOT = " · ";
+
+// Thinking level display text (Unicode/ASCII)
+export const THINKING_TEXT_UNICODE: Record<string, string> = {
+  minimal: "[min]",
+  low: "[low]",
+  medium: "[med]",
+  high: "[high]",
+  xhigh: "[xhi]",
+};
+
+// Thinking level display text (Nerd Fonts - with icons)
+export const THINKING_TEXT_NERD: Record<string, string> = {
+  minimal: "\u{F0E7} min",   // lightning bolt
+  low: "\u{F10C} low",       // circle outline
+  medium: "\u{F192} med",    // dot circle
+  high: "\u{F111} high",     // circle
+  xhigh: "\u{F06D} xhi",     // fire
+};
+
+// Get thinking text based on font support
+export function getThinkingText(level: string): string | undefined {
+  if (hasNerdFonts()) {
+    return THINKING_TEXT_NERD[level];
+  }
+  return THINKING_TEXT_UNICODE[level];
+}
+
+// Nerd Font icons (matching oh-my-pi exactly)
+export const NERD_ICONS: IconSet = {
+  pi: "\uE22C",         // nf-oct-pi (stylized pi icon)
+  model: "\uEC19",      // nf-md-chip (model/AI chip)
+  folder: "\uF115",     // nf-fa-folder_open
+  branch: "\uF126",     // nf-fa-code_fork (git branch)
+  git: "\uF1D3",        // nf-fa-git (git logo)
+  tokens: "\uE26B",     // nf-seti-html (tokens symbol)
+  context: "\uE70F",    // nf-dev-database (database)
+  cost: "\uF155",       // nf-fa-dollar
+  time: "\uF017",       // nf-fa-clock_o
+  agents: "\uF0C0",     // nf-fa-users
+  cache: "\uF1C0",      // nf-fa-database (cache)
+  input: "\uF090",      // nf-fa-sign_in (input arrow)
+  output: "\uF08B",     // nf-fa-sign_out (output arrow)
+  host: "\uF109",       // nf-fa-laptop (host)
+  session: "\uF550",    // nf-md-identifier (session id)
+  auto: "\u{F0068}",    // nf-md-lightning_bolt (auto-compact)
+  warning: "\uF071",    // nf-fa-warning
+};
+
+// ASCII/Unicode fallback icons (matching oh-my-pi)
+export const ASCII_ICONS: IconSet = {
+  pi: "π",
+  model: "",
+  folder: "dir",
+  branch: "⎇",
+  git: "⎇",
+  tokens: "⊛",
+  context: "◫",
+  cost: "$",
+  time: "◷",
+  agents: "AG",
+  cache: "cache",
+  input: "in:",
+  output: "out:",
+  host: "host",
+  session: "id",
+  auto: "AC",
+  warning: "!",
+};
+
+type PartialIconSet = Partial<IconSet>;
+
+function sanitizeUserIconOverrides(value: unknown): PartialIconSet {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return {};
+  }
+
+  const sanitized: PartialIconSet = {};
+  const validKeys = Object.keys(NERD_ICONS) as Array<keyof IconSet>;
+  for (const key of validKeys) {
+    const icon = value[key];
+    if (typeof icon === "string") {
+      sanitized[key] = icon;
+    }
+  }
+
+  return sanitized;
+}
+
+// Separator characters
+export interface SeparatorChars {
+  powerlineLeft: string;
+  powerlineRight: string;
+  powerlineThinLeft: string;
+  powerlineThinRight: string;
+  slash: string;
+  pipe: string;
+  block: string;
+  space: string;
+  asciiLeft: string;
+  asciiRight: string;
+  dot: string;
+}
+
+export const NERD_SEPARATORS: SeparatorChars = {
+  powerlineLeft: "\uE0B0",    //
+  powerlineRight: "\uE0B2",   //
+  powerlineThinLeft: "\uE0B1", //
+  powerlineThinRight: "\uE0B3", //
+  slash: "/",
+  pipe: "|",
+  block: "█",
+  space: " ",
+  asciiLeft: ">",
+  asciiRight: "<",
+  dot: "·",
+};
+
+export const ASCII_SEPARATORS: SeparatorChars = {
+  powerlineLeft: ">",
+  powerlineRight: "<",
+  powerlineThinLeft: "|",
+  powerlineThinRight: "|",
+  slash: "/",
+  pipe: "|",
+  block: "#",
+  space: " ",
+  asciiLeft: ">",
+  asciiRight: "<",
+  dot: ".",
+};
+
+// Detect Nerd Font support (check TERM or specific env var)
+export function hasNerdFonts(): boolean {
+  // User can set this env var to force Nerd Fonts
+  if (process.env.POWERLINE_NERD_FONTS === "1") return true;
+  if (process.env.POWERLINE_NERD_FONTS === "0") return false;
+
+  // Check for Ghostty (survives into tmux via GHOSTTY_RESOURCES_DIR)
+  if (process.env.GHOSTTY_RESOURCES_DIR) return true;
+
+  // Check common terminals known to support Nerd Fonts (case-insensitive)
+  const term = (process.env.TERM_PROGRAM || "").toLowerCase();
+  const nerdTerms = ["iterm", "wezterm", "kitty", "ghostty", "alacritty"];
+  return nerdTerms.some(t => term.includes(t));
+}
+
+export function getIcons(): IconSet {
+  const baseIcons = hasNerdFonts() ? NERD_ICONS : ASCII_ICONS;
+  return {
+    ...baseIcons,
+    ...sanitizeUserIconOverrides(loadThemeConfig().icons),
+  };
+}
+
+export function getSeparatorChars(): SeparatorChars {
+  return hasNerdFonts() ? NERD_SEPARATORS : ASCII_SEPARATORS;
+}