@adeildo/pi-look 5.9.2 → 5.10.0

package/README.md

@@ -22,32 +22,46 @@
 
 <!-- /docs -->
 
-## The screen
-
-A finished answer takes a box of its own, so you can see what the model wants to run before it runs. The mark of the tool and its name sit on the top line, the command under them, and the reason it was allowed under that, when another model answered it. A line cuts the command off from what it printed, and the bottom line says how it went: a check, a cross, and how long it took. A command still running says `running` with the time so far. A tool from an MCP server shows its server and tool instead of `mcp__server__tool`. A tool with no drawing of its own, like the memory calls, gets the same box with its name and arguments on top and its text under the cut.
-
 <!-- docs:look/call -->
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/felipeadeildo/pi-harness/main/packages/look/assets/call.png" alt="Three commands, each in its own box: a bash command with the reason it was allowed and the time it took, a file read, and a command still running." width="860">
+  <img src="https://raw.githubusercontent.com/felipeadeildo/pi-harness/main/packages/look/assets/call.png" alt="Three commands, each in its own box: a bash command with the reason it was allowed and the time it took, a file read, and a command still running." width="420">
+  <img src="https://raw.githubusercontent.com/felipeadeildo/pi-harness/main/packages/look/assets/settings.png" alt="The settings screen in a frame, titled Settings. The Look tab holds Appearance, Your messages and What is on screen, with Editor frame selected. Under the list, the preview draws the editor's rounded frame with main on the top edge, the folder on the right, the model on the bottom edge and the context on the right. Below, the setting's name and default, and the keys along the bottom edge." width="420">
   <br>
-  <em>One command that ran, one a rule let through, and one still going.</em>
+  <em>Every command in a box, and a setting shown before you keep it.</em>
 </p>
 
 <!-- /docs -->
 
+## The screen
+
+A finished answer takes a box of its own, so you can see what the model wants to run before it runs. The mark of the tool and its name sit on the top line, the command under them, and the reason it was allowed under that, when another model answered it. A line cuts the command off from what it printed, and the bottom line says how it went: a check, a cross, and how long it took. A command still running says `running` with the time so far. A tool from an MCP server shows its server and tool instead of `mcp__server__tool`. A tool with no drawing of its own, like the memory calls, gets the same box with its name and arguments on top and its text under the cut.
+
 The strip above the editor is calm on purpose. Nothing moves while the model streams except the stopwatch.
 
 | Piece                                            | Means                                                                                                   |
 | ------------------------------------------------ | ------------------------------------------------------------------------------------------------------- |
 | `0:12  3 calls`                                  | How long the agent has worked on this prompt, and how many calls to the model it made                   |
 | `last call 1.7s wait  900ms thought  ↓906 tok/s` | The last call: how long the model took to start, how long it thought then wrote, and how fast it writes |
+| `answered in 0:47  2 calls  $0.31`               | Once the run ends: how long it took, how many calls to the model, and what it cost                      |
 
 The border around the editor carries the branch with its distance and changes, the folder, the permission mode, the model with an effort meter, and the context. It takes pi's own effort colour, so it warms up as the model thinks harder and turns to the shell colour in bash mode.
 
 The spinner names the state instead of saying "Working": `waiting` for the first token, `thinking`, `writing`, `drafting bash` while the model writes the call, `running bash` while it runs.
 
-The footer is the session: the cost, the tokens sent and received, the cache of the last prompt, the average speeds, and last what other packages report, because that changes the most.
+Your messages sit in a frame like the tool calls', in the accent colour and named `you`, without pi's background or the blank rows above and below the text. `look.userFrame` turns it off.
+
+The start card shows the π, the folder, the branch and the model, and under them only what changed or waits on you since your last session in the folder: an account that needs a sign-in, files in conflict, a branch behind its remote, a failed CI run on the branch, a pull request of yours with changes requested or a new comment, other agents working there, a plan past 70%, a new harness version. On a quiet day it says nothing is new, and its bottom edge reads `ready when you are`. GitHub is asked once per launch, in the background, so the card never waits on it: those two lines appear when the answers arrive, and a missing `gh`, no network or a folder that is not on GitHub leaves them out. The π rises from its feet once per launch. With pi's `quietStartup` on `header`, which the harness sets, pi's list of everything it loaded stays out of the way.
+
+The mark of a phase that lasts moves: a clock goes round its hours while a call runs, the hourglass flows while it waits on you, and the pencil fills with ink and empties while the model writes the call, in its own cell. With the Unicode icons a quarter circle goes round and the pencil tilts as it writes instead, and with ASCII a line spins. The mark stands still once the call ends.
+
+Pi's own entries sit in the same frame as the tool calls: compactions and branch summaries under `π`, skills, `!` commands with a cut between the command and what it printed, and the messages of extensions that bring no renderer of their own. The messages you send while the agent works wait above the editor in a dashed frame, each marked `steer` (between the agent's calls) or `next` (after its run), with the key that takes them back to the editor in the bottom edge.
+
+While the model writes an `edit` or a `write`, its frame shows the end of what has arrived, with a cursor where the model is writing. A write shows its last 8 lines with their numbers, and says whether it makes a new file or how many lines it replaces. An edit shows the lines it takes out and puts in. The lines it repeats around the change stay as context. The bottom rule counts the lines and the size, or the edits and the lines changed. Once the call is written, pi's own view takes over, with the diff read from the file.
+
+The footer is the session, each number with its word: the cost, the tokens sent and received, how much of the last prompt was cached, the average speeds, the plan's windows with when they reset, and last what other packages report, because that changes the most.
+
+`Alt+O` opens the session's tool output in a frame you scroll, one call at a time, newest first. The arrows up and down scroll it, left and right move to older and newer calls, and the bottom edge says which lines you are on. Pi shows a long output cut in the transcript, and `Ctrl+O` opens every call at once.
 
 ## It holds still
 
@@ -67,7 +81,7 @@ The look never names a colour. Every piece names a theme token, so it follows wh
 
 ## Settings
 
-`Alt+S` opens them on the Look tab. You can reorder every piece of the strip, the frame and the footer, pick the frame style, the icons and the separator, and switch off what you do not want. The [reference](docs/reference.md#settings) lists every key and every segment.
+`Alt+S` opens them on the Look tab. The look is opinionated, so three things are yours: the icons (Nerd Font, Unicode or ASCII, which depend on your terminal's font), the style of the editor's frame, and whether your messages sit in a frame. Each shows a preview of what it changes as you pick it. The [reference](docs/reference.md#settings) lists them.
 
 The framed editor, and the idea of writing into its borders, come from [pi-open-tui](https://github.com/OldSuns/pi-open-tui), which this replaces. The segments with priorities come from [oh-my-pi](https://github.com/can1357/oh-my-pi).
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@adeildo/pi-look",
-	"version": "5.9.2",
+	"version": "5.10.0",
 	"description": "Pi's start screen, a framed editor and the footer, redrawn around the data that matters and painted only with the theme's colours.",
 	"keywords": [
 		"pi",
@@ -38,7 +38,7 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@adeildo/pi-kit": "5.9.2"
+		"@adeildo/pi-kit": "5.10.0"
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-ai": "*",

package/src/data/git.ts

@@ -1,4 +1,4 @@
-import { execFile } from "node:child_process";
+import { processRunner, type Runner } from "./runner.ts";
 
 export interface GitState {
 	ahead: number;
@@ -40,13 +40,16 @@ export function parseStatus(output: string): GitState {
 	return state;
 }
 
-export function readGit(cwd: string): Promise<GitState | undefined> {
-	return new Promise((resolve) => {
-		execFile(
-			"git",
-			["-C", cwd, "status", "--porcelain=v2", "--branch", "--show-stash"],
-			{ timeout: 2000 },
-			(error, stdout) => resolve(error === null ? parseStatus(stdout) : undefined),
+export async function readGit(
+	cwd: string,
+	run: Runner = processRunner(cwd, 2000),
+): Promise<GitState | undefined> {
+	try {
+		return parseStatus(
+			await run("git", ["-C", cwd, "status", "--porcelain=v2", "--branch", "--show-stash"]),
 		);
-	});
+	} catch {
+		// A folder that is not a repository, or a git that did not answer: the card says nothing.
+		return undefined;
+	}
 }

package/src/data/github.ts

@@ -0,0 +1,141 @@
+// The answers GitHub gives the start card: the last run of CI on this branch, and your own open pull
+// requests with something waiting on you. The card asks once per launch, in the background, and shows
+// nothing when gh is missing, the network is down, or the folder is not on GitHub.
+import { isObject } from "@adeildo/pi-kit";
+
+import { processRunner, type Runner } from "./runner.ts";
+
+/** The conclusions that mean a run did not pass. */
+const FAILED = new Set(["failure", "startup_failure", "timed_out"]);
+/** What gh is asked about a pull request: enough to tell a new comment from an old one. */
+const PR_FIELDS = "number,title,author,reviewDecision,comments";
+
+export interface CiFailure {
+	branch: string;
+	/** The failing commit, short enough to read. */
+	sha: string;
+	/** The workflow that failed. */
+	name: string;
+}
+
+export interface OpenPullRequest {
+	number: number;
+	title: string;
+	/** What waits on you there. */
+	waits: "changes requested" | "new comment";
+}
+
+export interface GithubState {
+	ci: CiFailure | undefined;
+	pr: OpenPullRequest | undefined;
+}
+
+/**
+ * What GitHub knows about this folder. It never rejects: every question that cannot be answered
+ * leaves its note out. `since` is the last session in the folder, the bar for a comment to be news.
+ */
+export async function readGithub(
+	cwd: string,
+	since: number | undefined,
+	run: Runner = processRunner(cwd),
+): Promise<GithubState> {
+	const [branch, pr] = await Promise.all([branchOf(run), pullRequest(run, since)]);
+	const ci = branch === undefined ? undefined : await failedRun(run, branch);
+	return { ci, pr };
+}
+
+async function branchOf(run: Runner): Promise<string | undefined> {
+	const branch = (await ask(() => run("git", ["branch", "--show-current"])))?.trim();
+	return branch === undefined || branch === "" ? undefined : branch;
+}
+
+/** The last run of CI on the branch, when it failed. */
+async function failedRun(run: Runner, branch: string): Promise<CiFailure | undefined> {
+	const out = await ask(() =>
+		run("gh", [
+			"run",
+			"list",
+			"--branch",
+			branch,
+			"--limit",
+			"1",
+			"--json",
+			"conclusion,headSha,name,displayTitle",
+		]),
+	);
+	const [last] = rows(out);
+	if (last === undefined) return undefined;
+	const conclusion = field(last, "conclusion");
+	if (conclusion === undefined || !FAILED.has(conclusion)) return undefined;
+	return {
+		branch,
+		sha: (field(last, "headSha") ?? "").slice(0, 7),
+		name: field(last, "name") ?? field(last, "displayTitle") ?? "CI",
+	};
+}
+
+/** The first of your open pull requests, newest first, with a review or a comment waiting on you. */
+async function pullRequest(
+	run: Runner,
+	since: number | undefined,
+): Promise<OpenPullRequest | undefined> {
+	const out = await ask(() =>
+		run("gh", ["pr", "list", "--author", "@me", "--limit", "10", "--json", PR_FIELDS]),
+	);
+	for (const pr of rows(out)) {
+		const number = numberOf(pr);
+		const title = field(pr, "title");
+		if (number === undefined || title === undefined) continue;
+		if (field(pr, "reviewDecision") === "CHANGES_REQUESTED")
+			return { number, title, waits: "changes requested" };
+		if (hasNewComment(pr, since)) return { number, title, waits: "new comment" };
+	}
+	return undefined;
+}
+
+function hasNewComment(pr: Record<string, unknown>, since: number | undefined): boolean {
+	if (since === undefined) return false;
+	const me = loginOf(pr["author"]);
+	const comments = pr["comments"];
+	if (!Array.isArray(comments)) return false;
+	return comments.some((comment) => {
+		if (!isObject(comment)) return false;
+		const at = Date.parse(field(comment, "createdAt") ?? "");
+		const login = loginOf(comment["author"]);
+		return Number.isFinite(at) && at > since && login !== undefined && login !== me;
+	});
+}
+
+function loginOf(value: unknown): string | undefined {
+	return isObject(value) ? field(value, "login") : undefined;
+}
+
+/** The stdout of a question that could not be asked is no answer at all. */
+async function ask(question: () => Promise<string>): Promise<string | undefined> {
+	try {
+		return await question();
+	} catch {
+		return undefined;
+	}
+}
+
+function rows(out: string | undefined): Record<string, unknown>[] {
+	if (out === undefined) return [];
+	let value: unknown;
+	try {
+		value = JSON.parse(out);
+	} catch {
+		return [];
+	}
+	return Array.isArray(value) ? value.filter(isObject) : [];
+}
+
+function field(row: Record<string, unknown>, key: string): string | undefined {
+	const value = row[key];
+	return typeof value === "string" && value !== "" ? value : undefined;
+}
+
+function numberOf(pr: Record<string, unknown>): number | undefined {
+	const value = pr["number"];
+	return typeof value === "number" && Number.isInteger(value) ? value : undefined;
+}

package/src/data/runner.ts

@@ -0,0 +1,25 @@
+import { execFile } from "node:child_process";
+
+/** How long one command may take before it is given up on. The start card is never worth a longer wait. */
+const TIMEOUT_MS = 3000;
+/** Room for a page of an answer, like your open pull requests with their comments. Node's own
+ * default, so a command that answered before keeps answering. */
+const MAX_OUTPUT = 1024 * 1024;
+
+/** Runs one command in the folder and returns its stdout. Rejects when it fails or takes too long. */
+export type Runner = (file: string, args: readonly string[]) => Promise<string>;
+
+export function processRunner(cwd: string, timeoutMs: number = TIMEOUT_MS): Runner {
+	return (file, args) =>
+		new Promise((resolve, reject) => {
+			execFile(
+				file,
+				[...args],
+				{ cwd, timeout: timeoutMs, maxBuffer: MAX_OUTPUT },
+				(error, stdout) => {
+					if (error === null) resolve(stdout);
+					else reject(error instanceof Error ? error : new Error(String(error)));
+				},
+			);
+		});
+}

package/src/data/snapshot.ts

@@ -104,6 +104,7 @@ interface Derived {
 	cacheHit: number | undefined;
 	cacheWarming: boolean;
 	averages: Averages;
+	context: ContextInfo | undefined;
 }
 
 export class SnapshotReader {
@@ -134,7 +135,6 @@ export class SnapshotReader {
 						},
 			thinking: ctx.thinkingLevel,
 			account: live.account,
-			context: contextOf(ctx),
 			...derived,
 			subscription: model === undefined ? false : ctx.modelRegistry.isUsingOAuth(model),
 			request: live.request,
@@ -153,8 +153,10 @@ export class SnapshotReader {
 	}
 
 	#derive(ctx: ExtensionContext): Derived {
-		// Every entry is appended at the leaf, so the leaf moving is the only way the sums change.
-		const key = ctx.sessionManager.getLeafId() ?? "";
+		// Every entry is appended at the leaf, so the leaf moving is the only way the sums change. The
+		// context also depends on the model's window. Pi counts it over the whole branch, which is too
+		// slow to do on every keystroke.
+		const key = `${ctx.sessionManager.getLeafId() ?? ""}\u0000${ctx.model?.provider}/${ctx.model?.id}`;
 		if (this.#derived !== undefined && key === this.#key) return this.#derived;
 
 		const entries: readonly SessionEntry[] = ctx.sessionManager.getBranch();
@@ -164,6 +166,7 @@ export class SnapshotReader {
 			cacheHit: cacheHitPercent(entries),
 			cacheWarming: cacheWarming(entries),
 			averages: averagesOf(entries),
+			context: contextOf(ctx),
 		};
 		return this.#derived;
 	}

package/src/data/start-notes.ts

@@ -0,0 +1,108 @@
+// What the start screen says under the folder and the model: only what changed or waits on you since
+// the last session here. On a quiet day the list is empty and the screen says so in one line.
+import { formatClock, GLYPH } from "@adeildo/pi-kit";
+
+import type { GithubState } from "./github.ts";
+import type { Snapshot } from "./snapshot.ts";
+
+/** Plans used past this percent show on the start screen. */
+const PLAN_LIMIT = 70;
+
+/** The last session in this folder, as the start screen remembers it. */
+export interface LastVisit {
+	at: number;
+	version: string;
+}
+
+export interface StartNote {
+	mark: string;
+	/** A theme color for the mark. */
+	color: string;
+	text: string;
+	detail?: string;
+}
+
+export function startNotes(
+	snapshot: Pick<Snapshot, "peers" | "account" | "git" | "branch">,
+	version: string,
+	last: LastVisit | undefined,
+	github?: GithubState,
+): StartNote[] {
+	const notes: StartNote[] = [];
+	const { account, git } = snapshot;
+
+	if (account?.needsLogin === true)
+		notes.push({
+			mark: GLYPH.cross,
+			color: "error",
+			text: `${account.label} needs a sign-in`,
+			detail: "/accounts",
+		});
+	if (git !== undefined && git.conflicted > 0)
+		notes.push({ mark: GLYPH.cross, color: "error", text: `${git.conflicted} files in conflict` });
+	if (git !== undefined && git.behind > 0)
+		notes.push({
+			mark: GLYPH.down,
+			color: "warning",
+			text: `${snapshot.branch ?? "this branch"} is ${git.behind} behind`,
+			detail: "pull before you start",
+		});
+	if (github?.ci !== undefined)
+		notes.push({
+			mark: GLYPH.cross,
+			color: "error",
+			text: `CI failed on ${github.ci.branch}`,
+			detail: `${github.ci.sha}  ${github.ci.name}`,
+		});
+	if (github?.pr !== undefined)
+		notes.push({
+			mark: GLYPH.flag,
+			color: "warning",
+			text: `PR #${github.pr.number} ${github.pr.title}`,
+			detail: github.pr.waits,
+		});
+	for (const peer of snapshot.peers)
+		notes.push({
+			mark: GLYPH.diamond,
+			color: peer.color,
+			text: `@${peer.handle}`,
+			detail: peerState(peer.state),
+		});
+	for (const window of account?.windows ?? []) {
+		if (window.used < PLAN_LIMIT) continue;
+		notes.push({
+			mark: GLYPH.up,
+			color: window.used >= 90 ? "error" : "warning",
+			text: `${window.name} at ${Math.round(window.used)}%`,
+			detail: window.resetsIn === undefined ? undefined : `resets in ${window.resetsIn}`,
+		});
+	}
+	if (last !== undefined && last.version !== version)
+		notes.push({
+			mark: GLYPH.up,
+			color: "accent",
+			text: `${GLYPH.pi}-harness ${version} is new`,
+			detail: `was ${last.version}`,
+		});
+	return notes;
+}
+
+function peerState(state: "running" | "idle" | "waiting"): string {
+	switch (state) {
+		case "running":
+			return "works here";
+		case "waiting":
+			return "waits for you";
+		case "idle":
+			return "is open here";
+	}
+}
+
+/** Local time, hours and minutes, or the day when it was not today. */
+export function since(at: number, now: number): string {
+	const then = new Date(at);
+	const time = formatClock(at);
+	if (new Date(now).toDateString() === then.toDateString()) return time;
+	const days = Math.round((now - at) / 86_400_000);
+	return days <= 1 ? `yesterday ${time}` : `${days} days ago`;
+}

package/src/data/telemetry.ts

@@ -38,6 +38,8 @@ export interface RunView {
 	running: boolean;
 	elapsedMs: number;
 	requests: number;
+	/** What the run's answers cost so far, at the provider's prices. */
+	cost: number;
 }
 
 interface Request {
@@ -56,6 +58,7 @@ interface Run {
 	startedAt: number;
 	endedAt: number | undefined;
 	requests: number;
+	cost: number;
 }
 
 interface UsageLike {
@@ -86,7 +89,7 @@ export class Telemetry {
 	}
 
 	runStarted(): void {
-		this.#run = { startedAt: this.#now(), endedAt: undefined, requests: 0 };
+		this.#run = { startedAt: this.#now(), endedAt: undefined, requests: 0, cost: 0 };
 	}
 
 	runEnded(): void {
@@ -137,6 +140,7 @@ export class Telemetry {
 		const now = this.#now();
 		request.endedAt = now;
 		request.usage = usageTotals(usage);
+		if (this.#run !== undefined) this.#run.cost += usage.cost.total;
 		if (request.usage.output === 0 && request.firstTokenAt === undefined) return undefined;
 
 		if (request.characters > 0 && request.usage.output > 0) {
@@ -172,6 +176,7 @@ export class Telemetry {
 			running,
 			elapsedMs: (run.endedAt ?? this.#now()) - run.startedAt,
 			requests: run.requests,
+			cost: run.cost,
 		};
 	}
 

package/src/data/totals.ts

@@ -68,25 +68,26 @@ export function totalsOf(entries: readonly SessionEntry[]): Totals {
 	return totals;
 }
 
-export function cacheHitPercent(entries: readonly SessionEntry[]): number | undefined {
+/** The usage of the last answer the model gave, which is what the cache lines talk about. */
+function lastAssistantUsage(entries: readonly SessionEntry[]): UsageLike | undefined {
 	for (let index = entries.length - 1; index >= 0; index--) {
 		const entry = entries[index];
 		if (entry?.type !== "message" || entry.message.role !== "assistant") continue;
-
-		const usage = entry.message.usage;
-		const prompt = usage.input + usage.cacheRead + usage.cacheWrite;
-		return prompt === 0 ? undefined : (usage.cacheRead / prompt) * 100;
+		return entry.message.usage;
 	}
 	return undefined;
 }
 
+export function cacheHitPercent(entries: readonly SessionEntry[]): number | undefined {
+	const usage = lastAssistantUsage(entries);
+	if (usage === undefined) return undefined;
+	const prompt = usage.input + usage.cacheRead + usage.cacheWrite;
+	return prompt === 0 ? undefined : (usage.cacheRead / prompt) * 100;
+}
+
 export function cacheWarming(entries: readonly SessionEntry[]): boolean {
-	for (let index = entries.length - 1; index >= 0; index--) {
-		const entry = entries[index];
-		if (entry?.type !== "message" || entry.message.role !== "assistant") continue;
-		return entry.message.usage.cacheRead === 0 && entry.message.usage.cacheWrite > 0;
-	}
-	return false;
+	const usage = lastAssistantUsage(entries);
+	return usage !== undefined && usage.cacheRead === 0 && usage.cacheWrite > 0;
 }
 
 export function averagesOf(entries: readonly SessionEntry[]): Averages {

package/src/data/visits.ts

@@ -0,0 +1,38 @@
+// The start screen says what changed since the last session in a folder, so it remembers when that
+// was and which harness version ran it. One small file for every folder.
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+import { isObject } from "@adeildo/pi-kit";
+
+import type { LastVisit } from "./start-notes.ts";
+
+type Visits = Record<string, LastVisit>;
+
+/** The last visit to `cwd`, and records this one. */
+export function visit(
+	file: string,
+	cwd: string,
+	version: string,
+	now: number,
+): LastVisit | undefined {
+	const visits = read(file);
+	const last = visits[cwd];
+	visits[cwd] = { at: now, version };
+	try {
+		mkdirSync(dirname(file), { recursive: true });
+		writeFileSync(file, JSON.stringify(visits));
+	} catch {
+		// A start screen that cannot remember only loses "since when".
+	}
+	return last;
+}
+
+function read(file: string): Visits {
+	try {
+		const value = JSON.parse(readFileSync(file, "utf8")) as unknown;
+		return isObject(value) ? (value as Visits) : {};
+	} catch {
+		return {};
+	}
+}