pi-git-status-line 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tony David Sprotte
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,96 @@
+# pi-git-status-line
+
+A standalone [Pi](https://github.com/badlogic/pi-mono) package that extends Pi's status line below the input with git information for the current working tree:
+
+- current branch name
+- amount of uncommitted files
+- commits to be pushed (`↑`)
+- commits to be pulled (`↓`)
+
+It keeps Pi's existing footer/status line and adds a git summary via `ctx.ui.setStatus(...)`.
+
+## Install
+
+### From npm
+
+```bash
+pi install npm:pi-git-status-line
+```
+
+### From git
+
+```bash
+pi install git:github.com/qualiti/pi-git-status-line
+```
+
+### From a local checkout
+
+```bash
+pi install /absolute/path/to/pi-git-status-line
+```
+
+## Usage
+
+After installation, reload Pi or start a new session.
+
+When you are inside a git repository, the footer will show a summary like:
+
+```text
+ main · 2 uncommitted · ↑1 ↓0
+```
+
+If the repo is clean:
+
+```text
+ main · ✓ clean · ↑0 ↓0
+```
+
+If the branch has no upstream yet:
+
+```text
+ feature/new-branch · 1 uncommitted · no upstream
+```
+
+## Notes
+
+- works only when the current working directory is inside a git repository
+- refreshes on session start, after turns, and after `bash`, `write`, or `edit` tool executions
+- if Pi is not in a git repo, the extension hides its status text
+
+## Requirements
+
+- `git` must be available on `PATH`
+
+## Package structure
+
+This package follows Pi package guidelines:
+
+- it declares a `pi` manifest in `package.json`
+- it exposes the extension through `./extensions`
+- it ships TypeScript directly so Pi can load it through jiti
+
+## Local development
+
+Run the unit tests:
+
+```bash
+npm test
+```
+
+Run a local package install into Pi:
+
+```bash
+pi install /absolute/path/to/pi-git-status-line
+```
+
+Or load the extension file directly for quick testing:
+
+```bash
+pi -e /absolute/path/to/pi-git-status-line/extensions/git-status-line.ts
+```
+
+## Files
+
+- `package.json` — Pi package manifest for npm and git installs
+- `extensions/git-status-line.ts` — the extension entry point
+- `tests/git-status-line.test.ts` — helper tests

package/extensions/git-status-line.ts

@@ -0,0 +1,229 @@
+import { access } from "node:fs/promises";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+
+type ExecResult = {
+	stdout: string;
+	stderr: string;
+	code: number;
+	killed?: boolean;
+};
+
+type RepoState = {
+	branch: string;
+	upstream?: string;
+	changedFileCount: number;
+	aheadCount: number;
+	behindCount: number;
+	conflictCount: number;
+	inProgress: string[];
+};
+
+const STATUS_KEY = "git-status-line";
+const REFRESH_TOOL_NAMES = new Set(["bash", "write", "edit"]);
+
+export default function gitStatusLineExtension(pi: ExtensionAPI) {
+	const refresh = async (ctx: ExtensionContext) => {
+		await updateStatusLine(pi, ctx);
+	};
+
+	pi.on("session_start", async (_event, ctx) => {
+		await refresh(ctx);
+	});
+
+	pi.on("turn_end", async (_event, ctx) => {
+		await refresh(ctx);
+	});
+
+	pi.on("tool_execution_end", async (event, ctx) => {
+		if (REFRESH_TOOL_NAMES.has(event.toolName)) {
+			await refresh(ctx);
+		}
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		if (ctx.hasUI) ctx.ui.setStatus(STATUS_KEY, "");
+	});
+}
+
+async function updateStatusLine(pi: ExtensionAPI, ctx: ExtensionContext) {
+	if (!ctx.hasUI) return;
+
+	try {
+		const repo = await inspectRepo(pi, ctx.cwd);
+		ctx.ui.setStatus(STATUS_KEY, formatGitStatusLine(repo, ctx.ui.theme));
+	} catch {
+		ctx.ui.setStatus(STATUS_KEY, "");
+	}
+}
+
+async function inspectRepo(pi: ExtensionAPI, cwd: string): Promise<RepoState> {
+	const inside = await run(pi, cwd, "git", ["rev-parse", "--is-inside-work-tree"]);
+	if (inside.code !== 0 || inside.stdout.trim() !== "true") {
+		throw new Error("Not inside a git repository.");
+	}
+
+	const rootResult = await run(pi, cwd, "git", ["rev-parse", "--show-toplevel"]);
+	if (rootResult.code !== 0) {
+		throw new Error(cleanErrorText(rootResult) || "Could not determine the repository root.");
+	}
+	const root = rootResult.stdout.trim();
+
+	const branchResult = await run(pi, root, "git", ["branch", "--show-current"]);
+	if (branchResult.code !== 0) {
+		throw new Error(cleanErrorText(branchResult) || "Could not determine the current branch.");
+	}
+	const branch = branchResult.stdout.trim();
+	if (!branch) {
+		throw new Error("Detached HEAD.");
+	}
+
+	const statusResult = await run(pi, root, "git", ["status", "--porcelain=v1", "--branch"]);
+	if (statusResult.code !== 0) {
+		throw new Error(cleanErrorText(statusResult) || "Could not inspect git status.");
+	}
+
+	const upstreamResult = await run(pi, root, "git", ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]);
+	const upstream = upstreamResult.code === 0 ? upstreamResult.stdout.trim() || undefined : undefined;
+
+	let aheadCount = 0;
+	let behindCount = 0;
+	if (upstream) {
+		const counts = await run(pi, root, "git", ["rev-list", "--left-right", "--count", `${upstream}...HEAD`]);
+		if (counts.code === 0) {
+			const [behindText, aheadText] = counts.stdout.trim().split(/\s+/);
+			behindCount = Number.parseInt(behindText ?? "0", 10) || 0;
+			aheadCount = Number.parseInt(aheadText ?? "0", 10) || 0;
+		}
+	}
+
+	const inProgress = await detectInProgressOperations(pi, root);
+	const parsedStatus = parseStatus(statusResult.stdout);
+
+	return {
+		branch,
+		upstream,
+		changedFileCount: parsedStatus.changedFileCount,
+		aheadCount,
+		behindCount,
+		conflictCount: parsedStatus.conflictCount,
+		inProgress,
+	};
+}
+
+function parseStatus(statusText: string) {
+	let stagedCount = 0;
+	let unstagedCount = 0;
+	let untrackedCount = 0;
+	let conflictCount = 0;
+	let changedFileCount = 0;
+
+	for (const line of statusText.split(/\r?\n/)) {
+		if (!line || line.startsWith("## ") || line.startsWith("!! ")) continue;
+		changedFileCount += 1;
+
+		if (line.startsWith("?? ")) {
+			untrackedCount += 1;
+			continue;
+		}
+
+		const x = line[0] ?? " ";
+		const y = line[1] ?? " ";
+		if (isUnmergedStatus(x, y)) {
+			conflictCount += 1;
+			continue;
+		}
+
+		if (x !== " ") stagedCount += 1;
+		if (y !== " ") unstagedCount += 1;
+	}
+
+	return { stagedCount, unstagedCount, untrackedCount, conflictCount, changedFileCount };
+}
+
+function isUnmergedStatus(x: string, y: string) {
+	const pair = `${x}${y}`;
+	return new Set(["DD", "AU", "UD", "UA", "DU", "AA", "UU"]).has(pair);
+}
+
+async function detectInProgressOperations(pi: ExtensionAPI, cwd: string) {
+	const operations: string[] = [];
+	const candidates: Array<[string, string]> = [
+		["MERGE_HEAD", "merge"],
+		["CHERRY_PICK_HEAD", "cherry-pick"],
+		["REVERT_HEAD", "revert"],
+		["rebase-merge", "rebase"],
+		["rebase-apply", "rebase"],
+	];
+
+	for (const [gitPathName, label] of candidates) {
+		const gitPath = await run(pi, cwd, "git", ["rev-parse", "--git-path", gitPathName]);
+		if (gitPath.code !== 0) continue;
+		if (await pathExists(gitPath.stdout.trim())) {
+			if (!operations.includes(label)) operations.push(label);
+		}
+	}
+
+	return operations;
+}
+
+function formatGitStatusLine(repo: RepoState, theme: { fg(color: string, text: string): string }) {
+	const branch = theme.fg("accent", ` ${repo.branch}`);
+
+	let workingTree = repo.changedFileCount === 0
+		? theme.fg("success", "✓ clean")
+		: theme.fg(repo.conflictCount > 0 ? "error" : "warning", `${repo.changedFileCount} uncommitted`);
+
+	if (repo.inProgress.length > 0) {
+		workingTree += theme.fg("warning", ` (${repo.inProgress.join(", ")})`);
+	}
+
+	const sync = repo.upstream
+		? formatAheadBehind(repo.aheadCount, repo.behindCount, theme)
+		: theme.fg("dim", "no upstream");
+
+	return [branch, workingTree, sync].join(theme.fg("dim", " · "));
+}
+
+function formatAheadBehind(aheadCount: number, behindCount: number, theme: { fg(color: string, text: string): string }) {
+	const ahead = aheadCount > 0 ? theme.fg("warning", `↑${aheadCount}`) : theme.fg("dim", "↑0");
+	const behind = behindCount > 0 ? theme.fg("warning", `↓${behindCount}`) : theme.fg("dim", "↓0");
+	return `${ahead} ${behind}`;
+}
+
+async function run(
+	pi: ExtensionAPI,
+	cwd: string,
+	command: string,
+	args: string[],
+	timeout = 10_000,
+): Promise<ExecResult> {
+	const result = await pi.exec(command, args, { cwd, timeout });
+	return {
+		stdout: result.stdout,
+		stderr: result.stderr,
+		code: result.code,
+		killed: result.killed,
+	};
+}
+
+async function pathExists(filePath: string) {
+	try {
+		await access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function cleanErrorText(result: ExecResult) {
+	const text = [result.stderr, result.stdout].filter(Boolean).join("\n").trim();
+	return text || undefined;
+}
+
+export const __test__ = {
+	parseStatus,
+	isUnmergedStatus,
+	formatGitStatusLine,
+	formatAheadBehind,
+	cleanErrorText,
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "pi-git-status-line",
+  "version": "0.1.0",
+  "description": "Shareable Pi package that extends the status line with git branch, uncommitted files, and ahead/behind counts.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Tony David Sprotte <tony@sprotte.dev>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/qualiti/pi-git-status-line.git"
+  },
+  "homepage": "https://github.com/qualiti/pi-git-status-line#readme",
+  "bugs": {
+    "url": "https://github.com/qualiti/pi-git-status-line/issues"
+  },
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi",
+    "git",
+    "status-line"
+  ],
+  "files": [
+    "extensions",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "echo 'No build step required'",
+    "test": "vitest run",
+    "check": "npm test && npm pack --dry-run",
+    "pack:check": "npm pack --dry-run"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "vitest": "^3.2.4"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  }
+}