pi-editor-footer 0.1.0

package/src/utils.ts

@@ -0,0 +1,388 @@
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import {
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+
+export { truncateToWidth, visibleWidth, wrapTextWithAnsi };
+
+export type ThemeColor = string;
+export type ThinkingLevel = string;
+
+export interface Theme {
+  fg(style: string, s: string): string;
+}
+
+export function stripAnsi(text: string): string {
+  return text
+    .replace(/\x1b\[[0-9;]*m/g, "")
+    .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
+    .replace(/\x1b_[^\x07]*\x07/g, "");
+}
+
+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 truncateBranch(branch: string, maxLen: number): string {
+  if (branch.length <= maxLen) return branch;
+  if (maxLen <= 3) return "...".slice(0, maxLen);
+  return `${branch.slice(0, maxLen - 3)}...`;
+}
+
+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;
+}
+
+export function fmtTokens(n: number): string {
+  if (n < 1000) return n.toString();
+  if (n < 10_000) return `${(n / 1000).toFixed(1)}k`;
+  if (n < 1_000_000) return `${Math.round(n / 1000)}k`;
+  if (n < 10_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  return `${Math.round(n / 1_000_000)}M`;
+}
+
+export function formatDuration(ms: number): string {
+  const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const s = totalSeconds % 60;
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  if (totalMinutes < 60) return `${totalMinutes}m ${s}s`;
+  const m = totalMinutes % 60;
+  const h = Math.floor(totalMinutes / 60);
+  return `${h}h ${m}m ${s}s`;
+}
+
+export function formatModelLabel(
+  model: { provider?: string; id?: string } | null | undefined,
+): string {
+  if (!model?.id) return "no-model";
+  return model.provider ? `${model.provider}/${model.id}` : model.id;
+}
+
+export function formatProviderLabel(provider: string | undefined): string {
+  if (!provider) return "Unknown";
+  return provider.charAt(0).toUpperCase() + provider.slice(1);
+}
+
+export function alignRight(
+  left: string,
+  right: string,
+  width: number,
+  theme: Theme,
+): string {
+  const rightW = visibleWidth(right);
+  if (rightW > width) {
+    right = truncateToWidth(right, width, theme.fg("dim", "..."));
+  }
+  const leftW = visibleWidth(left);
+  const rightW2 = visibleWidth(right);
+  const pad = width - leftW - rightW2;
+  if (pad >= 1) {
+    return left + " ".repeat(pad) + right;
+  }
+  const availableForLeft = Math.max(0, width - rightW2 - 1);
+  const truncatedLeft =
+    availableForLeft > 0
+      ? truncateToWidth(left, availableForLeft, theme.fg("dim", "..."))
+      : "";
+  return truncatedLeft ? truncatedLeft + " " + right : right;
+}
+
+export type PrioritizedSegment = {
+  text: string;
+  priority: number;
+  compactText?: string;
+  truncate?: (text: string, maxWidth: number, ellipsis: string) => string;
+};
+
+export function fitSegmentsByPriority(
+  segs: readonly PrioritizedSegment[],
+  maxW: number,
+  ellipsis = "...",
+): string[] {
+  const items = segs.map((s) => ({
+    text: s.text,
+    compactText: s.compactText,
+    priority: s.priority,
+    truncate: s.truncate,
+    w: visibleWidth(s.text),
+  }));
+  const totalW = () => {
+    const active = items.filter((it) => it.text !== "");
+    return (
+      active.reduce((a, it) => a + it.w, 0) + Math.max(0, active.length - 1)
+    );
+  };
+  if (totalW() > maxW) {
+    for (const item of items) {
+      if (!item.compactText || visibleWidth(item.compactText) >= item.w)
+        continue;
+      item.text = item.compactText;
+      item.w = visibleWidth(item.text);
+      if (totalW() <= maxW) break;
+    }
+  }
+  while (totalW() > maxW) {
+    let target = -1;
+    for (let i = 0; i < items.length; i++) {
+      if (
+        items[i]!.text !== "" &&
+        (target === -1 || items[i]!.priority < items[target]!.priority)
+      ) {
+        target = i;
+      }
+    }
+    if (target === -1) break;
+    const others = items.filter(
+      (_, i) => i !== target && items[i]!.text !== "",
+    );
+    const otherW =
+      others.reduce((a, it) => a + it.w, 0) + Math.max(0, others.length - 1);
+    const avail = maxW - otherW - (others.length > 0 ? 1 : 0);
+    if (avail <= visibleWidth(ellipsis)) {
+      items[target]!.text = "";
+      items[target]!.w = 0;
+    } else if (avail < items[target]!.w) {
+      const truncate = items[target]!.truncate;
+      items[target]!.text = truncate
+        ? truncate(items[target]!.text, avail, ellipsis)
+        : truncateToWidth(items[target]!.text, avail, ellipsis);
+      items[target]!.w = visibleWidth(items[target]!.text);
+    } else {
+      break;
+    }
+  }
+  return items.filter((it) => it.text !== "").map((it) => it.text);
+}
+
+export function stressColor(value: number, warn = 70, danger = 90): ThemeColor {
+  if (value >= danger) return "error";
+  if (value >= warn) return "warning";
+  return "accent";
+}
+
+export function cacheHitColor(value: number): ThemeColor {
+  if (value < 30) return "error";
+  if (value < 70) return "warning";
+  return "success";
+}
+
+export function providerColor(provider: string): ThemeColor {
+  switch (provider.toLowerCase()) {
+    case "anthropic":
+      return "accent";
+    case "openai":
+    case "openai-codex":
+      return "success";
+    case "google":
+    case "google-vertex":
+      return "warning";
+    case "amazon-bedrock":
+      return "thinkingHigh";
+    case "github-copilot":
+      return "mdLink";
+    case "deepseek":
+      return "thinkingLow";
+    case "xai":
+    case "groq":
+      return "error";
+    default:
+      return "muted";
+  }
+}
+
+export function effortColor(
+  level: ThinkingLevel | string | undefined,
+): ThemeColor {
+  switch (level) {
+    case "minimal":
+      return "thinkingMinimal";
+    case "low":
+      return "thinkingLow";
+    case "medium":
+      return "thinkingMedium";
+    case "high":
+      return "thinkingHigh";
+    case "xhigh":
+      return "thinkingXhigh";
+    default:
+      return "thinkingMedium";
+  }
+}
+
+export function isEditorBorderLine(line: string): boolean {
+  const plain = stripAnsi(line);
+  if (/^─+$/.test(plain)) return true;
+  if (/^─*\s*[↑↓]\s+\d+\s+more\s*─*$/.test(plain)) return true;
+  return false;
+}
+
+export function findBottomBorderIndex(lines: string[]): number {
+  for (let i = lines.length - 1; i >= 1; i--) {
+    if (isEditorBorderLine(lines[i]!)) return i;
+  }
+  return Math.max(0, lines.length - 1);
+}
+
+export function padRight(text: string, width: number, ellipsis = ""): string {
+  const clipped = truncateToWidth(text, width, ellipsis);
+  return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
+}
+
+export function center(text: string, width: number): string {
+  if (width <= 0) return "";
+  const w = visibleWidth(text);
+  if (w >= width) return truncateToWidth(text, width, "...");
+  return `${" ".repeat(Math.floor((width - w) / 2))}${text}`;
+}
+
+export function sanitizeStatus(text: string): string {
+  return stripAnsi(text)
+    .replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
+    .replace(/ +/g, " ")
+    .trim();
+}
+
+export function formatThinkingLabel(level: string): string {
+  if (level === "off") return "thinking off";
+  return `${level} effort`;
+}
+
+export const PI_BUILTIN_SLASH_COMMAND_NAMES = [
+  "settings",
+  "model",
+  "scoped-models",
+  "export",
+  "import",
+  "share",
+  "copy",
+  "name",
+  "session",
+  "changelog",
+  "hotkeys",
+  "fork",
+  "clone",
+  "tree",
+  "trust",
+  "login",
+  "logout",
+  "new",
+  "compact",
+  "resume",
+  "reload",
+  "quit",
+] as const;
+
+export function collectPiCommandNames(
+  sessionCommands: readonly { name: string }[],
+): string[] {
+  const names = new Set<string>(PI_BUILTIN_SLASH_COMMAND_NAMES);
+  for (const command of sessionCommands) {
+    if (command.name) names.add(command.name);
+  }
+  return [...names];
+}
+
+export function pickSlashCommandTips(
+  availableNames: readonly string[],
+  options: {
+    fixed?: readonly string[];
+    count?: number;
+    exclude?: readonly string[];
+    random?: () => number;
+  } = {},
+): string[] {
+  const fixed = [...(options.fixed ?? [])];
+  const count = options.count ?? 3;
+  const exclude = new Set<string>([...(options.exclude ?? []), ...fixed]);
+  const random = options.random ?? Math.random;
+
+  const pool = [
+    ...new Set(availableNames.map((n) => n.trim()).filter(Boolean)),
+  ].filter((name) => !exclude.has(name));
+
+  for (let i = pool.length - 1; i > 0; i--) {
+    const j = Math.floor(random() * (i + 1));
+    const tmp = pool[i]!;
+    pool[i] = pool[j]!;
+    pool[j] = tmp;
+  }
+
+  const picked = pool.slice(0, Math.max(0, count));
+  return [...fixed, ...picked].map((name) =>
+    name.startsWith("/") ? name : `/${name}`,
+  );
+}
+
+export const MIN_LEFT_WIDTH = 28;
+export const MIN_TIPS_WIDTH = 16;
+export const MAX_TIPS_WIDTH = 28;
+const COLUMN_GAP = 3;
+
+export function headerColumnWidths(
+  innerWidth: number,
+  minTipsWidth = MIN_TIPS_WIDTH,
+  maxTipsWidth = MAX_TIPS_WIDTH,
+  minLeftWidth = MIN_LEFT_WIDTH,
+): { leftWidth: number; rightWidth: number; useTips: boolean } {
+  if (innerWidth <= 0) {
+    return { leftWidth: 0, rightWidth: 0, useTips: false };
+  }
+
+  const gap = COLUMN_GAP;
+  if (innerWidth < minLeftWidth + gap + minTipsWidth) {
+    return { leftWidth: innerWidth, rightWidth: 0, useTips: false };
+  }
+
+  let rightWidth = Math.min(
+    maxTipsWidth,
+    Math.max(minTipsWidth, Math.round(innerWidth * 0.28)),
+  );
+  let leftWidth = innerWidth - gap - rightWidth;
+
+  if (leftWidth < minLeftWidth) {
+    leftWidth = minLeftWidth;
+    rightWidth = innerWidth - gap - leftWidth;
+  }
+
+  if (leftWidth <= rightWidth) {
+    leftWidth = Math.ceil((innerWidth - gap) * 0.65);
+    rightWidth = innerWidth - gap - leftWidth;
+  }
+
+  if (rightWidth < minTipsWidth || leftWidth < minLeftWidth) {
+    return { leftWidth: innerWidth, rightWidth: 0, useTips: false };
+  }
+
+  return { leftWidth, rightWidth, useTips: true };
+}

package/src/window-presentation.ts

@@ -0,0 +1,56 @@
+/**
+ * Bordered presentation of the detail window.
+ *
+ * Pure module: takes `renderDetail`'s `[header, ...description]` lines and a
+ * theme-like styler, and returns the bordered, styled box:
+ *
+ *   ┌──────────────────────────────┐
+ *   │ name · kind                  │   ← header, theme highlight (accent+bold)
+ *   │ description line 1           │   ← description, theme dim
+ *   │ description line 2           │
+ *   └──────────────────────────────┘
+ *
+ * Input `lines` must already be wrapped to (width - 4) columns (renderDetail's
+ * wrap width); this module adds the two border columns and two border rows.
+ */
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+/** Styling functions injected from the live theme. */
+export interface WindowThemeLike {
+	/** Border color function (theme "border"). */
+	border(s: string): string;
+	/** Header style — the theme's highlight (accent + bold). */
+	highlight(s: string): string;
+	/** Description style — the theme's dim. */
+	dim(s: string): string;
+}
+
+/**
+ * Wrap `[header, ...body]` in a bordered box. Returns `[]` for empty input
+ * (window hidden). Row layout: one `┌─…─┐` border row, the highlighted header
+ * row, the dim body rows, and a `└─…─┘` border row. Every row is exactly
+ * `width` columns (ANSI-aware padding).
+ */
+export function decorateWindow(
+	lines: string[],
+	width: number,
+	theme: WindowThemeLike,
+): string[] {
+	if (lines.length === 0) {
+		return [];
+	}
+	const innerWidth = Math.max(1, width - 4);
+	const padTo = (s: string): string =>
+		s + " ".repeat(Math.max(0, innerWidth - visibleWidth(s)));
+
+	const header = lines[0] ?? "";
+	const body = lines.slice(1);
+
+	const borderRun = theme.border("─".repeat(Math.max(0, width - 2)));
+	return [
+		`┌${borderRun}┐`,
+		`│ ${padTo(theme.highlight(header))} │`,
+		...body.map((line) => `│ ${padTo(theme.dim(line))} │`),
+		`└${borderRun}┘`,
+	];
+}

package/test/config.test.ts

@@ -0,0 +1,146 @@
+import assert from "node:assert/strict";
+import { describe, test, beforeEach, afterEach } from "node:test";
+import { mkdtempSync, rmSync, existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { DEFAULT_CONFIG, getConfigPath, loadConfig, saveConfig } from "../src/config.js";
+import { formatCwd, basenamePath, truncatePath, displayCwd } from "../src/utils-workspace.js";
+
+describe("DEFAULT_CONFIG", () => {
+  test("has expected defaults", () => {
+    assert.equal(DEFAULT_CONFIG.enabled, true);
+    assert.equal(DEFAULT_CONFIG.workspaceDisplay, "path");
+    assert.equal(DEFAULT_CONFIG.cursorStyle, "block");
+    assert.equal(DEFAULT_CONFIG.icons.mode, "auto");
+    assert.equal(DEFAULT_CONFIG.telemetry.enabled, true);
+    assert.equal(DEFAULT_CONFIG.footerSegments.cwd, true);
+  });
+});
+
+describe("getConfigPath", () => {
+  test("returns homedir based path", () => {
+    const p = getConfigPath();
+    assert.ok(p.endsWith(".pi/agent/pi-skill-desc.json"), p);
+  });
+});
+
+describe("loadConfig / saveConfig with temp HOME", () => {
+  let origHome: string | undefined;
+  let origUserProfile: string | undefined;
+  let tmpHome: string;
+
+  beforeEach(() => {
+    origHome = process.env.HOME;
+    origUserProfile = process.env.USERPROFILE;
+    tmpHome = mkdtempSync(join(tmpdir(), "pi-skill-desc-test-"));
+    process.env.HOME = tmpHome;
+    process.env.USERPROFILE = tmpHome;
+  });
+
+  afterEach(() => {
+    if (origHome === undefined) delete process.env.HOME;
+    else process.env.HOME = origHome;
+    if (origUserProfile === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = origUserProfile;
+    try { rmSync(tmpHome, { recursive: true, force: true }); } catch {}
+  });
+
+  test("loadConfig returns defaults when no file exists", () => {
+    const cfg = loadConfig();
+    assert.deepEqual(cfg, DEFAULT_CONFIG);
+  });
+
+  test("saveConfig merges and persists", () => {
+    const saved = saveConfig({ workspaceDisplay: "name" } as any);
+    assert.equal(saved.workspaceDisplay, "name");
+    // reload should persist
+    const reloaded = loadConfig();
+    assert.equal(reloaded.workspaceDisplay, "name");
+    assert.equal(reloaded.cursorStyle, DEFAULT_CONFIG.cursorStyle);
+  });
+
+  test("malformed JSON falls back to defaults with warning", () => {
+    const cfgPath = getConfigPath();
+    mkdirSync(join(cfgPath, ".."), { recursive: true });
+    writeFileSync(cfgPath, "{ not valid json", "utf8");
+    const cfg = loadConfig();
+    assert.deepEqual(cfg, DEFAULT_CONFIG);
+  });
+
+  test("invalid enum values fallback to defaults", () => {
+    const cfgPath = getConfigPath();
+    mkdirSync(join(cfgPath, ".."), { recursive: true });
+    writeFileSync(cfgPath, JSON.stringify({ workspaceDisplay: "invalid", cursorStyle: "bad", icons: { mode: "nope" } }), "utf8");
+    const cfg = loadConfig();
+    assert.equal(cfg.workspaceDisplay, DEFAULT_CONFIG.workspaceDisplay);
+    assert.equal(cfg.cursorStyle, DEFAULT_CONFIG.cursorStyle);
+    assert.equal(cfg.icons.mode, DEFAULT_CONFIG.icons.mode);
+  });
+
+  test("saveConfig validates enums", () => {
+    const saved = saveConfig({ workspaceDisplay: "invalid" as any, cursorStyle: "bar" });
+    assert.equal(saved.workspaceDisplay, DEFAULT_CONFIG.workspaceDisplay);
+    assert.equal(saved.cursorStyle, "bar");
+  });
+
+  test("deep merge preserves nested defaults", () => {
+    const cfgPath = getConfigPath();
+    mkdirSync(join(cfgPath, ".."), { recursive: true });
+    writeFileSync(cfgPath, JSON.stringify({ telemetry: { tps: false } }), "utf8");
+    const cfg = loadConfig();
+    assert.equal(cfg.telemetry.tps, false);
+    assert.equal(cfg.telemetry.ttft, true); // preserved
+    assert.equal(cfg.telemetry.duration, true);
+  });
+});
+
+describe("utils-workspace helpers", () => {
+  const origHome = process.env.HOME;
+  beforeEach(() => {
+    // Use a stable HOME for these tests
+    process.env.HOME = "/home/testuser";
+  });
+  afterEach(() => {
+    if (origHome === undefined) delete process.env.HOME;
+    else process.env.HOME = origHome;
+  });
+
+  test("formatCwd: inside HOME becomes ~", () => {
+    // HOME is /home/testuser, cwd is /home/testuser/projects/foo
+    const formatted = formatCwd("/home/testuser/projects/foo");
+    assert.ok(formatted.startsWith("~"), formatted);
+  });
+
+  test("formatCwd: outside HOME stays absolute", () => {
+    const formatted = formatCwd("/tmp/other");
+    assert.equal(formatted, "/tmp/other");
+  });
+
+  test("basenamePath", () => {
+    assert.equal(basenamePath("/foo/bar/baz"), "baz");
+    assert.equal(basenamePath("~/projects/my-workspace"), "my-workspace");
+    assert.equal(basenamePath("single"), "single");
+  });
+
+  test("truncatePath: short path unchanged", () => {
+    assert.equal(truncatePath("~/a/b", 20), "~/a/b");
+  });
+
+  test("truncatePath: long path truncated with ...", () => {
+    const long = "~/a/b/c/d/e/f/g/h";
+    const truncated = truncatePath(long, 8);
+    assert.ok(truncated.includes("..."), truncated);
+    assert.ok(truncated.length <= 8, `len ${truncated.length} <= 8`);
+  });
+
+  test("displayCwd: path vs name mode", () => {
+    const cwd = "/home/testuser/projects/my-workspace";
+    const asPath = displayCwd(cwd, "path");
+    const asName = displayCwd(cwd, "name");
+    assert.ok(asPath.includes("my-workspace"), asPath);
+    assert.equal(asName, "my-workspace");
+    // name mode should be basename of formatted path
+    assert.equal(asName, basenamePath(formatCwd(cwd)));
+  });
+});