@adeildo/pi-harness 4.0.0 → 4.1.0

package/src/look/ui/header.ts

@@ -1,212 +0,0 @@
-// The start screen. A card with the π drawn in blocks, coloured along the theme's effort ramp, next to
-// what the session starts with: the model, the folder, the machine, what loaded, and the keys worth
-// knowing. Narrow terminals get two plain lines instead.
-import { keyText } from "@earendil-works/pi-coding-agent";
-import { type Component, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-
-import { BOXES, border } from "../render/frame.ts";
-import { EFFORT_LEVELS, type Paint } from "../render/paint.ts";
-import { renderSegments, type SegmentId } from "../render/segments.ts";
-import type { HeaderStyle } from "../settings.ts";
-import type { Screen } from "./screen.ts";
-
-/** The π, one character per pixel, drawn two pixels per row with half blocks. */
-const PIXELS = [
-	"..............",
-	".############.",
-	"##############",
-	"...##....##...",
-	"...##....##...",
-	"...##....##...",
-	"...##....##...",
-	"...##....##...",
-	"..##.....###..",
-	".##.......####",
-];
-const LOGO = halfBlocks(PIXELS);
-/** One effort level per row, from cool at the top to hot at the bottom. */
-const LOGO_RAMP = EFFORT_LEVELS.slice(1);
-const LOGO_COLUMN = 20;
-/** Under this the right column is too cramped to share with the logo. */
-const MIN_RIGHT = 34;
-const MIN_CARD = 48;
-
-export interface LoadedCounts {
-	tools: number;
-	skills: number;
-	prompts: number;
-	extensions: number;
-}
-
-export interface HeaderSource {
-	style(): HeaderStyle;
-	counts(): LoadedCounts;
-}
-
-interface Hint {
-	key: string;
-	does: string;
-}
-
-export class HeaderComponent implements Component {
-	readonly #screen: Screen;
-	readonly #source: HeaderSource;
-
-	constructor(screen: Screen, source: HeaderSource) {
-		this.#screen = screen;
-		this.#source = source;
-	}
-
-	render(width: number): string[] {
-		if (width < MIN_CARD || this.#source.style() === "compact") return this.#compact(width);
-		return this.#card(width);
-	}
-
-	invalidate(): void {}
-
-	#card(width: number): string[] {
-		const screen = this.#screen;
-		const paint = screen.paint();
-		const box = BOXES.rounded;
-		const frame = paint.frame;
-		const title = this.#title(paint);
-		const inner = width - 4;
-		const withLogo = inner - LOGO_COLUMN - 3 >= MIN_RIGHT;
-		const rightWidth = withLogo ? inner - LOGO_COLUMN - 3 : inner;
-
-		const right = [
-			this.#segments(["model", "effort"], paint),
-			this.#segments(["path", "branch"], paint),
-			this.#loaded(paint),
-			paint.dim("─".repeat(Math.max(0, rightWidth))),
-			...this.#hints(paint, rightWidth),
-		];
-		const left = [
-			...LOGO.map((row, index) => paint.effort(LOGO_RAMP[index] ?? "max", row)),
-			"",
-			paint.italic(paint.dim("ready when you are")),
-		];
-
-		const rows = Math.max(left.length, right.length);
-		const lines = [
-			border(width, [{ text: title, priority: 1 }], [], {
-				box,
-				edge: "top",
-				paint: frame,
-				separator: " ",
-			}),
-		];
-		for (let row = 0; row < rows; row++) {
-			const content = withLogo
-				? `${center(left[row] ?? "", LOGO_COLUMN)} ${frame("│")} ${pad(right[row] ?? "", rightWidth)}`
-				: pad(right[row] ?? "", rightWidth);
-			lines.push(`${frame(box.vertical)} ${content} ${frame(box.vertical)}`);
-		}
-		lines.push(border(width, [], [], { box, edge: "bottom", paint: frame, separator: " " }));
-		lines.push("");
-		return lines.map((line) => truncateToWidth(line, width, ""));
-	}
-
-	#compact(width: number): string[] {
-		const paint = this.#screen.paint();
-		const separator = paint.dim(this.#screen.separator());
-		const first = [this.#title(paint), this.#segments(["model", "effort", "path", "branch"], paint)]
-			.filter((part) => part !== "")
-			.join(separator);
-		const hints = HINTS()
-			.map((hint) => `${paint.role("brand", hint.key)} ${paint.dim(hint.does)}`)
-			.join(separator);
-		return [first, hints, ""].map((line) => truncateToWidth(` ${line}`, width, "…"));
-	}
-
-	#title(paint: Paint): string {
-		const glyph = paint.bold(paint.role("brand", "π"));
-		return `${glyph} ${paint.bold("pi")} ${paint.dim(`v${this.#screen.snapshot().version}`)}`;
-	}
-
-	#segments(ids: readonly SegmentId[], paint: Paint): string {
-		const pieces = renderSegments(ids, {
-			snapshot: this.#screen.snapshot(),
-			glyphs: this.#screen.glyphs(),
-			paint,
-			options: this.#screen.options(),
-		});
-		return pieces.map((piece) => piece.text).join(paint.dim(this.#screen.separator()));
-	}
-
-	#loaded(paint: Paint): string {
-		const counts = this.#source.counts();
-		const parts = [
-			this.#segments(["host"], paint),
-			...[
-				[counts.tools, "tools"],
-				[counts.skills, "skills"],
-				[counts.prompts, "prompts"],
-				[counts.extensions, "extensions"],
-			]
-				.filter(([value]) => (value as number) > 0)
-				.map(([value, label]) => `${paint.text(String(value))} ${paint.dim(String(label))}`),
-		];
-		return parts.filter((part) => part !== "").join(paint.dim(this.#screen.separator()));
-	}
-
-	/** Three rows of two hints each, or one column when narrow. */
-	#hints(paint: Paint, width: number): string[] {
-		const hints = HINTS();
-		const keyWidth = Math.max(...hints.map((hint) => visibleWidth(hint.key)));
-		const cell = (hint: Hint) =>
-			`${paint.role("brand", hint.key.padEnd(keyWidth))} ${paint.dim(hint.does)}`;
-		const cellWidth = keyWidth + 1 + Math.max(...hints.map((hint) => visibleWidth(hint.does)));
-		if (width < cellWidth * 2 + 3) return hints.slice(0, 3).map(cell);
-		const rows: string[] = [];
-		for (let index = 0; index < hints.length; index += 2) {
-			const first = hints[index];
-			const second = hints[index + 1];
-			if (first === undefined) break;
-			rows.push(
-				second === undefined ? cell(first) : `${pad(cell(first), cellWidth)}   ${cell(second)}`,
-			);
-		}
-		return rows;
-	}
-}
-
-/** Read on every render, so a remapped key shows the new binding. */
-function HINTS(): Hint[] {
-	return [
-		{ key: keyText("app.model.select") || "/model", does: "model" },
-		{ key: keyText("app.thinking.cycle") || "/thinking", does: "effort" },
-		{ key: "/", does: "commands" },
-		{ key: "!", does: "shell" },
-		{ key: keyText("app.editor.external") || "/editor", does: "external editor" },
-		{ key: "/tree", does: "session history" },
-	];
-}
-
-export function halfBlocks(pixels: readonly string[]): string[] {
-	const rows: string[] = [];
-	for (let row = 0; row < pixels.length; row += 2) {
-		const top = pixels[row] ?? "";
-		const bottom = pixels[row + 1] ?? "";
-		let line = "";
-		for (let column = 0; column < Math.max(top.length, bottom.length); column++) {
-			const up = top[column] === "#";
-			const down = bottom[column] === "#";
-			line += up && down ? "█" : up ? "▀" : down ? "▄" : " ";
-		}
-		rows.push(line);
-	}
-	return rows;
-}
-
-function pad(text: string, width: number): string {
-	const clipped = truncateToWidth(text, Math.max(0, width), "…");
-	return `${clipped}${" ".repeat(Math.max(0, width - visibleWidth(clipped)))}`;
-}
-
-function center(text: string, width: number): string {
-	const clipped = truncateToWidth(text, width, "");
-	const room = Math.max(0, width - visibleWidth(clipped));
-	const before = Math.floor(room / 2);
-	return `${" ".repeat(before)}${clipped}${" ".repeat(room - before)}`;
-}

package/src/look/ui/screen.ts

@@ -1,39 +0,0 @@
-// What the components read. The feature implements it over the live session and the settings; tests
-// implement it over a fixed snapshot. Everything is read at render time, so a setting or theme change
-// shows on the next frame with nothing to invalidate.
-import type { Snapshot } from "../data/snapshot.ts";
-import type { Piece } from "../render/fit.ts";
-import type { FrameStyle } from "../render/frame.ts";
-import type { Glyphs } from "../render/glyphs.ts";
-import type { Paint } from "../render/paint.ts";
-import { renderSegments, type SegmentId, type SegmentOptions } from "../render/segments.ts";
-import type { CursorStyle } from "../settings.ts";
-
-export type SlotName = "strip" | "topLeft" | "topRight" | "bottomLeft" | "bottomRight" | "below";
-
-export interface Screen {
-	snapshot(): Snapshot;
-	glyphs(): Glyphs;
-	/** Paints with the active theme. `frame` overrides the border colour, which the editor owns. */
-	paint(frame?: (text: string) => string): Paint;
-	separator(): string;
-	options(): SegmentOptions;
-	slot(name: SlotName): readonly SegmentId[];
-	frameStyle(): FrameStyle | "off";
-	cursor(): CursorStyle;
-}
-
-/** The rendered pieces of one slot. The separator is painted here, once, for everyone. */
-export function slotPieces(
-	screen: Screen,
-	name: SlotName,
-	snapshot: Snapshot,
-	paint: Paint,
-): Piece[] {
-	return renderSegments(screen.slot(name), {
-		snapshot,
-		glyphs: screen.glyphs(),
-		paint,
-		options: screen.options(),
-	});
-}

package/src/look/ui/working.ts

@@ -1,73 +0,0 @@
-// What the spinner says. Pi's says "Working" for the whole run; this one says what is happening: the
-// newest line of the model's thinking, the tool call it is writing, the command running. It only
-// speaks through pi's public `setWorkingMessage`, so pi still owns the spinner and where it sits.
-
-export type Activity =
-	| { kind: "waiting" }
-	| { kind: "thinking"; tail: string }
-	| { kind: "writing" }
-	| { kind: "calling"; tool: string }
-	| { kind: "running"; tool: string; detail: string };
-
-/** One line, plain text: pi paints the message itself. */
-export function describe(activity: Activity): string {
-	switch (activity.kind) {
-		case "waiting":
-			return "Waiting";
-		case "thinking":
-			return activity.tail === "" ? "Thinking" : `Thinking · ${activity.tail}`;
-		case "writing":
-			return "Writing";
-		case "calling":
-			return `Calling ${activity.tool}`;
-		case "running":
-			return activity.detail === "" ? activity.tool : `${activity.tool} · ${activity.detail}`;
-	}
-}
-
-interface ContentPart {
-	type?: unknown;
-	thinking?: unknown;
-	name?: unknown;
-}
-
-/** The newest line of the thinking so far. Model output, so control characters go. */
-export function thinkingTail(content: unknown): string {
-	if (!Array.isArray(content)) return "";
-	for (let index = content.length - 1; index >= 0; index--) {
-		const part = content[index] as ContentPart | undefined;
-		if (part?.type !== "thinking" || typeof part.thinking !== "string") continue;
-		const lines = part.thinking.split("\n").map(clean).filter(Boolean);
-		return lines.at(-1) ?? "";
-	}
-	return "";
-}
-
-/** The name of the tool call being written, when the model is writing one. */
-export function callingTool(content: unknown): string | undefined {
-	if (!Array.isArray(content)) return undefined;
-	const part = content.at(-1) as ContentPart | undefined;
-	return part?.type === "toolCall" && typeof part.name === "string" ? part.name : undefined;
-}
-
-const DETAIL_KEYS = ["command", "path", "file_path", "pattern", "query", "url", "prompt"];
-
-/** The one argument that says what a tool is doing: the command, the file, the pattern. */
-export function toolDetail(args: unknown): string {
-	if (typeof args !== "object" || args === null) return "";
-	const record = args as Record<string, unknown>;
-	for (const key of DETAIL_KEYS) {
-		const value = record[key];
-		if (typeof value === "string" && value.trim() !== "") {
-			return clean(value.split("\n").find((line) => line.trim() !== "") ?? "");
-		}
-	}
-	return "";
-}
-
-// oxlint-disable-next-line no-control-regex -- escape sequences and control characters are the target
-const CONTROL = /\x1b\[[0-?]*[ -/]*[@-~]|[\x00-\x1f\x7f]/g;
-
-function clean(text: string): string {
-	return text.replace(CONTROL, " ").replace(/\s+/g, " ").trim();
-}

package/src/providers/index.ts

@@ -1,10 +0,0 @@
-import { createApp } from "@adeildo/pi-kit";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-
-import { subscription } from "./subscription/feature.ts";
-
-export { claudeCodeVersion, subscription } from "./subscription/feature.ts";
-
-export default function piProviders(pi: ExtensionAPI): void {
-	createApp(pi, { name: "pi-harness" }).use(subscription).build();
-}

package/src/providers/subscription/billing.ts

@@ -1,27 +0,0 @@
-// How Claude Code tells Anthropic who it is. A request is billed to the Claude plan when it
-// carries Claude Code's user agent and a first system block with a billing attribution, which ends
-// in three characters of the first user message hashed with the version and a salt.
-import { createHash } from "node:crypto";
-
-export const CLAUDE_CODE_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
-
-const FINGERPRINT_SALT = "59cf53e54c78";
-const SAMPLED_POSITIONS = [4, 7, 20];
-
-export function userAgent(version: string): string {
-	return `claude-cli/${version} (external, cli)`;
-}
-
-/** Positions past the end of the message count as "0", the way Claude Code pads them. */
-export function fingerprint(firstUserText: string, version: string): string {
-	const sampled = SAMPLED_POSITIONS.map((position) => firstUserText[position] ?? "0").join("");
-	return createHash("sha256")
-		.update(`${FINGERPRINT_SALT}${sampled}${version}`)
-		.digest("hex")
-		.slice(0, 3);
-}
-
-export function billingAttribution(firstUserText: string, version: string): string {
-	const stamp = `${version}.${fingerprint(firstUserText, version)}`;
-	return `x-anthropic-billing-header: cc_version=${stamp}; cc_entrypoint=cli;`;
-}

package/src/providers/subscription/feature.ts

@@ -1,43 +0,0 @@
-// Bills Anthropic OAuth requests to the Claude Pro/Max plan instead of extra usage. It acts on any
-// provider that speaks the Anthropic Messages API with an OAuth token, not only the one named
-// `anthropic`, so a second account under another name gets the same treatment.
-import { defineFeature, isObject, matching, setting } from "@adeildo/pi-kit";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-
-import { userAgent } from "./billing.ts";
-import { billToPlan } from "./payload.ts";
-
-export const claudeCodeVersion = setting({
-	id: "subscription.claudeCodeVersion",
-	default: "2.1.280",
-	decoder: matching(/^\d+\.\d+\.\d+$/, "a Claude Code version like 2.1.280"),
-	ui: {
-		group: "Providers",
-		label: "Claude Code version",
-		description:
-			"The Claude Code version pi reports to Anthropic. Anthropic refuses newer models to versions it considers too old.",
-	},
-});
-
-export const subscription = defineFeature({
-	id: "subscription",
-	description: "Bill Anthropic OAuth requests to the Claude plan instead of extra usage",
-	settings: [claudeCodeVersion],
-	setup(scope) {
-		scope.on("before_provider_headers", (event, ctx) => {
-			if (usesSubscription(ctx))
-				event.headers["user-agent"] = userAgent(claudeCodeVersion.get(scope));
-		});
-
-		scope.on("before_provider_request", (event, ctx) => {
-			if (!usesSubscription(ctx) || !isObject(event.payload)) return undefined;
-			return billToPlan(event.payload, claudeCodeVersion.get(scope));
-		});
-	},
-});
-
-function usesSubscription(ctx: ExtensionContext): boolean {
-	const model = ctx.model;
-	if (model === undefined || model.api !== "anthropic-messages") return false;
-	return ctx.modelRegistry.isUsingOAuth(model);
-}

package/src/providers/subscription/payload.ts

@@ -1,87 +0,0 @@
-// Rewrites the request pi builds for an Anthropic OAuth token. Anthropic's billing classifier reads
-// `system`, and any text there that Claude Code would not send costs extra usage. So `system` keeps
-// the attribution and the identity, and pi's prompt moves into the first user message, where the
-// model still follows it.
-import { isObject } from "@adeildo/pi-kit";
-
-import { billingAttribution, CLAUDE_CODE_IDENTITY } from "./billing.ts";
-
-export interface TextBlock {
-	type: "text";
-	text: string;
-	cache_control?: unknown;
-}
-
-type Payload = Record<string, unknown>;
-
-export function billToPlan(payload: Payload, version: string): Payload | undefined {
-	const system = claudeCodeSystem(payload.system);
-	if (system === undefined) return undefined;
-
-	const [identity, ...moved] = system;
-	const messages = Array.isArray(payload.messages) ? payload.messages : [];
-	const attribution: TextBlock = {
-		type: "text",
-		text: billingAttribution(firstUserText(messages), version),
-	};
-
-	return {
-		...payload,
-		system: [attribution, identity],
-		messages: prependInstructions(messages, moved),
-	};
-}
-
-function claudeCodeSystem(system: unknown): [TextBlock, ...TextBlock[]] | undefined {
-	if (!Array.isArray(system) || !system.every(isTextBlock)) return undefined;
-	const [first, ...rest] = system;
-	if (first === undefined || !first.text.startsWith(CLAUDE_CODE_IDENTITY)) return undefined;
-	return [first, ...rest];
-}
-
-function isTextBlock(block: unknown): block is TextBlock {
-	return isObject(block) && block.type === "text" && typeof block.text === "string";
-}
-
-function firstUserText(messages: readonly unknown[]): string {
-	const message = messages.find(isUserMessage);
-	if (message === undefined) return "";
-	if (typeof message.content === "string") return message.content;
-	if (!Array.isArray(message.content)) return "";
-	return message.content.find(isTextBlock)?.text ?? "";
-}
-
-function isUserMessage(message: unknown): message is Payload {
-	return isObject(message) && message.role === "user";
-}
-
-function prependInstructions(messages: readonly unknown[], moved: readonly TextBlock[]): unknown[] {
-	const text = moved
-		.map((block) => block.text)
-		.filter((part) => part.trim() !== "")
-		.join("\n\n");
-	if (text === "") return [...messages];
-
-	// The moved prompt takes over the cache breakpoint pi put on it, so the request keeps the same
-	// number of breakpoints and the prompt stays cached on its own.
-	const cacheControl = moved.findLast((block) => block.cache_control !== undefined)?.cache_control;
-	const instructions: TextBlock = {
-		type: "text",
-		text: `<system-instructions>\n${text}\n</system-instructions>`,
-		...(cacheControl === undefined ? {} : { cache_control: cacheControl }),
-	};
-
-	const index = messages.findIndex(isUserMessage);
-	const target = messages[index];
-	if (!isUserMessage(target)) return [{ role: "user", content: [instructions] }, ...messages];
-
-	const updated = [...messages];
-	updated[index] = { ...target, content: [instructions, ...contentBlocks(target.content)] };
-	return updated;
-}
-
-function contentBlocks(content: unknown): unknown[] {
-	if (Array.isArray(content)) return content;
-	if (typeof content === "string" && content !== "") return [{ type: "text", text: content }];
-	return [];
-}