pi-cc-extensions 0.1.1

package/extensions/ccstyle-powerline/git-status.ts

@@ -0,0 +1,218 @@
+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;
+}
+
+export type GitPollingMode = "full" | "branch" | "off";
+
+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, pollingMode: GitPollingMode = "full"): GitStatus {
+  const now = Date.now();
+  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) {
+    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/extensions/ccstyle-powerline/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]",
+  max: "[max]",
+};
+
+// 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
+  max: "\u{F06D} max",       // fire (maximum reasoning)
+};
+
+// 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 — pure ASCII only, no obscure Unicode that may render as □
+export const ASCII_ICONS: IconSet = {
+  pi: "pi",
+  model: "",
+  folder: "dir",
+  branch: "@",
+  git: "@",
+  tokens: "~",
+  context: "ctx",
+  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 via env var, WT_SESSION, or TERM_PROGRAM.
+ * Windows Terminal (WT_SESSION) often ships with Nerd Fonts or Cascadia Code PL. */
+export function hasNerdFonts(): boolean {
+  if (process.env.POWERLINE_NERD_FONTS === "1") return true;
+  if (process.env.POWERLINE_NERD_FONTS === "0") return false;
+  if (process.env.GHOSTTY_RESOURCES_DIR) return true;
+  // Windows Terminal — many users have Nerd Fonts installed
+  if (process.env.WT_SESSION) return true;
+  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;
+}

package/extensions/ccstyle-powerline/powerline-config.ts

@@ -0,0 +1,234 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+import type { ColorValue, CustomItemPosition, CustomStatusItem, PresetDef, StatusLinePreset, StatusLineSegmentId, StatusLineSegmentOptions } from "./types.ts";
+
+export interface PowerlineConfig {
+  preset: StatusLinePreset;
+  customItems: CustomStatusItem[];
+  segmentOptions: StatusLineSegmentOptions;
+  mouseScroll: boolean;
+  fixedEditor: boolean;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function normalizePreset(value: unknown, presets: readonly StatusLinePreset[]): StatusLinePreset | null {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  return (presets as readonly string[]).includes(normalized) ? (normalized as StatusLinePreset) : null;
+}
+
+function normalizeCustomItemId(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  if (!normalized) return null;
+  return /^[a-zA-Z0-9_-]+$/.test(normalized) ? normalized : null;
+}
+
+function normalizeCustomItemPosition(value: unknown): CustomItemPosition {
+  if (value === "left" || value === "right" || value === "secondary") return value;
+  return "right";
+}
+
+function normalizeCustomColor(value: unknown): ColorValue | undefined {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.trim();
+  return normalized ? (normalized as ColorValue) : undefined;
+}
+
+function normalizeCustomPrefix(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.trim();
+  return normalized ? normalized : undefined;
+}
+
+function normalizeCustomStatusItem(raw: unknown, idOverride?: string): CustomStatusItem | null {
+  if (!isRecord(raw)) return null;
+  const id = normalizeCustomItemId(idOverride ?? raw.id);
+  if (!id) return null;
+
+  const statusKey = typeof raw.statusKey === "string" && raw.statusKey.trim() ? raw.statusKey.trim() : id;
+
+  return {
+    id,
+    statusKey,
+    position: normalizeCustomItemPosition(raw.position),
+    color: normalizeCustomColor(raw.color),
+    prefix: normalizeCustomPrefix(raw.prefix),
+    hideWhenMissing: raw.hideWhenMissing !== false,
+    excludeFromExtensionStatuses: raw.excludeFromExtensionStatuses !== false,
+  };
+}
+
+function normalizeCustomItems(raw: unknown): CustomStatusItem[] {
+  const normalized: CustomStatusItem[] = [];
+
+  if (Array.isArray(raw)) {
+    for (const entry of raw) {
+      const item = normalizeCustomStatusItem(entry);
+      if (item) normalized.push(item);
+    }
+  } else if (isRecord(raw)) {
+    for (const [id, entry] of Object.entries(raw)) {
+      const item = normalizeCustomStatusItem(entry, id);
+      if (item) normalized.push(item);
+    }
+  }
+
+  const deduped = new Map<string, CustomStatusItem>();
+  for (const item of normalized) {
+    deduped.set(item.id, item);
+  }
+
+  return [...deduped.values()];
+}
+
+function normalizeSegmentOptions(raw: Record<string, unknown>): StatusLineSegmentOptions {
+  const options: StatusLineSegmentOptions = {};
+
+  if (isRecord(raw.model)) {
+    options.model = {
+      ...(typeof raw.model.showThinkingLevel === "boolean" ? { showThinkingLevel: raw.model.showThinkingLevel } : {}),
+    };
+  }
+
+  if (isRecord(raw.path)) {
+    options.path = {
+      ...(raw.path.mode === "basename" || raw.path.mode === "abbreviated" || raw.path.mode === "full" ? { mode: raw.path.mode } : {}),
+      ...(typeof raw.path.maxLength === "number" && Number.isFinite(raw.path.maxLength) && raw.path.maxLength > 0
+        ? { maxLength: Math.floor(raw.path.maxLength) }
+        : {}),
+    };
+  }
+
+  if (isRecord(raw.git)) {
+    options.git = {
+      ...(typeof raw.git.showBranch === "boolean" ? { showBranch: raw.git.showBranch } : {}),
+      ...(typeof raw.git.showStaged === "boolean" ? { showStaged: raw.git.showStaged } : {}),
+      ...(typeof raw.git.showUnstaged === "boolean" ? { showUnstaged: raw.git.showUnstaged } : {}),
+      ...(typeof raw.git.showUntracked === "boolean" ? { showUntracked: raw.git.showUntracked } : {}),
+      ...(raw.git.polling === "full" || raw.git.polling === "branch" || raw.git.polling === "off" ? { polling: raw.git.polling } : {}),
+    };
+  }
+
+  if (isRecord(raw.time)) {
+    options.time = {
+      ...(raw.time.format === "12h" || raw.time.format === "24h" ? { format: raw.time.format } : {}),
+      ...(typeof raw.time.showSeconds === "boolean" ? { showSeconds: raw.time.showSeconds } : {}),
+    };
+  }
+
+  return options;
+}
+
+export function mergeSegmentOptions(
+  defaults: StatusLineSegmentOptions = {},
+  overrides: StatusLineSegmentOptions = {},
+): StatusLineSegmentOptions {
+  return {
+    ...defaults,
+    ...overrides,
+    model: { ...defaults.model, ...overrides.model },
+    path: { ...defaults.path, ...overrides.path },
+    git: { ...defaults.git, ...overrides.git },
+    time: { ...defaults.time, ...overrides.time },
+  };
+}
+
+export function parsePowerlineConfig(value: unknown, presets: readonly StatusLinePreset[]): PowerlineConfig {
+  const defaultConfig: PowerlineConfig = { preset: "default", customItems: [], segmentOptions: {}, mouseScroll: true, fixedEditor: true };
+
+  const directPreset = normalizePreset(value, presets);
+  if (directPreset) return { ...defaultConfig, preset: directPreset };
+
+  if (!isRecord(value)) return defaultConfig;
+
+  return {
+    preset: normalizePreset(value.preset, presets) ?? defaultConfig.preset,
+    customItems: normalizeCustomItems(value.customItems),
+    segmentOptions: normalizeSegmentOptions(value),
+    mouseScroll: value.mouseScroll !== false,
+    fixedEditor: value.fixedEditor !== false,
+  };
+}
+
+export function mergeSegmentsWithCustomItems(presetDef: PresetDef, customItems: readonly CustomStatusItem[]): {
+  leftSegments: StatusLineSegmentId[];
+  rightSegments: StatusLineSegmentId[];
+  secondarySegments: StatusLineSegmentId[];
+} {
+  const left: StatusLineSegmentId[] = [...presetDef.leftSegments];
+  const right: StatusLineSegmentId[] = [...presetDef.rightSegments];
+  const secondary: StatusLineSegmentId[] = [...(presetDef.secondarySegments ?? [])];
+
+  for (const item of customItems) {
+    const segmentId: StatusLineSegmentId = `custom:${item.id}`;
+    if (item.position === "left") left.push(segmentId);
+    else if (item.position === "secondary") secondary.push(segmentId);
+    else right.push(segmentId);
+  }
+
+  return { leftSegments: left, rightSegments: right, secondarySegments: secondary };
+}
+
+export function nextPowerlineSettingWithPreset(existingPowerlineSetting: unknown, preset: StatusLinePreset): unknown {
+  if (!isRecord(existingPowerlineSetting)) {
+    return preset;
+  }
+  return { ...existingPowerlineSetting, preset };
+}
+
+export function nextPowerlineSettingWithOptions(
+  existingPowerlineSetting: unknown,
+  updates: Partial<Pick<PowerlineConfig, "mouseScroll" | "fixedEditor">>,
+  currentPreset: StatusLinePreset,
+): unknown {
+  if (!isRecord(existingPowerlineSetting)) {
+    return { preset: currentPreset, ...updates };
+  }
+  return { ...existingPowerlineSetting, ...updates };
+}
+
+export function collectHiddenExtensionStatusKeys(customItems: readonly CustomStatusItem[]): Set<string> {
+  const hidden = new Set<string>();
+  for (const item of customItems) {
+    if (item.excludeFromExtensionStatuses) hidden.add(item.statusKey);
+  }
+  return hidden;
+}
+
+export function isNotificationExtensionStatus(value: string): boolean {
+  return value.trimStart().startsWith("[");
+}
+
+export function getNotificationExtensionStatuses(
+  statuses: ReadonlyMap<string, string>,
+  hiddenKeys: ReadonlySet<string>,
+): string[] {
+  const notifications: string[] = [];
+  for (const [statusKey, value] of statuses.entries()) {
+    if (hiddenKeys.has(statusKey) || !value || !isNotificationExtensionStatus(value)) {
+      continue;
+    }
+    notifications.push(value);
+  }
+  return notifications;
+}
+
+export function normalizeExtensionStatusValue(value: string): string | null {
+  if (!value || visibleWidth(value) <= 0) {
+    return null;
+  }
+
+  const stripped = value.replace(/(\x1b\[[0-9;]*m|\s|·|[|])+$/, "");
+  return visibleWidth(stripped) > 0 ? stripped : null;
+}
+
+export function normalizeCompactExtensionStatus(value: string): string | null {
+  if (isNotificationExtensionStatus(value)) {
+    return null;
+  }
+
+  return normalizeExtensionStatusValue(value);
+}