@huseynsnmz/pi-suite 0.0.0-stage → 0.2.0

package/packages/frame/docs/reference.md

@@ -0,0 +1,78 @@
+# Reference
+
+Everything the [README](../README.md) leaves out: the colours, every setting and segment, and how a line fits.
+
+## Colours
+
+pi-frame never names a colour. Every piece names a **theme token**, so it follows whatever theme pi runs: `system`, `dark`, `light`, or a JSON of yours. Change the theme and every piece moves with it.
+
+| What                                          | Token                                                       |
+| --------------------------------------------- | ----------------------------------------------------------- |
+| Folder                                        | `accent`                                                    |
+| Branch                                        | `syntaxFunction`                                            |
+| Ahead, staged / behind, modified / conflicted | `success` / `warning` / `error`                             |
+| Machine, cache                                | `syntaxType`                                                |
+| Session name                                  | `mdHeading`                                                 |
+| Provider, model icon                          | `syntaxKeyword`                                             |
+| Model                                         | `text`, bold                                                |
+| Sent `↑`                                      | `mdLink`                                                    |
+| Received `↓`, speeds, done                    | `success`                                                   |
+| Time to first token, money                    | `syntaxNumber`, then `warning` past $1 and `error` past $10 |
+| Context                                       | `success`, `warning` past 70%, `error` past 90%             |
+| Effort level, the π                           | `thinkingMinimal` … `thinkingMax`, one per level            |
+| Labels, units, separators                     | `dim`                                                       |
+| Editor frame                                  | pi's effort border colour; with pi-modes, `warning` in auto, `accent` in plan, `success` in read-only |
+
+Syntax tokens are borrowed on purpose: a theme spends its hues there, so they give the line variety that stays in the theme's family. The table lives in `src/render/paint.ts` as `ROLE_TOKENS`, and a test fails if any entry is ever a colour instead of a token.
+
+## Settings
+
+They live in the file `@adeildo/pi-kit` keeps, `~/.pi/agent/extensions/pi-harness/settings.json`, under `frame.`.
+
+| Key           | Default     | Does                                                                                                                                   |
+| ------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------- |
+| `icons`       | `"auto"`    | `nerd`, `unicode` or `ascii`. Auto uses plain Unicode, or ASCII without UTF-8 |
+| `style`       | `"rounded"` | `rounded`, `square`, `heavy` or `line` (pi's two rules, written into)                                                                  |
+| `userFrame`   | `true`      | Your messages in a frame named `you`. Off, pi draws them its own way                                                                   |
+
+The rest is fixed. The line above the editor shows `elapsed` and `last`, with `board` on its right. The frame shows `branch` and `session` at the top left, `path` and `host` at the top right, the permission mode, `model` and `effort` at the bottom left, and `context` at the bottom right. The line below the editor shows `cost`, `tokens`, `cache`, `average` and `statuses`, with `quota` on its right. Every number has its word.
+
+### Segments
+
+What each piece of the screen shows.
+
+| Id             | Shows                                                                                                                                                                               |
+| -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `path`         | The working folder, with home as `~`                                                                                                                                                |
+| `branch`       | The branch, ahead `↑` and behind `↓`, staged `+`, modified `~`, untracked `?`, conflicts `!`, stashes                                                                               |
+| `host`         | The machine, so a pasted line says where it came from                                                                                                                               |
+| `session`      | The session name, once it has one                                                                                                                                                   |
+| `board`        | The card being done (`+1` when there are more), then how many open cards are blocked (`⚑ 1`, in yellow), are to do (`⧗ 3`) and are done (`✓ 2`, in green), from the session's board |
+| `version`      | The pi version                                                                                                                                                                      |
+| `clock`        | The time                                                                                                                                                                            |
+| `model`        | `provider/model`, with the account in parentheses when one is in use                                                                                                                |
+| `provider`     | The provider on its own                                                                                                                                                             |
+| `quota`        | Every window of the plan, with its percent and its reset                                                                                                                            |
+| `effort`       | A divider and the effort level. Hidden for models that do not reason                                                                                                                    |
+| `context`      | Context used, the gauge, tokens over the window                                                                                                                                     |
+| `speed`        | This answer's speeds, received `↓` and sent `↑`                                                                                                                                     |
+| `wait`         | Time to the first token                                                                                                                                                             |
+| `server`       | The last call's time from the request leaving to the response headers                                                                                                               |
+| `elapsed`      | The agent's working time, as a stopwatch, and its calls                                                                                                                             |
+| `last`         | The last finished call: its wait, its thought time and its writing speed                                                                                                            |
+| `request`      | This answer's tokens, with the cache                                                                                                                                                |
+| `costRate`     | This answer's cost per million tokens                                                                                                                                               |
+| `cost`         | The session's cost                                                                                                                                                                  |
+| `tokens`       | The session's tokens, with the cache                                                                                                                                                |
+| `cache`        | The cache hit of the last prompt                                                                                                                                                    |
+| `average`      | The session's average speeds, both ways                                                                                                                                             |
+| `statuses`     | The mode and sandbox state first, then what other packages report through `setStatus`, minus the ones placed on their own                                                                                                  |
+| `status:<key>` | One package's status, by the key it passes to `setStatus`                                                                                                                           |
+
+A `status:<key>` segment is how a package gets a place of its own. [`@adeildo/pi-ask-permission`](../ask-permission) reports its mode as `pi-ask-permission:mode`, and the mode says what happens to what you type, so by default it sits in the frame next to the model instead of in the footer with everything else. `@adeildo/pi-providers` still reports its account as `pi-providers:account`, but the `model` segment draws it in parentheses, so the statuses segment skips it.
+
+## How it fits
+
+When a line runs out of room, the least important pieces take their short form first (the folder becomes its last part, the model loses its provider, the effort meter loses its label), and then leave, one at a time. The two sides of a border compete for the same width, so an unimportant piece on the right leaves before an important one on the left. A line never goes empty: the last piece stays and is cut.
+
+The frame is the editor pi already has. Typing, history, autocomplete and every app key stay pi's; the class only changes what the lines look like and shifts mouse clicks by the width of the frame. The spinner is pi's, embedded through pi's own hook, and the working line only speaks through `setWorkingMessage`.

package/packages/frame/package.json

@@ -0,0 +1,72 @@
+{
+	"name": "@huseynsnmz/pi-frame",
+	"version": "0.5.0",
+	"description": "Pi's start screen, a framed editor, a box around every tool call and a session footer. A fork of @adeildo/pi-look.",
+	"keywords": [
+		"pi",
+		"pi-coding-agent",
+		"pi-extension",
+		"pi-package",
+		"statusline",
+		"theme",
+		"tui"
+	],
+	"license": "MIT",
+	"author": {
+		"name": "Hüseyin Sönmez",
+		"email": "huseyin@snmz.org",
+		"url": "https://github.com/huseynsnmz"
+	},
+	"contributors": [
+		{
+			"name": "adeildo",
+			"url": "https://github.com/felipeadeildo"
+		}
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/huseynsnmz/pi-suite.git",
+		"directory": "packages/frame"
+	},
+	"files": [
+		"src",
+		"docs",
+		"README.md",
+		"CHANGELOG.md",
+		"LICENSE"
+	],
+	"type": "module",
+	"exports": {
+		".": "./src/index.ts"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"check": "tsc --noEmit",
+		"test": "bun test",
+		"e2e": "python3 test/e2e/run.py"
+	},
+	"dependencies": {},
+	"peerDependencies": {
+		"@earendil-works/pi-ai": "*",
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*",
+		"typebox": "*"
+	},
+	"devDependencies": {
+		"@earendil-works/pi-ai": "1.5.0",
+		"@earendil-works/pi-coding-agent": "1.5.0",
+		"@earendil-works/pi-tui": "1.5.0",
+		"@types/bun": "1.4.4",
+		"@types/node": "26.6.6",
+		"typebox": "1.4.3",
+		"typescript": "7.0.2"
+	},
+	"pi": {
+		"extensions": [
+			"./src/index.ts"
+		]
+	},
+	"private": true
+}

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

@@ -0,0 +1,90 @@
+import { processRunner, type Runner } from "./runner.ts";
+
+export interface GitState {
+	ahead: number;
+	behind: number;
+	staged: number;
+	modified: number;
+	untracked: number;
+	conflicted: number;
+	stashed: number;
+}
+
+export function emptyGit(): GitState {
+	return { ahead: 0, behind: 0, staged: 0, modified: 0, untracked: 0, conflicted: 0, stashed: 0 };
+}
+
+export function parseStatus(output: string): GitState {
+	const state = emptyGit();
+
+	for (const line of output.split("\n")) {
+		if (line.startsWith("# branch.ab ")) {
+			const [, , ahead, behind] = line.split(" ");
+			state.ahead = Math.abs(Number(ahead ?? "0")) || 0;
+			state.behind = Math.abs(Number(behind ?? "0")) || 0;
+		} else if (line.startsWith("# stash ")) {
+			state.stashed = Number(line.slice("# stash ".length)) || 0;
+		} else if (line.startsWith("1 ") || line.startsWith("2 ")) {
+			// `XY` is the index column, then the tree column, with `.` for unchanged.
+			const index = line[2];
+			const tree = line[3];
+			if (index !== undefined && index !== ".") state.staged++;
+			if (tree !== undefined && tree !== ".") state.modified++;
+		} else if (line.startsWith("u ")) {
+			state.conflicted++;
+		} else if (line.startsWith("? ")) {
+			state.untracked++;
+		}
+	}
+
+	return state;
+}
+
+/**
+ * `git status` runs after every tool call, outside any permission check, so nothing the repository
+ * configures may run through it: an agent can write `.git/config`, and a downloaded folder can bring one.
+ */
+const SAFE_STATUS = [
+	"-c",
+	"core.fsmonitor=false",
+	"-c",
+	"core.hooksPath=/dev/null",
+	"--no-optional-locks",
+];
+
+/** Keys and scopes separated by NUL, as `git config --show-scope --name-only --list -z` prints them. */
+export function hasRepoFilter(config: string): boolean {
+	const fields = config.split("\0");
+	for (let at = 0; at + 1 < fields.length; at += 2) {
+		const scope = fields[at];
+		if (scope !== "local" && scope !== "worktree") continue;
+		if (/^filter\..+\.(?:clean|smudge|process)$/is.test(fields[at + 1] ?? "")) return true;
+	}
+	return false;
+}
+
+export async function readGit(
+	cwd: string,
+	run: Runner = processRunner(cwd, 2000),
+): Promise<GitState | undefined> {
+	try {
+		// A filter's name is free, so no option can turn them all off.
+		const config = await run("git", ["-C", cwd, "config", "--show-scope", "--name-only", "--list", "-z"]);
+		if (hasRepoFilter(config)) return undefined;
+		return parseStatus(
+			await run("git", [
+				...SAFE_STATUS,
+				"-C",
+				cwd,
+				"status",
+				"--porcelain=v2",
+				"--branch",
+				"--show-stash",
+				"--ignore-submodules=all",
+			]),
+		);
+	} catch {
+		// Not a repository, or git did not answer: the card says nothing.
+		return undefined;
+	}
+}

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 "../kit/index.ts";
+
+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,49 @@
+// 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)$/;
+
+export 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;
+}
+
+/** A message's frame stays pi's own in `normal` too. */
+export function modeColor(mode: Mode): (typeof FRAME_COLORS)[keyof typeof FRAME_COLORS] | undefined {
+	return mode === "normal" ? undefined : FRAME_COLORS[mode];
+}
+
+export function frameColorOf(
+	statuses: ReadonlyMap<string, string>,
+): (typeof FRAME_COLORS)[keyof typeof FRAME_COLORS] | undefined {
+	const mode = modeOf(statuses);
+	return mode === undefined ? undefined : modeColor(mode);
+}
+
+/** Saved with the session, so a resumed conversation still shows which mode each message went out in. */
+export const SENT_IN_ENTRY = "pi-frame-sent-in";
+
+/** The session entry of each message sent in a mode, joined on the message's timestamp, since a live message has no entry yet. */
+export function sentInFromEntries(
+	entries: readonly { type: string; id?: string; customType?: string; data?: unknown; message?: { role?: string; timestamp?: number } }[],
+): Map<string, Mode> {
+	const byTime = new Map<number, Mode>();
+	for (const entry of entries) {
+		if (entry.type !== "custom" || entry.customType !== SENT_IN_ENTRY) continue;
+		const { at, mode } = (entry.data ?? {}) as { at?: unknown; mode?: unknown };
+		if (typeof at === "number" && typeof mode === "string" && REPORTED.test(`mode: ${mode}`)) byTime.set(at, mode as Mode);
+	}
+	const sent = new Map<string, Mode>();
+	for (const entry of entries) {
+		const mode = entry.type === "message" && entry.message?.role === "user" ? byTime.get(entry.message.timestamp ?? -1) : undefined;
+		if (mode !== undefined && entry.id !== undefined) sent.set(entry.id, mode);
+	}
+	return sent;
+}

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)));
+				},
+			);
+		});
+}