pi-editor-footer 0.1.0

package/test/telemetry.test.ts

@@ -0,0 +1,199 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import {
+  formatTurnTelemetry,
+  TurnTelemetryTracker,
+  type AssistantMessage,
+  type TelemetryConfig,
+} from "../src/telemetry.js";
+
+const theme = {
+  fg: (_color: string, text: string) => text,
+};
+
+const fullConfig: TelemetryConfig = {
+  enabled: true,
+  tps: true,
+  ttft: true,
+  duration: true,
+  tokens: true,
+  stalls: true,
+  cost: true,
+};
+
+function makeMessage(output = 20, input = 50): AssistantMessage {
+  const totalTokens = input + output;
+  return {
+    role: "assistant",
+    content: [{ type: "text", text: "response" }],
+    api: "openai-completions",
+    provider: "openai",
+    model: "gpt-4",
+    usage: {
+      input,
+      output,
+      totalTokens,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: totalTokens * 0.000004 },
+    },
+    stopReason: "stop",
+    timestamp: Date.now(),
+  };
+}
+
+function update(
+  message: AssistantMessage,
+  delta = "x",
+  type = "text_delta",
+): { type: "message_update"; message: AssistantMessage; assistantMessageEvent: { type: string; delta: string } } {
+  return {
+    type: "message_update",
+    message: message as unknown as AssistantMessage & { role: string },
+    assistantMessageEvent: { type, delta },
+  };
+}
+
+function startTurn(tracker: TurnTelemetryTracker, message: AssistantMessage, turnIndex = 0): void {
+  tracker.handle({ type: "turn_start", turnIndex, timestamp: Date.now() });
+  tracker.handle({ type: "message_start", message: message as unknown as AssistantMessage & { role: string } });
+}
+
+function endTurn(tracker: TurnTelemetryTracker, message: AssistantMessage, turnIndex = 0) {
+  tracker.handle({ type: "message_end", message: message as unknown as AssistantMessage & { role: string } });
+  return tracker.handle({ type: "turn_end", turnIndex, message: message as unknown as AssistantMessage & { role: string }, toolResults: [] });
+}
+
+describe("TurnTelemetryTracker", () => {
+  test("uses total output over full generation time", () => {
+    let now = 0;
+    const tracker = new TurnTelemetryTracker(() => now);
+    const message = makeMessage();
+    startTurn(tracker, message);
+    for (const timestamp of [4000, 4100]) {
+      now = timestamp;
+      tracker.handle(update(message));
+    }
+    now = 5000;
+    const telemetry = endTurn(tracker, message);
+    assert.deepEqual(telemetry, {
+      tps: 4,
+      ttftMs: 4000,
+      totalMs: 5000,
+      inputTokens: 50,
+      outputTokens: 20,
+      stallMs: 0,
+      stallCount: 0,
+      rateUsdPerMTokens: 4,
+      generationMs: 5000,
+      totalTokens: 70,
+      costUsd: 0.00028,
+      measurementMs: 5000,
+    });
+    assert.equal(
+      formatTurnTelemetry(telemetry!, theme, fullConfig),
+      "> TPS 4.0 tok/s | ~ TTFT 4.0s | + 5.0s | ↑ 50 | ↓ 20 | $ $4.00/M",
+    );
+  });
+
+  test("measures non-streamed responses from turn start", () => {
+    let now = 0;
+    const tracker = new TurnTelemetryTracker(() => now);
+    const message = makeMessage();
+
+    tracker.handle({ type: "turn_start", turnIndex: 0, timestamp: Date.now() });
+    now = 5000;
+    tracker.handle({ type: "message_start", message: message as unknown as AssistantMessage & { role: string } });
+    tracker.handle({ type: "message_end", message: message as unknown as AssistantMessage & { role: string } });
+    const telemetry = tracker.handle({ type: "turn_end", turnIndex: 0, message: message as unknown as AssistantMessage & { role: string }, toolResults: [] })!;
+
+    assert.equal(telemetry.tps, 4);
+    assert.equal(telemetry.ttftMs, 5000);
+    assert.equal(telemetry.generationMs, 5000);
+    assert.equal(telemetry.measurementMs, 5000);
+  });
+
+  test("returns no TPS without output or generation time", () => {
+    const scenarios = [
+      { name: "zero duration", updates: [0, 0], endMs: 0, output: 20 },
+      { name: "zero output", updates: [100, 200], endMs: 800, output: 0 },
+    ];
+
+    for (const scenario of scenarios) {
+      let now = 0;
+      const tracker = new TurnTelemetryTracker(() => now);
+      const message = makeMessage(scenario.output);
+      startTurn(tracker, message);
+      for (const timestamp of scenario.updates) {
+        now = timestamp;
+        tracker.handle(update(message));
+      }
+      now = scenario.endMs;
+      const telemetry = endTurn(tracker, message);
+      assert.equal(telemetry?.tps, null, scenario.name);
+      assert.equal(telemetry?.outputTokens, scenario.output, scenario.name);
+    }
+  });
+
+  test("keeps stalls in delivery time so they lower TPS", () => {
+    function measure(updates: number[], endMs: number) {
+      let now = 0;
+      const tracker = new TurnTelemetryTracker(() => now);
+      const message = makeMessage();
+      startTurn(tracker, message);
+      for (const timestamp of updates) {
+        now = timestamp;
+        tracker.handle(update(message));
+      }
+      now = endMs;
+      return endTurn(tracker, message)!;
+    }
+
+    const uninterrupted = measure([100, 200, 300], 800);
+    const stalled = measure([100, 1200, 2300, 2400, 3500], 3600);
+
+    assert.equal(uninterrupted.tps, 25);
+    assert.equal(stalled.tps, 5.6);
+    assert.ok(stalled.tps! < uninterrupted.tps!);
+    assert.equal(stalled.stallMs, 3300);
+    assert.equal(stalled.stallCount, 2);
+    assert.match(formatTurnTelemetry(stalled, theme, fullConfig), /! stall 2x \/ 3\.3s/);
+  });
+
+  test("getLastTelemetry returns last turn", () => {
+    let now = 0;
+    const tracker = new TurnTelemetryTracker(() => now);
+    const message = makeMessage(10, 10);
+    startTurn(tracker, message);
+    now = 100;
+    tracker.handle(update(message));
+    now = 1000;
+    const tel = endTurn(tracker, message)!;
+    assert.deepEqual(tracker.getLastTelemetry(), tel);
+  });
+
+  test("respects telemetry segment settings", () => {
+    const telemetry = {
+      tps: 50,
+      ttftMs: 200,
+      totalMs: 900,
+      inputTokens: 50,
+      outputTokens: 20,
+      stallMs: 800,
+      stallCount: 1,
+      rateUsdPerMTokens: 4,
+      generationMs: 700,
+      totalTokens: 70,
+      costUsd: 0.00028,
+      measurementMs: 400,
+    };
+    const hidden: TelemetryConfig = {
+      enabled: false,
+      tps: false,
+      ttft: false,
+      duration: false,
+      tokens: false,
+      stalls: false,
+      cost: false,
+    };
+    assert.equal(formatTurnTelemetry(telemetry, theme, hidden), "");
+  });
+});

package/test/utils.test.ts

@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import {
+  basenamePath,
+  fitSegmentsByPriority,
+  formatCwd,
+  formatDuration,
+  fmtTokens,
+  truncateBranch,
+  truncatePath,
+} from "../src/utils.js";
+
+const theme = { fg: (_s: string, t: string) => t };
+
+describe("utils", () => {
+  test("basenamePath extracts last segment", () => {
+    assert.equal(basenamePath("/a/b/c"), "c");
+    assert.equal(basenamePath("~/.pi/agent"), "agent");
+    assert.equal(basenamePath("single"), "single");
+  });
+
+  test("truncateBranch keeps prefix", () => {
+    assert.equal(truncateBranch("fix/login", 20), "fix/login");
+    assert.equal(truncateBranch("a".repeat(30), 10), "a".repeat(7) + "...");
+  });
+
+  test("truncatePath keeps head and tail", () => {
+    assert.equal(truncatePath("/a/b/c", 20), "/a/b/c");
+    const long = "~/a/b/c/d/e/f/g";
+    const truncated = truncatePath(long, 10);
+    assert.ok(truncated.length <= 10);
+    assert.ok(truncated.includes("..."));
+  });
+
+  test("fmtTokens formats", () => {
+    assert.equal(fmtTokens(999), "999");
+    assert.equal(fmtTokens(1500), "1.5k");
+    assert.equal(fmtTokens(15000), "15k");
+  });
+
+  test("formatDuration", () => {
+    assert.equal(formatDuration(500), "0s");
+    assert.equal(formatDuration(65000), "1m 5s");
+    assert.equal(formatDuration(3700000), "1h 1m 40s");
+  });
+  test("formatCwd relative to HOME", () => {
+    const cwd = formatCwd("/tmp");
+    assert.ok(typeof cwd === "string");
+  });
+
+  test("fitSegmentsByPriority compacts and drops", () => {
+    const segs = [
+      { text: "cwd", priority: 0 },
+      { text: "git", priority: 3 },
+      { text: "runtime", priority: 4 },
+    ];
+    const fitted = fitSegmentsByPriority(segs, 20, "...");
+    assert.ok(fitted.length > 0);
+    const narrow = fitSegmentsByPriority(segs, 3, "...");
+    assert.ok(narrow.length <= segs.length);
+  });
+
+  test("fitSegmentsByPriority uses compactText", () => {
+    const segs = [
+      { text: "~/very/long/path/to/project", compactText: "project", priority: 4 },
+      { text: "git: main", priority: 0 },
+    ];
+    const fitted = fitSegmentsByPriority(segs, 15, "...");
+    assert.ok(fitted.some((s) => s.includes("project")));
+  });
+});

package/test/window-presentation.test.ts

@@ -0,0 +1,73 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import {
+	decorateWindow,
+	type WindowThemeLike,
+} from "../src/window-presentation.js";
+
+const RED = "\x1b[31m";
+const RESET = "\x1b[39m";
+
+/** Mock theme emitting REAL ANSI sequences, like pi's Theme does. */
+function makeTheme(): WindowThemeLike {
+	return {
+		border: (s) => `${RED}${s}${RESET}`,
+		highlight: (s) => `${RED}${s}${RESET}`,
+		dim: (s) => `${RED}${s}${RESET}`,
+	};
+}
+
+describe("decorateWindow", () => {
+	test("returns [] for empty input (window hidden)", () => {
+		assert.deepEqual(decorateWindow([], 40, makeTheme()), []);
+	});
+
+	test("builds a bordered box: border, header, body, border", () => {
+		const out = decorateWindow(
+			["grilling · skill", "Interview users"],
+			20,
+			makeTheme(),
+		);
+		assert.equal(out.length, 4);
+		// top/bottom borders: ┌ + (width-2) ─ + ┐
+		assert.equal(out[0], `┌${RED}${"─".repeat(18)}${RESET}┐`);
+		assert.equal(out[3], `└${RED}${"─".repeat(18)}${RESET}┘`);
+		// header row: highlighted header (16 cols = inner width, no pad)
+		assert.equal(out[1], `│ ${RED}grilling · skill${RESET} │`);
+		// body row: dim description (15 cols, padded by 1 + the row's suffix space)
+		assert.equal(out[2], `│ ${RED}Interview users${RESET}  │`);
+	});
+
+	test("every row is exactly `width` columns (ANSI-aware padding)", () => {
+		const out = decorateWindow(["a · b", "line"], 12, makeTheme());
+		for (const row of out) {
+			assert.equal(
+				visibleWidth(row),
+				12,
+				`row ${JSON.stringify(row)} not 12 wide`,
+			);
+		}
+	});
+
+	test("padTo is ANSI-aware: styled content padded to inner width", () => {
+		// "a · b" (5 cols) padded to inner width (8) — 3 trailing spaces AFTER the reset
+		const out = decorateWindow(["a · b", "line"], 12, makeTheme());
+		assert.equal(out[1], `│ ${RED}a · b${RESET}    │`);
+	});
+
+	test("short content pads, long content does not crash (clamped pad)", () => {
+		const out = decorateWindow(["label · kind", "short"], 10, makeTheme());
+		assert.equal(out.length, 4);
+		assert.ok(out[1].includes("label · kind"));
+	});
+
+	test("header uses highlight, body uses dim, borders use border style", () => {
+		const out = decorateWindow(["h", "d1", "d2"], 8, makeTheme());
+		assert.ok(out[1].startsWith(`│ ${RED}h${RESET}`));
+		assert.ok(out[2].startsWith(`│ ${RED}d1${RESET}`));
+		assert.ok(out[3].startsWith(`│ ${RED}d2${RESET}`));
+		assert.ok(out[0].startsWith(`┌${RED}`));
+		assert.ok(out[out.length - 1].startsWith(`└${RED}`));
+	});
+});

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "types": ["node"]
+  },
+  "include": ["src", "test"]
+}