@caph42/pi-ccline 0.0.0-stage → 0.1.1

package/extensions/pi-ccline/render.test.ts

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+import { extensionStatusLine, loadingNotice, missingBinaryNotice, normalizeFrame, noticeFrame, sanitizeStatusText, withStaleMarker } from "./render.ts";
+
+const RED = "\u001b[31m";
+const RESET = "\u001b[0m";
+
+test("splits ccline output into footer lines and drops trailing blanks", () => {
+	const stdout = `${RED}one${RESET}\n${RED}two${RESET}\n\n`;
+	assert.deepEqual(normalizeFrame(stdout, 80), [`${RED}one${RESET}`, `${RED}two${RESET}`]);
+});
+
+test("strips carriage returns", () => {
+	assert.deepEqual(normalizeFrame("a\r\nb\r\n", 80), ["a", "b"]);
+});
+
+test("truncates by visible width, not string length", () => {
+	const line = `${RED}${"日".repeat(20)}${RESET}`;
+	assert.equal(visibleWidth(line), 40);
+	assert.notEqual(line.length, visibleWidth(line));
+	const [truncated = ""] = normalizeFrame(line, 10);
+	assert.ok(visibleWidth(truncated) <= 10, `visible width was ${visibleWidth(truncated)}`);
+});
+
+test("keeps a line that already fits untouched", () => {
+	const line = `${RED}abc${RESET}`;
+	assert.deepEqual(normalizeFrame(line, 3), [line]);
+});
+
+test("narrow widths do not overflow", () => {
+	for (const width of [1, 2, 5]) {
+		const [line = ""] = normalizeFrame(`${RED}model · dir · 15% · 120k tokens${RESET}`, width);
+		assert.ok(visibleWidth(line) <= width, `width ${width} produced ${visibleWidth(line)}`);
+	}
+});
+
+test("empty output normalizes to no lines so the caller can keep the last frame", () => {
+	assert.deepEqual(normalizeFrame("", 80), []);
+	assert.deepEqual(normalizeFrame("\n\n", 80), []);
+});
+
+test("notices fit the width", () => {
+	for (const frame of [loadingNotice(6), missingBinaryNotice(20), noticeFrame("ccline failed: exit 1", 12)]) {
+		assert.equal(frame.length, 1);
+		assert.ok(visibleWidth(frame[0] ?? "") <= 20);
+	}
+});
+
+test("stale marker is appended only when it still fits", () => {
+	const lines = ["short"];
+	assert.deepEqual(withStaleMarker(lines, 20, " ·stale"), ["short ·stale"]);
+	assert.deepEqual(withStaleMarker(lines, 7, " ·stale"), ["short"]);
+	assert.deepEqual(withStaleMarker([], 20, " ·stale"), []);
+});
+
+test("stale marker respects ANSI width on the last line", () => {
+	const lines = [`${RED}12345${RESET}`];
+	const marked = withStaleMarker(lines, 11, "xx");
+	assert.equal(marked.length, 1);
+	assert.ok(visibleWidth(marked[0] ?? "") <= 11);
+});
+
+test("extension statuses become one sorted row like the built-in footer", () => {
+	const statuses = new Map([
+		["cursor-fast", "Cursor fast: on"],
+		["alpha", "first"],
+	]);
+	assert.equal(extensionStatusLine(statuses, 80), "first Cursor fast: on");
+});
+
+test("status text is collapsed to a single line", () => {
+	assert.equal(sanitizeStatusText("a\nb\tc  \r\nd"), "a b c d");
+	assert.equal(extensionStatusLine(new Map([["k", "one\ntwo"]]), 80), "one two");
+});
+
+test("blank statuses are dropped and an empty set produces no row", () => {
+	assert.equal(extensionStatusLine(new Map([["k", "   "]]) as Map<string, string>, 80), null);
+	assert.equal(extensionStatusLine(new Map(), 80), null);
+	assert.equal(extensionStatusLine(null, 80), null);
+	assert.equal(extensionStatusLine(undefined, 80), null);
+});
+
+test("a long status row is truncated by visible width with the dim ellipsis", () => {
+	const row = extensionStatusLine(new Map([["k", "日".repeat(20)]]), 10, "...");
+	assert.ok(row !== null);
+	assert.ok(visibleWidth(row) <= 10, `visible width was ${visibleWidth(row ?? "")}`);
+	assert.ok((row ?? "").replace(/\u001b\[[0-9;]*m/g, "").endsWith("..."));
+});

package/extensions/pi-ccline/render.ts

@@ -0,0 +1,72 @@
+// Normalizes ccline stdout into footer lines.
+// ccline emits ANSI escapes, so every width decision goes through pi-tui's
+// visible-width helpers instead of String.length.
+
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+/** ccline is asked to wrap at COLUMNS, but a cached frame may still be wider. */
+export function normalizeFrame(stdout: string, width: number, ellipsis = "…"): string[] {
+	const safeWidth = Math.max(1, Math.floor(width));
+	const lines = stdout.replace(/\r\n?/g, "\n").split("\n");
+	while (lines.length > 0 && (lines[lines.length - 1] ?? "").trim() === "") {
+		lines.pop();
+	}
+	return lines.map((line) => (visibleWidth(line) > safeWidth ? truncateToWidth(line, safeWidth, ellipsis) : line));
+}
+
+/** Fit a plain notice into the footer width. */
+export function noticeFrame(text: string, width: number): string[] {
+	return [truncateToWidth(text, Math.max(1, Math.floor(width)))];
+}
+
+export function missingBinaryNotice(width: number): string[] {
+	return noticeFrame("ccline not found · npm i -g @cometix/ccline · or set binary in ~/.pi/agent/pi-ccline/config.json", width);
+}
+
+export function loadingNotice(width: number): string[] {
+	return noticeFrame("ccline …", width);
+}
+
+/**
+ * Extension statuses are single-line by contract; collapse control characters
+ * the way pi's built-in footer does before measuring anything.
+ */
+export function sanitizeStatusText(text: string): string {
+	return text.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim();
+}
+
+/**
+ * pi's built-in footer puts every extension status on one extra row, sorted by
+ * key and joined by a space. Mirror that so `ctx.ui.setStatus` keeps working
+ * when this footer owns the slot.
+ */
+export function extensionStatusLine(
+	statuses: Iterable<[string, string]> | null | undefined,
+	width: number,
+	ellipsis = "…",
+): string | null {
+	if (!statuses) return null;
+	const text = [...statuses]
+		.sort(([a], [b]) => a.localeCompare(b))
+		.map(([, value]) => sanitizeStatusText(value))
+		.filter((value) => value.length > 0)
+		.join(" ");
+	if (!text) return null;
+	const safeWidth = Math.max(1, Math.floor(width));
+	return visibleWidth(text) > safeWidth ? truncateToWidth(text, safeWidth, ellipsis) : text;
+}
+
+/**
+ * Append a marker to the last line when it still fits. A stale frame is kept
+ * visible instead of blanking the footer, and the marker stays opt-in.
+ */
+export function withStaleMarker(lines: string[], width: number, marker: string): string[] {
+	if (lines.length === 0) return lines;
+	const safeWidth = Math.max(1, Math.floor(width));
+	const last = lines[lines.length - 1] ?? "";
+	const markerWidth = visibleWidth(marker);
+	if (markerWidth === 0 || visibleWidth(last) + markerWidth > safeWidth) return lines;
+	const next = lines.slice();
+	next[next.length - 1] = last + marker;
+	return next;
+}

package/fixtures/basic.json

@@ -0,0 +1,26 @@
+{
+  "cwd": "/Users/caph/Workspace/pi-packages/pi-ccline",
+  "workspace": {
+    "current_dir": "/Users/caph/Workspace/pi-packages/pi-ccline"
+  },
+  "model": {
+    "id": "gpt-5.6-codex",
+    "display_name": "GPT-5.6 Codex (openai-codex)"
+  },
+  "effort": {
+    "level": "high"
+  },
+  "context_window": {
+    "context_window_size": 272000,
+    "current_usage": {
+      "input_tokens": 42000
+    },
+    "used_percentage": 15.4
+  },
+  "cost": {
+    "total_cost_usd": 1.2345,
+    "total_duration_ms": 1830000
+  },
+  "session_id": "4f8f2c1a-0000-4000-8000-000000000000",
+  "session_name": "pi-ccline demo"
+}

package/package.json

@@ -1,6 +1,50 @@
 {
-  "name": "@caph42/pi-ccline",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@caph42/pi-ccline",
+	"version": "0.1.1",
+	"description": "Pi extension that renders the footer by delegating to the CCometixLine (ccline) statusline binary",
+	"keywords": [
+		"pi-package",
+		"pi-extension",
+		"pi-coding-agent",
+		"statusline",
+		"footer",
+		"ccline",
+		"cometix"
+	],
+	"license": "MIT",
+	"type": "module",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Caph-dev/pi-ccline.git"
+	},
+	"homepage": "https://github.com/Caph-dev/pi-ccline#readme",
+	"bugs": {
+		"url": "https://github.com/Caph-dev/pi-ccline/issues"
+	},
+	"engines": {
+		"node": ">=22.19.0"
+	},
+	"files": [
+		"extensions",
+		"scripts",
+		"fixtures",
+		"README.md",
+		"README_zh.md"
+	],
+	"pi": {
+		"extensions": [
+			"./extensions/pi-ccline/index.ts"
+		]
+	},
+	"scripts": {
+		"test": "node --test",
+		"render-once": "node --experimental-strip-types scripts/render-once.ts"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/scripts/render-once.ts

@@ -0,0 +1,164 @@
+// Render one ccline frame from a fixture, for manual acceptance checks.
+//
+//   node --experimental-strip-types scripts/render-once.ts
+//   node --experimental-strip-types scripts/render-once.ts --fixture fixtures/basic.json --width 120 --width 40
+//
+// Runs the real binary (no model call, no pi session) and prints both the raw
+// ANSI bytes and the footer lines pi would receive.
+
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+import { clearBinaryCache, probeVersion, resolveBinary, spawnCcline } from "../extensions/pi-ccline/binary.ts";
+import { configPath, loadConfig } from "../extensions/pi-ccline/config.ts";
+import { normalizeFrame } from "../extensions/pi-ccline/render.ts";
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+interface Options {
+	fixture: string;
+	binary: string | null;
+	widths: number[];
+	timeoutMs: number;
+	raw: boolean;
+	home: string;
+}
+
+function parseArgs(argv: string[]): Options {
+	const options: Options = {
+		fixture: resolve(packageRoot, "fixtures/basic.json"),
+		binary: null,
+		widths: [],
+		timeoutMs: 5000,
+		raw: false,
+		home: homedir(),
+	};
+
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		const next = () => {
+			index += 1;
+			const value = argv[index];
+			if (value === undefined) throw new Error(`missing value for ${arg}`);
+			return value;
+		};
+		switch (arg) {
+			case "--fixture":
+				options.fixture = resolve(process.cwd(), next());
+				break;
+			case "--binary":
+				options.binary = resolve(process.cwd(), next());
+				break;
+			case "--width":
+				options.widths.push(Number(next()));
+				break;
+			case "--timeout":
+				options.timeoutMs = Number(next());
+				break;
+			case "--home":
+				// Isolate both config lookup and the child process (~/.claude writes).
+				options.home = resolve(process.cwd(), next());
+				break;
+			case "--raw":
+				options.raw = true;
+				break;
+			case "--help":
+			case "-h":
+				console.log(
+					[
+						"usage: render-once.ts [--fixture <path>] [--binary <path>] [--width <cols>]...",
+						"                     [--timeout <ms>] [--home <dir>] [--raw]",
+						"",
+						"Without --width the fixture renders at 120 and 40 columns.",
+					].join("\n"),
+				);
+				process.exit(0);
+				break;
+			default:
+				throw new Error(`unknown argument: ${arg}`);
+		}
+	}
+
+	if (options.widths.length === 0) options.widths = [120, 40];
+	for (const width of options.widths) {
+		if (!Number.isFinite(width) || width < 1) throw new Error(`invalid width: ${width}`);
+	}
+	return options;
+}
+
+async function main(): Promise<number> {
+	const options = parseArgs(process.argv.slice(2));
+	const fixtureText = readFileSync(options.fixture, "utf8");
+	const payload = JSON.stringify(JSON.parse(fixtureText));
+	const config = loadConfig(configPath(options.home));
+
+	clearBinaryCache();
+	const resolved = options.binary ? { path: options.binary, source: "config" as const } : resolveBinary(config.binary, { home: options.home });
+
+	console.log(`fixture: ${options.fixture}`);
+	if (!resolved.path) {
+		console.error("ccline not found. Looked at config.binary, ~/.claude/ccline/ccline and PATH.");
+		console.error("install: npm i -g @cometix/ccline   (or pass --binary <path>)");
+		return 1;
+	}
+
+	const version = await probeVersion(resolved.path, options.timeoutMs);
+	console.log(`binary:  ${resolved.path} (${resolved.source})`);
+	console.log(`home:    ${options.home}`);
+	console.log(`version: ${version ?? "unknown"}`);
+
+	const childEnv: Record<string, string> = { ...config.env, HOME: options.home, USERPROFILE: options.home };
+
+	let failures = 0;
+	for (const width of options.widths) {
+		const result = await spawnCcline({
+			binary: resolved.path,
+			payload,
+			timeoutMs: options.timeoutMs,
+			columns: width,
+			env: childEnv,
+		});
+
+		console.log("");
+		console.log(`--- width ${width} ---`);
+		if (result.timedOut) {
+			console.error(`timed out after ${options.timeoutMs}ms`);
+			failures += 1;
+			continue;
+		}
+		if (!result.ok) {
+			console.error(`failed: ${result.error ?? `exit ${result.code}`}${result.stderr.trim() ? `\n${result.stderr.trim()}` : ""}`);
+			failures += 1;
+			continue;
+		}
+		if (options.raw) console.log(`raw: ${JSON.stringify(result.stdout)}`);
+
+		const lines = normalizeFrame(result.stdout, width);
+		if (lines.length === 0) {
+			console.error("empty output");
+			failures += 1;
+			continue;
+		}
+		for (const [index, line] of lines.entries()) {
+			console.log(`[${index}] w=${visibleWidth(line)} ${line}`);
+		}
+		const overflow = lines.filter((line) => visibleWidth(line) > width);
+		if (overflow.length > 0) {
+			console.error(`width contract violated: ${overflow.length} line(s) wider than ${width}`);
+			failures += 1;
+		}
+	}
+
+	return failures === 0 ? 0 : 1;
+}
+
+main()
+	.then((code) => process.exit(code))
+	.catch((error: unknown) => {
+		console.error(error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	});