@huseynsnmz/pi-suite 0.0.0-stage → 0.1.0

package/packages/frame/src/data/github.ts

@@ -0,0 +1,140 @@
+// CI's last run on this branch and your open pull requests that wait on you, asked once per launch.
+// Shows nothing without the forge's tool, network or a remote it serves, and starts only that tool.
+import { isObject } from "@adeildo/pi-kit";
+
+import { gitlabHosts, glabMayStart, readGitlab } from "./gitlab.ts";
+import { processRunner, type Runner } from "./runner.ts";
+
+const FAILED = new Set(["failure", "startup_failure", "timed_out"]);
+/** Enough to tell a new comment from an old one. */
+const PR_FIELDS = "number,title,author,reviewDecision,comments";
+/** github.com, or an enterprise host like github.acme.dev. */
+const GITHUB_REMOTE = /(?:@|\/\/)(?:[\w-]+\.)*github\.[\w.-]+[:/]/i;
+
+interface CiFailure {
+	branch: string;
+	sha: string;
+	name: string;
+}
+
+interface OpenPullRequest {
+	number: number;
+	title: string;
+	waits: "changes requested" | "new comment" | "open threads";
+	/** How the forge names it. `PR #52` when unset. */
+	ref?: string;
+}
+
+export interface GithubState {
+	ci: CiFailure | undefined;
+	pr: OpenPullRequest | undefined;
+}
+
+/** Never rejects. `since` is the last session here, the bar for a comment to be news. */
+export async function readGithub(
+	cwd: string,
+	since: number | undefined,
+	run: Runner = processRunner(cwd),
+): Promise<GithubState> {
+	const remotes = (await ask(() => run("git", ["remote", "-v"]))) ?? "";
+	if (!GITHUB_REMOTE.test(remotes)) {
+		const hosts = gitlabHosts(remotes);
+		return glabMayStart(hosts) ? readGitlab(run, await branchOf(run)) : { ci: undefined, pr: undefined };
+	}
+	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;
+}
+
+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",
+	};
+}
+
+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;
+}
+
+export async function ask(question: () => Promise<string>): Promise<string | undefined> {
+	try {
+		return await question();
+	} catch {
+		return undefined;
+	}
+}
+
+export 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) : [];
+}
+
+export function field(row: Record<string, unknown>, key: string): string | undefined {
+	const value = row[key];
+	return typeof value === "string" && value !== "" ? value : undefined;
+}
+
+export function numberOf(pr: Record<string, unknown>, key = "number"): number | undefined {
+	const value = pr[key];
+	return typeof value === "number" && Number.isInteger(value) ? value : undefined;
+}

package/packages/frame/src/data/gitlab.ts

@@ -0,0 +1,63 @@
+// The GitLab version of github.ts: the branch's last pipeline, and your merge requests that wait on you.
+// glab sends a token from the environment to whichever host it is pointed at, and the repository
+// chooses that host, so with such a token it starts only for gitlab.com or GITLAB_HOST.
+import { ask, field, type GithubState, numberOf, rows } from "./github.ts";
+import type { Runner } from "./runner.ts";
+
+/** gitlab.com, or a self-hosted name like gitlab.acme.dev. */
+const GITLAB_HOST = /(?:@|\/\/)((?:[\w-]+\.)*gitlab\.[\w.-]+)[:/]/gi;
+const TOKENS = ["GITLAB_TOKEN", "GITLAB_ACCESS_TOKEN", "OAUTH_TOKEN"];
+const WAITS = {
+	requested_changes: "changes requested",
+	discussions_not_resolved: "open threads",
+} as const;
+
+export function gitlabHosts(remotes: string): string[] {
+	return [...remotes.matchAll(GITLAB_HOST)].map((match) => (match[1] ?? "").toLowerCase());
+}
+
+export function glabMayStart(
+	hosts: readonly string[],
+	env: Readonly<Record<string, string | undefined>> = process.env,
+): boolean {
+	if (hosts.length === 0) return false;
+	if (!TOKENS.some((name) => env[name])) return true;
+	const trusted = ["gitlab.com", env["GITLAB_HOST"]?.replace(/^https?:\/\//, "").toLowerCase()];
+	return hosts.every((host) => trusted.includes(host));
+}
+
+/** Never rejects. */
+export async function readGitlab(run: Runner, branch: string | undefined): Promise<GithubState> {
+	const [ci, pr] = await Promise.all([
+		branch === undefined ? undefined : failedPipeline(run, branch),
+		mergeRequest(run),
+	]);
+	return { ci, pr };
+}
+
+async function failedPipeline(run: Runner, branch: string): Promise<GithubState["ci"]> {
+	const out = await ask(() =>
+		run("glab", ["ci", "list", "--ref", branch, "--per-page", "1", "--output", "json"]),
+	);
+	const [last] = rows(out);
+	if (last === undefined || field(last, "status") !== "failed") return undefined;
+	return {
+		branch,
+		sha: (field(last, "sha") ?? "").slice(0, 7),
+		name: field(last, "name") ?? "pipeline",
+	};
+}
+
+async function mergeRequest(run: Runner): Promise<GithubState["pr"]> {
+	const out = await ask(() =>
+		run("glab", ["mr", "list", "--author", "@me", "--per-page", "10", "--output", "json"]),
+	);
+	for (const mr of rows(out)) {
+		const number = numberOf(mr, "iid");
+		const title = field(mr, "title");
+		const waits = WAITS[field(mr, "detailed_merge_status") as keyof typeof WAITS];
+		if (number !== undefined && title !== undefined && waits !== undefined)
+			return { number, title, waits, ref: `MR !${number}` };
+	}
+	return undefined;
+}

package/packages/frame/src/data/mode.ts

@@ -0,0 +1,23 @@
+// The mode pi-modes reports. It only publishes a status, so the text is the contract.
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+
+const MODE_STATUS = "pi-modes";
+const REPORTED = /^mode: (normal|auto|plan|read-only|yolo)$/;
+
+type Mode = "normal" | "auto" | "plan" | "read-only" | "yolo";
+
+/** The same colors pi-modes gives the word. In `normal`, the frame stays pi's own. */
+const FRAME_COLORS = { auto: "warning", plan: "accent", "read-only": "success", yolo: "error" } as const;
+
+export function modeOf(statuses: ReadonlyMap<string, string>): Mode | undefined {
+	const status = statuses.get(MODE_STATUS);
+	if (status === undefined) return undefined;
+	return REPORTED.exec(stripTerminalSequences(status).trim())?.[1] as Mode | undefined;
+}
+
+export function frameColorOf(
+	statuses: ReadonlyMap<string, string>,
+): (typeof FRAME_COLORS)[keyof typeof FRAME_COLORS] | undefined {
+	const mode = modeOf(statuses);
+	return mode === undefined || mode === "normal" ? undefined : FRAME_COLORS[mode];
+}

package/packages/frame/src/data/past-prompts.ts

@@ -0,0 +1,57 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+const NEWEST_FILES = 20;
+const MAX_FILE_BYTES = 20 * 1024 * 1024;
+const MAX_PROMPTS = 1000;
+
+function promptOf(line: string): string | undefined {
+	if (!line.includes('"role":"user"')) return undefined;
+	try {
+		const entry = JSON.parse(line) as { type?: string; message?: { role?: string; content?: unknown } };
+		if (entry.type !== "message" || entry.message?.role !== "user") return undefined;
+		const content = entry.message.content;
+		if (typeof content === "string") return content.trim() || undefined;
+		if (!Array.isArray(content)) return undefined;
+		const text = content
+			.filter((part): part is { type: "text"; text: string } => part?.type === "text" && typeof part.text === "string")
+			.map((part) => part.text)
+			.join("\n")
+			.trim();
+		return text || undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** What was typed in this folder's recent sessions, newest first. A file it can't read is skipped. */
+export function pastPrompts(sessionDir: string): string[] {
+	const prompts: string[] = [];
+	let files: { path: string; modified: number; size: number }[] = [];
+	try {
+		files = readdirSync(sessionDir)
+			.filter((name) => name.endsWith(".jsonl"))
+			.map((name) => {
+				const path = join(sessionDir, name);
+				const { mtimeMs, size } = statSync(path);
+				return { path, modified: mtimeMs, size };
+			});
+	} catch {
+		return [];
+	}
+	files.sort((a, b) => b.modified - a.modified);
+	for (const { path, size } of files.slice(0, NEWEST_FILES)) {
+		if (size > MAX_FILE_BYTES || prompts.length >= MAX_PROMPTS) continue;
+		try {
+			const found: string[] = [];
+			for (const line of readFileSync(path, "utf8").split("\n")) {
+				const prompt = promptOf(line);
+				if (prompt) found.push(prompt);
+			}
+			prompts.push(...found.reverse());
+		} catch {
+			/* it may be gone, or still being written */
+		}
+	}
+	return prompts.slice(0, MAX_PROMPTS);
+}

package/packages/frame/src/data/runner.ts

@@ -0,0 +1,32 @@
+import { execFile } from "node:child_process";
+
+/** The start card is never worth a longer wait. */
+const TIMEOUT_MS = 3000;
+/** Room for a page of answers, like your open pull requests with their comments. */
+const MAX_OUTPUT = 1024 * 1024;
+
+/** No download for a partial clone, whose transport the repository's config chooses, and no prompt. */
+const QUIET_GIT = {
+	...process.env,
+	GIT_NO_LAZY_FETCH: "1",
+	GIT_TERMINAL_PROMPT: "0",
+	GLAB_CHECK_UPDATE: "false",
+};
+
+/** 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, env: QUIET_GIT },
+				(error, stdout) => {
+					if (error === null) resolve(stdout);
+					else reject(error instanceof Error ? error : new Error(String(error)));
+				},
+			);
+		});
+}

package/packages/frame/src/data/snapshot.ts

@@ -0,0 +1,223 @@
+import { hostname } from "node:os";
+
+import type { AccountState, Board, PeerMark, RoomMark, WritingMark } from "@adeildo/pi-kit";
+import { VERSION, type ExtensionContext, type SessionEntry } from "@earendil-works/pi-coding-agent";
+
+import { plainText } from "../render/safe.ts";
+
+import type { GitState } from "./git.ts";
+import type { RequestView, RunView } from "./telemetry.ts";
+import {
+	type Averages,
+	averagesOf,
+	cacheHitPercent,
+	cacheWarming,
+	emptyTotals,
+	type Totals,
+	totalsOf,
+} from "./totals.ts";
+
+interface ModelInfo {
+	name: string;
+	provider: string;
+	reasoning: boolean;
+}
+
+interface ContextInfo {
+	percent: number;
+	tokens: number;
+	window: number;
+}
+
+/** pi-sandbox sets this while it's on, and empties it when it goes off. */
+export const SANDBOX_STATUS = "sandbox";
+
+export interface Snapshot {
+	now: number;
+	cwd: string;
+	home: string | undefined;
+	branch: string | null;
+	git: GitState | undefined;
+	host: string | undefined;
+	sessionName: string | undefined;
+	/** The word the room calls this session by, in its color once it is in a room. */
+	me: { handle: string; color?: string } | undefined;
+	version: string;
+	model: ModelInfo | undefined;
+	account: AccountState | undefined;
+	thinking: string | undefined;
+	context: ContextInfo | undefined;
+	totals: Totals;
+	cacheHit: number | undefined;
+	cacheWarming: boolean;
+	subscription: boolean;
+	request: RequestView | undefined;
+	last: RequestView | undefined;
+	run: RunView | undefined;
+	averages: Averages;
+	statuses: ReadonlyMap<string, string>;
+	/** Whether pi-sandbox is confining commands. Undefined when it isn't installed. */
+	sandbox: "on" | "off" | undefined;
+	/** When a board feature keeps it. */
+	board: Board | undefined;
+	/** When a peers feature keeps them. */
+	peers: PeerMark[];
+	/** Empty when the peers feature publishes only `peers`. */
+	peersRooms: RoomMark[];
+	peersUnread: number;
+	peersWriting: WritingMark[];
+}
+
+export function emptySnapshot(): Snapshot {
+	return {
+		now: 0,
+		cwd: "",
+		home: undefined,
+		branch: null,
+		git: undefined,
+		host: undefined,
+		sessionName: undefined,
+		me: undefined,
+		version: VERSION,
+		model: undefined,
+		account: undefined,
+		thinking: undefined,
+		context: undefined,
+		totals: emptyTotals(),
+		cacheHit: undefined,
+		cacheWarming: false,
+		subscription: false,
+		request: undefined,
+		last: undefined,
+		run: undefined,
+		averages: { decode: undefined, prefill: undefined },
+		statuses: new Map(),
+		sandbox: undefined,
+		board: undefined,
+		peers: [],
+		peersRooms: [],
+		peersUnread: 0,
+		peersWriting: [],
+	};
+}
+
+export interface LiveInputs {
+	branch: string | null;
+	git: GitState | undefined;
+	account?: AccountState | undefined;
+	request: RequestView | undefined;
+	last: RequestView | undefined;
+	run: RunView | undefined;
+	statuses: ReadonlyMap<string, string>;
+	sandboxInstalled?: boolean;
+	board?: Board | undefined;
+	me?: { handle: string; color?: string } | undefined;
+	peers?: PeerMark[] | undefined;
+	peersRooms?: RoomMark[] | undefined;
+	peersUnread?: number | undefined;
+	peersWriting?: WritingMark[] | undefined;
+}
+
+interface Derived {
+	totals: Totals;
+	cacheHit: number | undefined;
+	cacheWarming: boolean;
+	averages: Averages;
+	context: ContextInfo | undefined;
+	answeredBy: string | undefined;
+}
+
+const VIRTUAL_API = "pi-virtual";
+
+export class SnapshotReader {
+	#key: string | undefined;
+	#derived: Derived | undefined;
+	readonly #host = hostname().split(".")[0];
+
+	read(ctx: ExtensionContext, live: LiveInputs): Snapshot {
+		const model = ctx.model;
+		const derived = this.#derive(ctx);
+
+		return {
+			now: Date.now(),
+			cwd: ctx.cwd,
+			home: process.env.HOME ?? process.env.USERPROFILE,
+			branch: live.branch,
+			git: live.git,
+			host: this.#host,
+			sessionName: ctx.sessionManager.getSessionName(),
+			me: live.me,
+			version: VERSION,
+			model:
+				model === undefined
+					? undefined
+					: {
+							name:
+								model.api === VIRTUAL_API && derived.answeredBy !== undefined
+									? `${model.name} \u2192 ${derived.answeredBy}`
+									: (model.name ?? model.id),
+							provider: ctx.modelRegistry.getProviderDisplayName(model.provider),
+							reasoning: model.reasoning,
+						},
+			thinking: ctx.thinkingLevel,
+			account: live.account,
+			...derived,
+			subscription: model === undefined ? false : ctx.modelRegistry.isUsingOAuth(model),
+			request: live.request,
+			last: live.last,
+			run: live.run,
+			statuses: new Map(
+				[...live.statuses.entries()]
+					.toSorted(([a], [b]) => a.localeCompare(b))
+					.map(([key, text]): [string, string] => [key, sanitize(text)])
+					.filter(([, text]) => text !== ""),
+			),
+			sandbox: !live.sandboxInstalled ? undefined : live.statuses.get(SANDBOX_STATUS) ? "on" : "off",
+			board: live.board,
+			peers: live.peers ?? [],
+			peersRooms: live.peersRooms ?? [],
+			peersUnread: live.peersUnread ?? 0,
+			peersWriting: live.peersWriting ?? [],
+		};
+	}
+
+	#derive(ctx: ExtensionContext): Derived {
+		// Entries are appended at the leaf, so the sums change only when the leaf or the model does.
+		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();
+		this.#key = key;
+		this.#derived = {
+			totals: totalsOf(entries),
+			cacheHit: cacheHitPercent(entries),
+			cacheWarming: cacheWarming(entries),
+			averages: averagesOf(entries),
+			context: contextOf(ctx),
+			answeredBy: answeredBy(ctx, entries),
+		};
+		return this.#derived;
+	}
+}
+
+/** A virtual model only says what was selected. The latest answer says which model it chose. */
+function answeredBy(ctx: ExtensionContext, entries: readonly SessionEntry[]): string | undefined {
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const entry = entries[index];
+		if (entry?.type !== "message" || entry.message.role !== "assistant") continue;
+		if (entry.message.stopReason === "error" || entry.message.stopReason === "aborted") continue;
+		const { provider, model } = entry.message;
+		return plainText(ctx.modelRegistry.find(provider, model)?.name ?? model).replace(/\s+/g, " ");
+	}
+	return undefined;
+}
+
+function contextOf(ctx: ExtensionContext): ContextInfo | undefined {
+	const usage = ctx.getContextUsage();
+	if (usage === undefined || usage.percent === null || usage.tokens === null) return undefined;
+	return { percent: usage.percent, tokens: usage.tokens, window: usage.contextWindow };
+}
+
+function sanitize(text: string): string {
+	return text.replace(/[\r\n\t]+/g, " ").trim();
+}

package/packages/frame/src/data/start-notes.ts

@@ -0,0 +1,104 @@
+// Under the folder and the model, only what changed or waits on you since the last session here.
+import { formatClock, GLYPH } from "@adeildo/pi-kit";
+
+import type { GithubState } from "./github.ts";
+import type { Snapshot } from "./snapshot.ts";
+
+const PLAN_LIMIT = 70;
+
+export interface LastVisit {
+	at: number;
+	version: string;
+}
+
+export interface StartNote {
+	mark: string;
+	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: `${github.pr.ref ?? `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}-frame ${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, 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`;
+}