pi-cc-extensions 0.1.1

package/extensions/ccstyle-powerline/shortcuts.ts

@@ -0,0 +1,57 @@
+import { matchesKey } from "@earendil-works/pi-tui";
+
+const CTRL_NAVIGATION_SHORTCUT_PATTERNS = new Map<string, RegExp>([
+  // xterm/Windows Terminal, Kitty keyboard protocol, and modifyOtherKeys.
+  ["ctrl+up", /^\x1b\[(?:1;5(?::[12])?A|57419;5(?::[12])?u|27;5;65~)$/],
+  ["ctrl+down", /^\x1b\[(?:1;5(?::[12])?B|57420;5(?::[12])?u|27;5;66~)$/],
+  ["ctrl+end", /^\x1b\[(?:1;5(?::[12])?F|4;5(?::[12])?~|57424;5(?::[12])?u|27;5;70~)$/],
+]);
+
+const SUPER_SHORTCUT_PATTERNS = new Map<string, RegExp>([
+  ["super+up", /^\x1b\[(?:1;9(?::[12])?[AH]|574(?:19|23);9(?::[12])?u|7;9(?::[12])?~|27;9;65~)$/],
+  ["super+down", /^\x1b\[(?:1;9(?::[12])?[BF]|574(?:20|24);9(?::[12])?u|8;9(?::[12])?~|27;9;66~)$/],
+  ["super+home", /^\x1b\[(?:1;9(?::[12])?H|57423;9(?::[12])?u|7;9(?::[12])?~)$/],
+  ["super+end", /^\x1b\[(?:1;9(?::[12])?F|57424;9(?::[12])?u|8;9(?::[12])?~)$/],
+  ["super+pageup", /^\x1b\[(?:5;9(?::[12])?~|57421;9(?::[12])?u)$/],
+  ["super+pagedown", /^\x1b\[(?:6;9(?::[12])?~|57422;9(?::[12])?u)$/],
+  ["super+shift+up", /^\x1b\[(?:1;10(?::[12])?[AH]|574(?:19|23);10(?::[12])?u|7;10(?::[12])?~|27;10;65~)$/],
+  ["super+shift+down", /^\x1b\[(?:1;10(?::[12])?[BF]|574(?:20|24);10(?::[12])?u|8;10(?::[12])?~|27;10;66~)$/],
+  ["super+shift+home", /^\x1b\[(?:1;10(?::[12])?H|57423;10(?::[12])?u|7;10(?::[12])?~)$/],
+  ["super+shift+end", /^\x1b\[(?:1;10(?::[12])?F|57424;10(?::[12])?u|8;10(?::[12])?~)$/],
+]);
+
+export function shortcutUsesSuper(shortcut: string): boolean {
+  const parts = shortcut.toLowerCase().split("+");
+  return parts.slice(0, -1).includes("super");
+}
+
+export function isSupportedSuperShortcut(shortcut: string): boolean {
+  return SUPER_SHORTCUT_PATTERNS.has(shortcut.toLowerCase());
+}
+
+export function shortcutConflictKey(shortcut: string): string {
+  switch (shortcut.toLowerCase()) {
+    case "super+home":
+      return "super+up";
+    case "super+end":
+      return "super+down";
+    case "super+shift+home":
+      return "super+shift+up";
+    case "super+shift+end":
+      return "super+shift+down";
+    default:
+      return shortcut;
+  }
+}
+
+export function matchesConfiguredShortcut(data: string, shortcut: string): boolean {
+  const normalizedShortcut = shortcut.toLowerCase();
+  if (shortcutUsesSuper(normalizedShortcut)) {
+    return SUPER_SHORTCUT_PATTERNS.get(normalizedShortcut)?.test(data) ?? false;
+  }
+
+  // Some Windows terminal/protocol combinations are not normalized by
+  // pi-tui's matchesKey(), so recognize raw Ctrl+navigation encodings too.
+  if (CTRL_NAVIGATION_SHORTCUT_PATTERNS.get(normalizedShortcut)?.test(data)) return true;
+  return matchesKey(data, normalizedShortcut);
+}

package/extensions/ccstyle-powerline/theme.json

@@ -0,0 +1,26 @@
+{
+  "colors": {
+    "model": "#3794FF",
+    "shellMode": "#4FC1FF",
+    "path": "#4EC9B0",
+    "gitDirty": "#F48771",
+    "gitClean": "#89D185",
+    "thinking": "#808080",
+    "thinkingMinimal": "#064675",
+    "thinkingLow": "#125489",
+    "thinkingMedium": "#1F5F99",
+    "thinkingHigh": "#3F87C5",
+    "thinkingXhigh": "#66A9DC",
+    "thinkingMax": "#8FC5F0",
+    "context": "#808080",
+    "contextWarn": "#DCDCAA",
+    "contextError": "#F14C4C",
+    "cost": "#CE9178",
+    "tokens": "#9CDCFE",
+    "separator": "#6A6A6A",
+    "border": "#3E3E42"
+  },
+  "icons": {
+    "context": ""
+  }
+}

package/extensions/ccstyle-powerline/theme.ts

@@ -0,0 +1,241 @@
+/**
+ * Theme system for powerline-footer
+ * 
+ * Colors are resolved in order:
+ * 1. User overrides from theme.json (if exists)
+ * 2. Preset colors
+ * 3. Default colors
+ */
+
+import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+import { existsSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ColorScheme, ColorValue, SemanticColor, ThemeLike } from "./types.ts";
+
+export interface PowerlineThemeConfig {
+  colors?: unknown;
+  icons?: unknown;
+}
+
+// VS Code Modern Dark-inspired fallback defaults. Native pi themes take
+// precedence for thinking-level colors when available.
+const DEFAULT_COLORS: Required<ColorScheme> = {
+  model: "#3794ff",
+  shellMode: "#4fc1ff",
+  path: "#4ec9b0",
+  gitDirty: "#f48771",
+  gitClean: "#89d185",
+  thinking: "#808080",
+  thinkingOff: "#808080",
+  thinkingMinimal: "#064675",
+  thinkingLow: "#125489",
+  thinkingMedium: "#1f5f99",
+  thinkingHigh: "#3f87c5",
+  thinkingXhigh: "#66a9dc",
+  thinkingMax: "#8fc5f0",
+  context: "#808080",
+  contextWarn: "#dcdcaa",
+  contextError: "#f14c4c",
+  cost: "#ce9178",
+  tokens: "#9cdcfe",
+  separator: "#6a6a6a",
+  border: "#3e3e42",
+};
+
+// Cache for user theme overrides
+let userThemeCache: ColorScheme | null = null;
+let userThemeCacheTime = 0;
+let themeConfigCache: PowerlineThemeConfig | null = null;
+let themeConfigCacheTime = 0;
+const CACHE_TTL = 5000; // 5 seconds
+const warnedInvalidThemeColors = new Set<string>();
+
+/** Force the next render to reload theme.json, including after Pi /reload. */
+export function invalidateThemeCache(): void {
+  userThemeCache = null;
+  userThemeCacheTime = 0;
+  themeConfigCache = null;
+  themeConfigCacheTime = 0;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function sanitizeUserThemeOverrides(value: unknown): ColorScheme {
+  if (!isRecord(value)) {
+    return {};
+  }
+
+  const sanitized: ColorScheme = {};
+  for (const [key, rawColor] of Object.entries(value)) {
+    if (!Object.prototype.hasOwnProperty.call(DEFAULT_COLORS, key)) {
+      continue;
+    }
+    if (typeof rawColor !== "string") {
+      continue;
+    }
+
+    const color = rawColor.trim();
+    if (!color) {
+      continue;
+    }
+
+    sanitized[key as SemanticColor] = color as ColorValue;
+  }
+
+  return sanitized;
+}
+
+/**
+ * Get the path to the theme.json file
+ */
+function getThemePath(): string {
+  const extDir = dirname(fileURLToPath(import.meta.url));
+  return join(extDir, "theme.json");
+}
+
+/**
+ * Load user theme config from theme.json
+ */
+export function loadThemeConfig(): PowerlineThemeConfig {
+  const now = Date.now();
+  if (themeConfigCache && now - themeConfigCacheTime < CACHE_TTL) {
+    return themeConfigCache;
+  }
+
+  const themePath = getThemePath();
+  try {
+    if (existsSync(themePath)) {
+      const content = readFileSync(themePath, "utf-8");
+      const parsed = JSON.parse(content);
+      themeConfigCache = isRecord(parsed) ? parsed : {};
+      themeConfigCacheTime = now;
+      return themeConfigCache;
+    }
+  } catch (error) {
+    // Theme overrides are optional. If the file is unreadable or malformed,
+    // keep rendering with built-in defaults instead of breaking the footer.
+    console.debug(`[powerline-theme] Failed to load ${themePath}:`, error);
+  }
+
+  themeConfigCache = {};
+  themeConfigCacheTime = now;
+  return themeConfigCache;
+}
+
+function loadUserTheme(): ColorScheme {
+  const now = Date.now();
+  if (userThemeCache && now - userThemeCacheTime < CACHE_TTL) {
+    return userThemeCache;
+  }
+
+  userThemeCache = sanitizeUserThemeOverrides(loadThemeConfig().colors);
+  userThemeCacheTime = now;
+  return userThemeCache;
+}
+
+/**
+ * Resolve a semantic color to an actual color value
+ */
+export function resolveColor(
+  semantic: SemanticColor,
+  presetColors?: ColorScheme
+): ColorValue {
+  const userTheme = loadUserTheme();
+  
+  // Priority: user overrides > preset colors > defaults
+  return userTheme[semantic] 
+    ?? presetColors?.[semantic] 
+    ?? DEFAULT_COLORS[semantic];
+}
+
+/**
+ * Check if a color value is a hex color
+ */
+function isHexColor(color: ColorValue): color is `#${string}` {
+  return typeof color === "string" && /^#[0-9a-fA-F]{6}$/.test(color);
+}
+
+/**
+ * Convert hex color to ANSI escape code
+ */
+function hexToAnsi(hex: string): string {
+  const h = hex.replace("#", "");
+  const r = parseInt(h.slice(0, 2), 16);
+  const g = parseInt(h.slice(2, 4), 16);
+  const b = parseInt(h.slice(4, 6), 16);
+  return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+/**
+ * Apply a color to text using the pi theme or custom hex
+ */
+export function applyColor(
+  theme: ThemeLike,
+  color: ColorValue,
+  text: string
+): string {
+  if (isHexColor(color)) {
+    return `${hexToAnsi(color)}${text}\x1b[0m`;
+  }
+
+  try {
+    return theme.fg(color as ThemeColor, text);
+  } catch (error) {
+    const key = String(color);
+    if (!warnedInvalidThemeColors.has(key)) {
+      warnedInvalidThemeColors.add(key);
+      if (warnedInvalidThemeColors.size > 200) {
+        warnedInvalidThemeColors.clear();
+      }
+      console.debug(`[powerline-theme] Invalid theme color "${key}"; falling back to "text".`, error);
+    }
+    return theme.fg("text", text);
+  }
+}
+
+/**
+ * Apply a semantic color to text
+ */
+export function fg(
+  theme: ThemeLike,
+  semantic: SemanticColor,
+  text: string,
+  presetColors?: ColorScheme
+): string {
+  const color = resolveColor(semantic, presetColors);
+  return applyColor(theme, color, text);
+}
+
+const THINKING_SEMANTIC_COLORS: Record<string, SemanticColor> = {
+  off: "thinkingOff",
+  minimal: "thinkingMinimal",
+  low: "thinkingLow",
+  medium: "thinkingMedium",
+  high: "thinkingHigh",
+  xhigh: "thinkingXhigh",
+  max: "thinkingMax",
+};
+
+/**
+ * Apply the extension's monotonic blue scale so stronger thinking levels
+ * become brighter and more prominent without switching to unrelated hues.
+ */
+export function colorThinking(
+  theme: ThemeLike,
+  level: string,
+  text: string,
+  presetColors?: ColorScheme,
+): string {
+  const semantic = THINKING_SEMANTIC_COLORS[level] ?? "thinkingOff";
+  return fg(theme, semantic, text, presetColors);
+}
+
+/**
+ * Get the default color scheme
+ */
+export function getDefaultColors(): Required<ColorScheme> {
+  return { ...DEFAULT_COLORS };
+}

package/extensions/ccstyle-powerline/types.ts

@@ -0,0 +1,197 @@
+import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+
+// Theme color - either a pi theme color name or a custom hex color
+export type ColorValue = ThemeColor | `#${string}`;
+export type ThemeLike = Pick<Theme, "fg">;
+
+// Semantic color names for segments
+export type SemanticColor =
+  | "model"
+  | "shellMode"
+  | "path"
+  | "gitDirty"
+  | "gitClean"
+  | "thinking"
+  | "thinkingOff"
+  | "thinkingMinimal"
+  | "thinkingLow"
+  | "thinkingMedium"
+  | "thinkingHigh"
+  | "thinkingXhigh"
+  | "thinkingMax"
+  | "context"
+  | "contextWarn"
+  | "contextError"
+  | "cost"
+  | "tokens"
+  | "separator"
+  | "border";
+
+// Color scheme mapping semantic names to actual colors
+export type ColorScheme = Partial<Record<SemanticColor, ColorValue>>;
+
+// Built-in segment identifiers
+export type BuiltinStatusLineSegmentId =
+  | "model"
+  | "shell_mode"
+  | "path"
+  | "git"
+  | "subagents"
+  | "token_in"
+  | "token_out"
+  | "token_total"
+  | "cost"
+  | "context_pct"
+  | "context_total"
+  | "time_spent"
+  | "time"
+  | "session"
+  | "hostname"
+  | "cache_read"
+  | "cache_write"
+  | "thinking"
+  | "extension_statuses";
+
+// Segment identifiers (built-in + dynamically registered custom items)
+export type StatusLineSegmentId = BuiltinStatusLineSegmentId | `custom:${string}`;
+
+// Separator styles
+export type StatusLineSeparatorStyle =
+  | "powerline"
+  | "powerline-thin"
+  | "slash"
+  | "pipe"
+  | "block"
+  | "none"
+  | "ascii"
+  | "dot"
+  | "chevron"
+  | "star";
+
+// Preset names
+export type StatusLinePreset =
+  | "default"
+  | "minimal"
+  | "compact"
+  | "full"
+  | "nerd"
+  | "ascii"
+  | "custom";
+
+// Per-segment options
+export interface StatusLineSegmentOptions {
+  model?: { showThinkingLevel?: boolean };
+  path?: { 
+    mode?: "basename" | "abbreviated" | "full";
+    maxLength?: number;
+  };
+  git?: {
+    showBranch?: boolean;
+    showStaged?: boolean;
+    showUnstaged?: boolean;
+    showUntracked?: boolean;
+    polling?: "full" | "branch" | "off";
+  };
+  time?: { format?: "12h" | "24h"; showSeconds?: boolean };
+}
+
+export type CustomItemPosition = "left" | "right" | "secondary";
+
+export interface CustomStatusItem {
+  id: string;
+  statusKey: string;
+  position: CustomItemPosition;
+  color?: ColorValue;
+  prefix?: string;
+  hideWhenMissing: boolean;
+  excludeFromExtensionStatuses: boolean;
+}
+
+// Preset definition
+export interface PresetDef {
+  leftSegments: BuiltinStatusLineSegmentId[];
+  rightSegments: BuiltinStatusLineSegmentId[];
+  /** Secondary row segments (shown in footer, above sub bar) */
+  secondarySegments?: BuiltinStatusLineSegmentId[];
+  separator: StatusLineSeparatorStyle;
+  segmentOptions?: StatusLineSegmentOptions;
+  /** Color scheme for this preset */
+  colors?: ColorScheme;
+}
+
+// Separator definition
+export interface SeparatorDef {
+  left: string;
+  right: string;
+  endCaps?: {
+    left: string;
+    right: string;
+    useBgAsFg: boolean;
+  };
+}
+
+// Git status data
+export interface GitStatus {
+  branch: string | null;
+  staged: number;
+  unstaged: number;
+  untracked: number;
+}
+
+// Usage statistics
+export interface UsageStats {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  cost: number;
+}
+
+// Context passed to segment render functions
+export interface SegmentContext {
+  // From pi-mono
+  model: { id: string; name?: string; reasoning?: boolean; contextWindow?: number } | undefined;
+  thinkingLevel: string;
+  sessionId: string | undefined;
+  cwd?: string;
+  
+  // Computed
+  usageStats: UsageStats;
+  contextPercent: number | null;
+  contextWindow: number;
+  autoCompactEnabled: boolean;
+  customCompactionEnabled: boolean;
+  usingSubscription: boolean;
+  sessionStartTime: number;
+  shellModeActive: boolean;
+  shellRunning: boolean;
+  shellName: string | null;
+  shellCwd: string | null;
+  
+  // Git
+  git: GitStatus;
+  
+  // Extension statuses
+  extensionStatuses: ReadonlyMap<string, string>;
+  hiddenExtensionStatusKeys: ReadonlySet<string>;
+  customItemsById: ReadonlyMap<string, CustomStatusItem>;
+  
+  // Options
+  options: StatusLineSegmentOptions;
+  
+  // Theming
+  theme: ThemeLike;
+  colors: ColorScheme;
+}
+
+// Rendered segment output
+export interface RenderedSegment {
+  content: string;
+  visible: boolean;
+}
+
+// Segment definition
+export interface StatusLineSegment {
+  id: BuiltinStatusLineSegmentId;
+  render(ctx: SegmentContext): RenderedSegment;
+}

package/extensions/ccstyle-powerline/welcome-dismiss.ts

@@ -0,0 +1,34 @@
+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 timer: ReturnType<typeof setTimeout> | null = null;
+
+  return {
+    schedule(ctx) {
+      if (timer) return;
+
+      const generation = options.getGeneration();
+      timer = setTimeout(() => {
+        timer = null;
+        if (!options.isEnabled() || generation !== options.getGeneration()) return;
+        options.dismiss(ctx);
+      }, 0);
+    },
+    cancel() {
+      if (!timer) return;
+      clearTimeout(timer);
+      timer = null;
+    },
+  };
+}