pi-editor-footer 0.1.0

package/src/header.ts

@@ -0,0 +1,185 @@
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+// Keep helpers local to avoid conflict with footer track which owns shared src/utils.ts.
+// Copied from tmp/pi-open-tui/extensions/open-tui/utils.ts (MIT).
+
+export type WorkspaceDisplay = "path" | "name";
+
+export interface HeaderThemeLike {
+  fg(style: string, s: string): string;
+}
+
+export interface HeaderDeps {
+  cwd: string;
+  workspaceDisplay: WorkspaceDisplay;
+  tipCommands: string[];
+  /** Cwd glyph; defaults to "@" (ascii) if not provided. Footer owns full icons.ts. */
+  iconCwd?: string;
+}
+
+export function formatCwd(cwd: string): string {
+  const home = process.env.HOME || process.env.USERPROFILE;
+  if (!home) return cwd;
+  const resolvedCwd = resolve(cwd);
+  const resolvedHome = resolve(home);
+  const rel = relative(resolvedHome, resolvedCwd);
+  const insideHome =
+    rel === "" ||
+    (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+  if (!insideHome) return cwd;
+  return rel === "" ? "~" : `~${sep}${rel}`;
+}
+
+export function basenamePath(path: string): string {
+  return path.split(/[\\/]/).filter(Boolean).at(-1) ?? path;
+}
+
+export function truncatePath(path: string, maxLen: number): string {
+  if (path.length <= maxLen) return path;
+  if (maxLen <= 3) return "...".slice(0, maxLen);
+  const sepChar = path.includes("/") ? "/" : "\\";
+  const parts = path.split(/[\\/]/);
+  if (parts.length <= 2) return path.slice(0, maxLen - 3) + "...";
+  const tail: string[] = [];
+  let tailLen = 0;
+  for (let i = parts.length - 1; i >= 1; i--) {
+    const seg = parts[i]!;
+    if (tailLen + seg.length + 4 > maxLen) break;
+    tail.unshift(seg);
+    tailLen += seg.length + 1;
+  }
+  const head = parts[0]!;
+  const result = `${head}${sepChar}...${sepChar}${tail.join(sepChar)}`;
+  return result.length > maxLen ? result.slice(0, maxLen - 3) + "..." : result;
+}
+
+function displayCwd(rawCwd: string, _mode: WorkspaceDisplay): string {
+  return formatCwd(rawCwd);
+}
+
+// Keep layout logic local; footer owns the full headerColumnWidths.
+// Simple: at narrow widths, tips are dropped.
+const GAP = 3;
+
+export function renderHeader(
+  width: number,
+  deps: HeaderDeps,
+  theme: HeaderThemeLike,
+): string[] {
+  if (width <= 0) return [];
+  if (!deps.cwd) return [];
+
+  const icon = deps.iconCwd ?? "@";
+  const cwdText = displayCwd(deps.cwd, deps.workspaceDisplay);
+  // Single-line content: "icon cwd  |  tip0  tip1  tip2"
+  const tips = (deps.tipCommands ?? [])
+    .slice(0, 3)
+    .map((t) => (t.startsWith("/") ? t : `/${t}`));
+  const tipsText =
+    tips.length > 0 ? tips.map((t) => theme.fg("dim", t)).join("  ") : "";
+
+  // At very narrow widths, just show cwd with icon, truncated.
+  if (width < 24 || tipsText === "") {
+    const raw = `${icon} ${cwdText}`;
+    const truncated = truncateToWidth(raw, width, theme.fg("dim", "..."));
+    return [truncated];
+  }
+
+  const tipsW = visibleWidth(tipsText);
+  const gapW = GAP;
+  // Reserve for tips; if not enough room, drop tips.
+  if (tipsW + gapW + 10 > width) {
+    const raw = `${icon} ${cwdText}`;
+    return [truncateToWidth(raw, width, theme.fg("dim", "..."))];
+  }
+
+  // Allocate widths
+  const maxTipsW = Math.min(28, tipsW);
+  const leftW = width - gapW - maxTipsW;
+  const cwdIconText = `${icon} ${cwdText}`;
+  const leftText = truncatePath(cwdIconText, leftW);
+  // Pad left to leftW, then gap, then tips (right-aligned within maxTipsW)
+  // For simplicity, left + gap + tipsText (tips already themed dim)
+  // Use visibleWidth for padding.
+  const leftVisible = visibleWidth(leftText);
+  const pad = Math.max(gapW, width - leftVisible - tipsW);
+  const line = leftText + " ".repeat(pad) + tipsText;
+  return [truncateToWidth(line, width, theme.fg("dim", "..."))];
+}
+
+// Minimal widget installer — keeps header always on when enabled.
+// Does not depend on full config; caller provides getters so tests stay pure.
+
+export type GetHeaderConfig = () => {
+  enabled: boolean;
+  workspaceDisplay: WorkspaceDisplay;
+};
+export type GetCwd = () => string;
+export type GetTips = () => string[];
+
+export function installHeader(
+  ctx: {
+    ui: {
+      setWidget(
+        key: string,
+        content: unknown,
+        options?: { placement?: string },
+      ): void;
+    };
+    mode?: string;
+  },
+  getConfig: GetHeaderConfig,
+  getCwd: GetCwd,
+  getTips: GetTips,
+): () => void {
+  const key = "theme-header";
+
+  // Avoid touching UI when not in TUI.
+  const mode = (ctx as { mode?: string }).mode;
+  if (mode && mode !== "tui") {
+    return () => {};
+  }
+
+  // Create a TUI component that renders the header at current width.
+  const factory = (_tui: unknown, theme: unknown) => {
+    const th = theme as HeaderThemeLike;
+    return {
+      invalidate(): void {},
+      render(width: number): string[] {
+        const cfg = getConfig();
+        if (!cfg.enabled) return [];
+        return renderHeader(
+          width,
+          {
+            cwd: getCwd(),
+            workspaceDisplay: cfg.workspaceDisplay,
+            tipCommands: getTips(),
+          },
+          th,
+        );
+      },
+      dispose(): void {},
+    };
+  };
+
+  // Adapter: ExtensionUIContextLike.setWidget expects (key, content, options)
+  // where content can be string[] or factory (tui, theme) => Component.
+  const ui = ctx.ui as unknown as {
+    setWidget: (
+      key: string,
+      content:
+        | ((
+            tui: unknown,
+            theme: unknown,
+          ) => { render(width: number): string[] })
+        | undefined,
+      options?: { placement?: string },
+    ) => void;
+  };
+  ui.setWidget(key, factory as unknown as never, { placement: "aboveEditor" });
+
+  return () => {
+    ui.setWidget(key, undefined);
+  };
+}

package/src/icons.ts

@@ -0,0 +1,197 @@
+export type IconMode = "auto" | "nerd" | "ascii";
+
+export interface IconGlyphs {
+  cwd: string;
+  session: string;
+  git: string;
+  working: string;
+  done: string;
+  context: string;
+  model: string;
+  thinking: string;
+  input: string;
+  output: string;
+  cacheHit: string;
+  cost: string;
+  speed: string;
+  latency: string;
+  stall: string;
+  extensions: string;
+  ahead: string;
+  behind: string;
+  diverged: string;
+  conflicted: string;
+  stashed: string;
+  modified: string;
+  staged: string;
+  untracked: string;
+  renamed: string;
+  deleted: string;
+}
+
+const NERD_GLYPHS: IconGlyphs = {
+  cwd: "",
+  session: "",
+  git: "",
+  working: "",
+  done: "",
+  context: "",
+  model: "",
+  thinking: "",
+  input: "",
+  output: "",
+  cacheHit: "",
+  cost: "",
+  speed: "󰓅",
+  latency: "",
+  stall: "",
+  extensions: "",
+  ahead: "↑",
+  behind: "↓",
+  diverged: "⇕",
+  conflicted: "=",
+  stashed: "$",
+  modified: "!",
+  staged: "+",
+  untracked: "?",
+  renamed: "»",
+  deleted: "✘",
+};
+
+const ASCII_GLYPHS: IconGlyphs = {
+  cwd: "@",
+  session: "s",
+  git: "*",
+  working: "o",
+  done: "+",
+  context: "#",
+  model: "M",
+  thinking: "~",
+  input: "↑",
+  output: "↓",
+  cacheHit: "c",
+  cost: "$",
+  speed: ">",
+  latency: "~",
+  stall: "!",
+  extensions: "&",
+  ahead: "^",
+  behind: "v",
+  diverged: "^v",
+  conflicted: "=",
+  stashed: "S",
+  modified: "!",
+  staged: "A",
+  untracked: "?",
+  renamed: "r",
+  deleted: "x",
+};
+
+const NERD_FONT_TERMINALS = new Set([
+  "iTerm.app",
+  "Ghostty",
+  "WezTerm",
+  "kitty",
+  "rio",
+  "tabby",
+  "WindowsTerminal",
+  "vscode",
+]);
+
+export function detectNerdFont(): boolean {
+  const termProgram = process.env.TERM_PROGRAM;
+  if (termProgram && NERD_FONT_TERMINALS.has(termProgram)) return true;
+  const lcTerminal = process.env.LC_TERMINAL;
+  if (lcTerminal && NERD_FONT_TERMINALS.has(lcTerminal)) return true;
+  if (process.env.TERM === "xterm-kitty") return true;
+  if (process.env.WT_SESSION) return true;
+  if (process.env.TERM_PROGRAM === "vscode") return true;
+  return false;
+}
+
+export function resolveIconMode(mode: IconMode): "nerd" | "ascii" {
+  if (mode === "nerd") return "nerd";
+  if (mode === "ascii") return "ascii";
+  return detectNerdFont() ? "nerd" : "ascii";
+}
+
+export function resolveGlyphs(mode: IconMode): IconGlyphs {
+  const resolved = resolveIconMode(mode);
+  return resolved === "nerd" ? NERD_GLYPHS : ASCII_GLYPHS;
+}
+
+const RUNTIME_SYMBOLS: Record<string, string> = {
+  nodejs: "\uE718",
+  rust: "\uE7A8",
+  go: "\uE626",
+  python: "\uE73C",
+  ruby: "\uE739",
+  java: "\uE256",
+  cpp: "\uE61D",
+  c: "\uE61E",
+  swift: "\uE755",
+  kotlin: "\uE634",
+  deno: "\uE7FB",
+  bun: "\uE6FB",
+  php: "\uE73D",
+  haskell: "\uE777",
+  julia: "\uE624",
+  lua: "\uE620",
+  elixir: "\uE62B",
+  erlang: "\uE7B1",
+  gleam: "\uE6B4",
+  crystal: "\uE62F",
+  dart: "\uE7C0",
+  nim: "\uE677",
+  zig: "\uE6A9",
+  ocaml: "\uE67A",
+  clojure: "\uE76A",
+  scala: "\uE747",
+  perl: "\uE769",
+  r: "\uE68A",
+  elm: "\uE62C",
+  haxe: "\uE7B7",
+  vagrant: "\uE21A",
+  terraform: "\uE1A5",
+};
+
+const RUNTIME_ASCII_SYMBOLS: Record<string, string> = {
+  nodejs: "node",
+  rust: "rs",
+  go: "go",
+  python: "py",
+  ruby: "rb",
+  java: "java",
+  swift: "swift",
+  kotlin: "kt",
+  cpp: "c++",
+  c: "c",
+  deno: "deno",
+  bun: "bun",
+  php: "php",
+  haskell: "hs",
+  julia: "jl",
+  lua: "lua",
+  elixir: "ex",
+  erlang: "erl",
+  gleam: "gleam",
+  crystal: "cr",
+  dart: "dart",
+  nim: "nim",
+  zig: "zig",
+  ocaml: "ml",
+  clojure: "clj",
+  scala: "scala",
+  perl: "pl",
+  r: "R",
+  elm: "elm",
+  haxe: "hx",
+  vagrant: "vag",
+  terraform: "tf",
+};
+
+export function runtimeSymbol(name: string, mode: IconMode): string {
+  if (resolveIconMode(mode) === "ascii")
+    return RUNTIME_ASCII_SYMBOLS[name] ?? name;
+  return RUNTIME_SYMBOLS[name] ?? "";
+}