pi-redline 0.1.0 → 0.3.0

package/extensions/session-diff.ts

@@ -26,6 +26,7 @@ import {
 	visibleWidth,
 	wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
+import { completeSimple } from "@earendil-works/pi-ai";
 import { spawnSync } from "node:child_process";
 import { existsSync, statSync } from "node:fs";
 import { dirname, isAbsolute, relative, resolve } from "node:path";
@@ -193,6 +194,34 @@ function padTo(width: number, s: string): string {
 }
 
 // ─── Git ─────────────────────────────────────────────────────────────────────
+// Build a fake "diff" payload explaining that the file has no working-tree
+// changes vs HEAD, and listing the most recent commits touching it. Lines
+// without a leading space/+/-/@/diff prefix are classified by parseDiff as
+// rawHeader rows, which the renderer paints in the muted overlay0 color and
+// excludes from select-mode navigation — exactly the behavior we want here.
+function synthesizeCommittedNotice(repoRoot: string, rel: string): string {
+	const log = spawnSync(
+		"git",
+		["-C", repoRoot, "log", "--oneline", "--no-color", "-n", "10", "--", rel],
+		{ encoding: "utf8" },
+	);
+	const entries = (log.stdout ?? "").split("\n").filter((l) => l.length > 0);
+	const lines: string[] = [
+		`diff --git a/${rel} b/${rel}`,
+		"• No uncommitted changes vs HEAD.",
+		"•",
+	];
+	if (entries.length > 0) {
+		lines.push("• Commits touching this file (newest first):");
+		for (const e of entries) lines.push(`•   ${e}`);
+		lines.push("•");
+		lines.push("• Tip: `git show <sha>` to inspect any commit.");
+	} else {
+		lines.push("• No commits touch this file either — content matches HEAD.");
+	}
+	return lines.join("\n");
+}
+
 function gitDiff(repoRoot: string | null, abs: string): string {
 	const UFLAG = "--unified=999999";
 	if (!repoRoot) {
@@ -213,7 +242,13 @@ function gitDiff(repoRoot: string | null, abs: string): string {
 			["-C", repoRoot, "diff", "HEAD", "--no-color", UFLAG, "--", rel],
 			{ encoding: "utf8" },
 		);
-		return r.stdout ?? "";
+		const raw = r.stdout ?? "";
+		if (raw.trim()) return raw;
+		// No uncommitted changes vs HEAD — most often this means the edits got
+		// committed during the session. Surface the recent history of this file
+		// instead of a blank pane so the user understands *why* there is nothing
+		// to redline.
+		return synthesizeCommittedNotice(repoRoot, rel);
 	}
 	if (!existsSync(abs)) return "";
 	const r = spawnSync(
@@ -315,6 +350,493 @@ type Row =
 	| { kind: "repoMeta"; repo: string | null; tone: "branch" | "path"; text: string }
 	| { kind: "file"; repo: string | null; abs: string };
 
+// ─── Ship mode: commit + push + open PR ─────────────────────────────────────
+//
+// Press `P` after you're happy with the diff to walk through committing the
+// session-touched files, pushing the branch, and opening a PR. Commit message
+// and PR description are drafted with silent LLM round-trips (`completeSimple`)
+// so they don't pollute the chat history.
+
+function runGit(repo: string, args: string[]): { ok: boolean; stdout: string; stderr: string } {
+	const r = spawnSync("git", ["-C", repo, ...args], { encoding: "utf8" });
+	return {
+		ok: r.status === 0,
+		stdout: (r.stdout ?? "").trim(),
+		stderr: (r.stderr ?? "").trim(),
+	};
+}
+
+function gitCurrentBranch(repo: string): string {
+	const r = runGit(repo, ["rev-parse", "--abbrev-ref", "HEAD"]);
+	return r.ok ? r.stdout : "";
+}
+
+function gitDefaultBranch(repo: string): string {
+	// origin/HEAD → origin/main (or whatever the upstream default is).
+	const r = runGit(repo, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
+	if (r.ok && r.stdout.startsWith("origin/")) return r.stdout.slice("origin/".length);
+	// Fall back to common defaults if origin/HEAD is unset.
+	for (const guess of ["main", "master", "develop"]) {
+		if (runGit(repo, ["rev-parse", "--verify", `refs/heads/${guess}`]).ok) return guess;
+	}
+	return "main";
+}
+
+function gitRemoteUrl(repo: string): string {
+	const r = runGit(repo, ["config", "--get", "remote.origin.url"]);
+	return r.ok ? r.stdout : "";
+}
+
+function gitRepoSlug(repo: string): string {
+	// Parse owner/name out of a remote URL. Handles both git@ and https variants.
+	const url = gitRemoteUrl(repo);
+	if (!url) return "";
+	const m = url.match(/[:/]([^:/]+)\/([^/]+?)(?:\.git)?$/);
+	return m ? `${m[1]}/${m[2]}` : "";
+}
+
+/** Stage only the abs paths we know were touched this session, never `git add .`. */
+function gitAddPaths(repo: string, absPaths: string[]): { ok: boolean; err: string } {
+	if (absPaths.length === 0) return { ok: true, err: "" };
+	const rels = absPaths
+		.map((p) => relative(repo, p))
+		.filter((r) => r && !r.startsWith(".."));
+	if (rels.length === 0) return { ok: true, err: "" };
+	const r = runGit(repo, ["add", "--", ...rels]);
+	return { ok: r.ok, err: r.stderr };
+}
+
+function gitHasStagedChanges(repo: string): boolean {
+	// `git diff --cached --quiet` exits 1 when there ARE staged changes.
+	const r = spawnSync("git", ["-C", repo, "diff", "--cached", "--quiet"], { encoding: "utf8" });
+	return r.status === 1;
+}
+
+function gitCommit(repo: string, subject: string, body: string): { ok: boolean; err: string } {
+	const args = ["commit", "--no-verify", "-m", subject];
+	if (body.trim()) args.push("-m", body);
+	const r = runGit(repo, args);
+	return { ok: r.ok, err: r.stderr || r.stdout };
+}
+
+function gitPush(repo: string, branch: string): { ok: boolean; err: string } {
+	const r = spawnSync(
+		"git",
+		["-C", repo, "push", "--set-upstream", "origin", branch],
+		{ encoding: "utf8", env: { ...process.env, GH_TOKEN: "", GITHUB_TOKEN: "" } },
+	);
+	return {
+		ok: r.status === 0,
+		err: (r.stderr ?? "").trim() || (r.stdout ?? "").trim(),
+	};
+}
+
+function gitCheckoutNewBranch(repo: string, branch: string): { ok: boolean; err: string } {
+	const r = runGit(repo, ["checkout", "-b", branch]);
+	return { ok: r.ok, err: r.stderr };
+}
+
+function gitStagedDiff(repo: string): string {
+	const r = runGit(repo, ["diff", "--cached", "--no-color", "--unified=3"]);
+	return r.stdout;
+}
+
+function ghCreatePr(
+	repo: string,
+	title: string,
+	body: string,
+	baseBranch: string,
+): { ok: boolean; url: string; err: string } {
+	const r = spawnSync(
+		"gh",
+		["pr", "create", "--title", title, "--body", body, "--base", baseBranch],
+		{ cwd: repo, encoding: "utf8", env: { ...process.env, GH_TOKEN: "", GITHUB_TOKEN: "" } },
+	);
+	const out = (r.stdout ?? "").trim();
+	const err = (r.stderr ?? "").trim();
+	if (r.status !== 0) return { ok: false, url: "", err: err || out || `gh exited ${r.status}` };
+	// gh prints the PR URL on stdout.
+	const urlMatch = out.match(/https?:\/\/\S+/);
+	return { ok: true, url: urlMatch ? urlMatch[0] : out, err: "" };
+}
+
+function slugify(s: string): string {
+	return s
+		.toLowerCase()
+		.replace(/^(feat|fix|chore|docs|refactor|test|perf|build|ci|style|revert)(\([^)]*\))?:\s*/, "")
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-+|-+$/g, "")
+		.slice(0, 40);
+}
+
+async function silentComplete(
+	ctx: ExtensionContext,
+	systemPrompt: string,
+	userPrompt: string,
+): Promise<string> {
+	const model = ctx.model;
+	if (!model) throw new Error("No model configured (ctx.model is undefined).");
+	const result = await completeSimple(model as any, {
+		systemPrompt,
+		messages: [{ role: "user", content: userPrompt, timestamp: Date.now() }],
+	});
+	const text = result.content
+		.filter((c: any) => c.type === "text")
+		.map((c: any) => c.text as string)
+		.join("")
+		.trim();
+	if (!text) throw new Error("LLM returned an empty response.");
+	return text;
+}
+
+function parseCommitDraft(raw: string): { subject: string; body: string } {
+	// LLM sometimes wraps in code fences; strip them.
+	let s = raw.trim();
+	s = s.replace(/^```[a-z]*\n?/i, "").replace(/\n?```$/, "").trim();
+	const nl = s.indexOf("\n");
+	if (nl === -1) return { subject: s, body: "" };
+	return {
+		subject: s.slice(0, nl).trim(),
+		body: s.slice(nl + 1).trim(),
+	};
+}
+
+const COMMIT_SYSTEM = `You write Conventional Commit messages for git.
+
+Rules:
+- Output ONLY the commit message — no prose, no code fences, no preamble.
+- Subject line: <type>(<optional-scope>): <imperative summary>. Max 72 chars. No trailing period.
+- Allowed types: feat, fix, chore, docs, refactor, test, perf, build, ci, style, revert.
+- After the subject line, optionally add a blank line and a wrapped body explaining the *why*, not the *what*. Keep body under 6 lines.
+- Use the imperative mood ("add", not "added").`;
+
+const PR_BODY_SYSTEM = `You write GitHub Pull Request descriptions in markdown.
+
+Rules:
+- Output ONLY the markdown body — no preamble, no code fences around the whole thing.
+- Structure: a 1-2 sentence summary, then a "## Changes" bullet list (one bullet per logical change), then a "## Why" paragraph, then an optional "## Notes" section for caveats.
+- Be concrete and specific to the diff. Reference filenames where helpful.
+- Keep it under 30 lines.`;
+
+type ShipPhase =
+	| { kind: "summary" }
+	| { kind: "branch-input"; suggested: string; input: string; err?: string }
+	| { kind: "drafting-commit" }
+	| { kind: "commit-review"; subject: string; body: string }
+	| { kind: "commit-instruct"; subject: string; body: string; input: string }
+	| { kind: "confirm"; subject: string; body: string }
+	| { kind: "shipping"; status: string }
+	| { kind: "done"; ok: boolean; message: string };
+
+interface ShipDeps {
+	ctx: ExtensionContext;
+	pi: ExtensionAPI;
+	invalidate: () => void;
+}
+
+class ShipMode {
+	phase: ShipPhase = { kind: "summary" };
+	repo: string;
+	currentBranch: string;
+	defaultBranch: string;
+	isDefaultBranch: boolean;
+	repoName: string;
+	targetBranch = "";
+	filesAbs: string[];
+	prUrl: string | null = null;
+
+	constructor(
+		repo: string,
+		filesAbs: string[],
+		private deps: ShipDeps,
+	) {
+		this.repo = repo;
+		this.filesAbs = filesAbs;
+		this.currentBranch = gitCurrentBranch(repo);
+		this.defaultBranch = gitDefaultBranch(repo);
+		this.isDefaultBranch = ["main", "master", "develop"].includes(this.currentBranch);
+		this.repoName = getRepoInfo(repo).name;
+		this.targetBranch = this.isDefaultBranch ? "" : this.currentBranch;
+	}
+
+	private setPhase(p: ShipPhase) {
+		this.phase = p;
+		this.deps.invalidate();
+	}
+
+	handleInput(data: string): "handled" | "exit" {
+		const p = this.phase;
+
+		if (p.kind === "done") {
+			if (matchesKey(data, Key.enter) || matchesKey(data, Key.escape) || data === "q") return "exit";
+			return "handled";
+		}
+
+		if (p.kind === "shipping") return "handled"; // ignore input during ship
+
+		if (matchesKey(data, Key.escape)) return "exit";
+
+		if (p.kind === "summary") {
+			if (matchesKey(data, Key.enter) || data === "y" || data === "Y") {
+				if (this.isDefaultBranch) {
+					this.setPhase({ kind: "branch-input", suggested: "", input: "" });
+				} else {
+					this.startDraftCommit();
+				}
+			}
+			return "handled";
+		}
+
+		if (p.kind === "branch-input") {
+			if (matchesKey(data, Key.enter)) {
+				const name = (p.input || p.suggested).trim();
+				if (!name || !/^[A-Za-z0-9._\/-]+$/.test(name)) {
+					this.setPhase({ ...p, err: "Invalid branch name." });
+					return "handled";
+				}
+				this.targetBranch = name;
+				this.startDraftCommit();
+				return "handled";
+			}
+			if (matchesKey(data, Key.backspace)) {
+				this.setPhase({ ...p, input: p.input.slice(0, -1) });
+				return "handled";
+			}
+			if (data.length === 1 && data.charCodeAt(0) >= 32) {
+				this.setPhase({ ...p, input: p.input + data });
+				return "handled";
+			}
+			return "handled";
+		}
+
+		if (p.kind === "commit-review") {
+			if (matchesKey(data, Key.enter) || data === "y" || data === "Y") {
+				this.setPhase({ kind: "confirm", subject: p.subject, body: p.body });
+				return "handled";
+			}
+			if (data === "r" || data === "R") {
+				this.startDraftCommit();
+				return "handled";
+			}
+			if (data === "e" || data === "E") {
+				this.setPhase({ kind: "commit-instruct", subject: p.subject, body: p.body, input: "" });
+				return "handled";
+			}
+			return "handled";
+		}
+
+		if (p.kind === "commit-instruct") {
+			if (matchesKey(data, Key.enter)) {
+				const instr = p.input.trim();
+				if (!instr) {
+					this.setPhase({ kind: "commit-review", subject: p.subject, body: p.body });
+					return "handled";
+				}
+				this.startDraftCommit(instr, p.subject, p.body);
+				return "handled";
+			}
+			if (matchesKey(data, Key.backspace)) {
+				this.setPhase({ ...p, input: p.input.slice(0, -1) });
+				return "handled";
+			}
+			if (data.length === 1 && data.charCodeAt(0) >= 32) {
+				this.setPhase({ ...p, input: p.input + data });
+				return "handled";
+			}
+			return "handled";
+		}
+
+		if (p.kind === "confirm") {
+			if (data === "y" || data === "Y" || matchesKey(data, Key.enter)) {
+				this.doShip(p.subject, p.body);
+				return "handled";
+			}
+			if (data === "n" || data === "N") {
+				this.setPhase({ kind: "commit-review", subject: p.subject, body: p.body });
+				return "handled";
+			}
+			return "handled";
+		}
+
+		return "handled";
+	}
+
+	private startDraftCommit(instruction?: string, prevSubject?: string, prevBody?: string) {
+		this.setPhase({ kind: "drafting-commit" });
+		(async () => {
+			try {
+				// Stage files now so we can diff --cached.
+				const add = gitAddPaths(this.repo, this.filesAbs);
+				if (!add.ok) throw new Error(`git add failed: ${add.err}`);
+				let diff = gitStagedDiff(this.repo);
+				if (diff.length > 32_000) diff = diff.slice(0, 32_000) + "\n\n[diff truncated]";
+				const parts: string[] = [];
+				if (instruction) {
+					parts.push(`The previous draft was:\n\n${prevSubject ?? ""}\n${prevBody ? "\n" + prevBody : ""}`);
+					parts.push(`The user asked: ${instruction}`);
+					parts.push("Please produce a revised commit message that follows the user's instruction. Output ONLY the commit message.");
+				}
+				parts.push(`Staged diff:\n\n${diff || "(empty diff)"}`);
+				const raw = await silentComplete(this.deps.ctx, COMMIT_SYSTEM, parts.join("\n\n"));
+				const draft = parseCommitDraft(raw);
+				this.setPhase({ kind: "commit-review", subject: draft.subject, body: draft.body });
+			} catch (e: any) {
+				this.setPhase({
+					kind: "done",
+					ok: false,
+					message: `Failed to draft commit: ${e?.message ?? String(e)}`,
+				});
+			}
+		})();
+	}
+
+	private async doShip(subject: string, body: string) {
+		const step = (s: string) => this.setPhase({ kind: "shipping", status: s });
+		try {
+			if (this.isDefaultBranch) {
+				step(`Creating branch ${this.targetBranch}…`);
+				const co = gitCheckoutNewBranch(this.repo, this.targetBranch);
+				if (!co.ok) throw new Error(`checkout -b failed: ${co.err}`);
+			}
+			step("Staging files…");
+			const add = gitAddPaths(this.repo, this.filesAbs);
+			if (!add.ok) throw new Error(`git add failed: ${add.err}`);
+			if (!gitHasStagedChanges(this.repo)) {
+				this.setPhase({
+					kind: "done",
+					ok: false,
+					message: "Nothing to commit — staged diff is empty. Did you already commit these files?",
+				});
+				return;
+			}
+			step("Committing…");
+			const cm = gitCommit(this.repo, subject, body);
+			if (!cm.ok) throw new Error(`git commit failed: ${cm.err}`);
+			step(`Pushing origin/${this.targetBranch || this.currentBranch}…`);
+			const pushBranch = this.targetBranch || this.currentBranch;
+			const ps = gitPush(this.repo, pushBranch);
+			if (!ps.ok) throw new Error(`git push failed: ${ps.err}`);
+			// PR creation lands in 0.4.0; for now just confirm commit+push.
+			this.setPhase({
+				kind: "done",
+				ok: true,
+				message: `Pushed to origin/${pushBranch}.\n\nNext: open a PR (gh pr create) — automated PR flow lands in pi-redline 0.4.0.`,
+			});
+		} catch (e: any) {
+			this.setPhase({
+				kind: "done",
+				ok: false,
+				message: e?.message ?? String(e),
+			});
+		}
+	}
+
+	render(width: number, height: number): string[] {
+		const lines: string[] = [];
+		const pad = (s: string) => padTo(width, s);
+		const h = (s: string) => bold(fg(C.lavender, s));
+		const dim = (s: string) => fg(C.overlay1, s);
+		const key = (s: string) => fg(C.peach, s);
+		const ok = (s: string) => fg(C.green, s);
+		const err = (s: string) => fg(C.red, s);
+
+		lines.push(pad(""));
+		lines.push(pad("  " + h("🚀 Ship to GitHub")));
+		lines.push(pad(""));
+		lines.push(pad("  " + dim("repo:    ") + fg(C.text, this.repoName)));
+		const slug = gitRepoSlug(this.repo);
+		if (slug) lines.push(pad("  " + dim("remote:  ") + fg(C.subtext0, slug)));
+		lines.push(pad("  " + dim("branch:  ") + fg(C.text, this.currentBranch) + dim("  (default: " + this.defaultBranch + ")")));
+		lines.push(pad("  " + dim("files:   ") + fg(C.text, String(this.filesAbs.length))));
+		lines.push(pad(""));
+
+		const p = this.phase;
+		if (p.kind === "summary") {
+			if (this.isDefaultBranch) {
+				lines.push(pad("  " + fg(C.yellow, "⚠ ") + fg(C.subtext0, `You're on "${this.currentBranch}". You'll be asked for a new branch name.`)));
+			} else {
+				lines.push(pad("  " + ok("✓ ") + fg(C.subtext0, `Will commit to current branch "${this.currentBranch}".`)));
+			}
+			lines.push(pad(""));
+			lines.push(pad("  " + dim("This will:")));
+			lines.push(pad("  " + dim("   1. Stage the " + this.filesAbs.length + " file" + (this.filesAbs.length === 1 ? "" : "s") + " touched in this session")));
+			lines.push(pad("  " + dim("   2. Draft a commit message with the LLM (silent — no chat pollution)")));
+			lines.push(pad("  " + dim("   3. Let you accept/regenerate/instruct")));
+			lines.push(pad("  " + dim("   4. Commit and push to origin")));
+		} else if (p.kind === "branch-input") {
+			const sugg = p.suggested ? dim(`  (suggested: ${p.suggested})`) : "";
+			lines.push(pad("  " + h("New branch name") + sugg));
+			lines.push(pad("  " + fg(C.peach, "› ") + fg(C.text, p.input) + fg(C.peach, "▏")));
+			if (p.err) lines.push(pad("  " + err(p.err)));
+		} else if (p.kind === "drafting-commit") {
+			lines.push(pad("  " + fg(C.sapphire, "⏳ ") + fg(C.subtext0, "Drafting commit message with the LLM…")));
+		} else if (p.kind === "commit-review" || p.kind === "confirm") {
+			lines.push(pad("  " + h("Commit message")));
+			lines.push(pad(""));
+			lines.push(pad("    " + bold(fg(C.text, p.subject))));
+			if (p.body) {
+				lines.push(pad(""));
+				for (const ln of p.body.split("\n")) {
+					lines.push(pad("    " + fg(C.subtext0, ln)));
+				}
+			}
+			lines.push(pad(""));
+			if (p.kind === "confirm") {
+				const branch = this.targetBranch || this.currentBranch;
+				lines.push(pad("  " + fg(C.yellow, "⚠ ") + fg(C.text, "Ship to ") + bold(fg(C.peach, `origin/${branch}`)) + fg(C.text, "?")));
+			}
+		} else if (p.kind === "commit-instruct") {
+			lines.push(pad("  " + h("How should the commit message change?")));
+			lines.push(pad("  " + dim('e.g. "make it shorter", "mention IN-2170", "use chore type"')));
+			lines.push(pad("  " + fg(C.peach, "› ") + fg(C.text, p.input) + fg(C.peach, "▏")));
+		} else if (p.kind === "shipping") {
+			lines.push(pad("  " + fg(C.sapphire, "⏳ ") + fg(C.subtext0, p.status)));
+		} else if (p.kind === "done") {
+			const icon = p.ok ? ok("✓ ") : err("✗ ");
+			lines.push(pad("  " + icon + (p.ok ? ok("Success") : err("Failed"))));
+			lines.push(pad(""));
+			for (const ln of p.message.split("\n")) {
+				lines.push(pad("  " + fg(C.subtext0, ln)));
+			}
+		}
+
+		while (lines.length < height) lines.push(pad(""));
+		return lines.slice(0, height);
+	}
+
+	renderFooter(width: number): string {
+		const seg = (k: string, v: string) =>
+			`${fg(C.peach, k)} ${fg(C.subtext0, v)}`;
+		const p = this.phase;
+		let segs: [string, string][] = [];
+		switch (p.kind) {
+			case "summary":
+				segs = [["⏎/y", "begin"], ["esc", "cancel ship"]];
+				break;
+			case "branch-input":
+				segs = [["⏎", "confirm branch"], ["esc", "cancel ship"]];
+				break;
+			case "drafting-commit":
+			case "shipping":
+				segs = [["esc", "cancel ship"]];
+				break;
+			case "commit-review":
+				segs = [["⏎/y", "accept"], ["r", "regenerate"], ["e", "instruct LLM"], ["esc", "cancel"]];
+				break;
+			case "commit-instruct":
+				segs = [["⏎", "send instruction"], ["esc", "cancel"]];
+				break;
+			case "confirm":
+				segs = [["y", "ship it"], ["n", "back to commit"], ["esc", "cancel"]];
+				break;
+			case "done":
+				segs = [["⏎", "close"]];
+				break;
+		}
+		return padTo(width, " " + segs.map(([k, v]) => seg(k, v)).join("  ·  "));
+	}
+}
+
 interface RenderedDiff {
 	rows: string[]; // colored, gutter-prefixed, wrapped lines ready to slice
 	rowToParsed: number[]; // rendered row index → parsed DiffLine index
@@ -347,6 +869,9 @@ class SessionDiffView {
 	private cachedHeight?: number;
 	private cachedLines?: string[];
 
+	// Ship mode (P key) — commit + push touched files. Null when inactive.
+	private ship: ShipMode | null = null;
+
 	public onClose?: () => void;
 	public onSubmit?: (prompt: string) => void;
 
@@ -354,10 +879,47 @@ class SessionDiffView {
 		private files: TouchedFile[],
 		/** Annotations live in the extension closure so they survive overlay close. */
 		private annotations: Annotation[],
+		private shipDeps?: { ctx: ExtensionContext; pi: ExtensionAPI },
 	) {
 		this.rebuildRows();
 	}
 
+	private startShip(): void {
+		if (!this.shipDeps) return;
+		// Determine which repo to ship: use the currently selected row's repo if a
+		// real git repo, else the first touched repo we can find.
+		let repo: string | null = null;
+		const sel = this.rows[this.leftSelected];
+		if (sel && (sel.kind === "repo" || sel.kind === "repoMeta" || sel.kind === "file")) {
+			repo = sel.repo;
+		}
+		if (!repo) {
+			for (const f of this.files) {
+				if (f.repo) { repo = f.repo; break; }
+			}
+		}
+		if (!repo) {
+			this.shipDeps.ctx.ui.notify("No git repo found in this session — nothing to ship.", "warning");
+			return;
+		}
+		const filesInRepo = this.files.filter((f) => f.repo === repo).map((f) => f.abs);
+		if (filesInRepo.length === 0) {
+			this.shipDeps.ctx.ui.notify("No session-touched files in that repo.", "warning");
+			return;
+		}
+		this.ship = new ShipMode(repo, filesInRepo, {
+			ctx: this.shipDeps.ctx,
+			pi: this.shipDeps.pi,
+			invalidate: () => this.invalidate(),
+		});
+		this.invalidate();
+	}
+
+	private exitShip(): void {
+		this.ship = null;
+		this.invalidate();
+	}
+
 	// ── Left tree ────────────────────────────────────────────────────────────
 	private repoKey(r: string | null): string {
 		return r ?? "__none__";
@@ -532,6 +1094,17 @@ class SessionDiffView {
 
 	// ── Input ────────────────────────────────────────────────────────────────
 	handleInput(data: string): void {
+		// Ship mode takes over input entirely while active.
+		if (this.ship) {
+			const r = this.ship.handleInput(data);
+			if (r === "exit") this.exitShip();
+			return;
+		}
+		// P enters ship mode from any non-text-input mode.
+		if (data === "P" && this.mode !== "annotate") {
+			this.startShip();
+			return;
+		}
 		// Annotate mode: capture text input.
 		if (this.mode === "annotate") {
 			if (matchesKey(data, Key.escape)) {
@@ -919,6 +1492,26 @@ class SessionDiffView {
 		const dividerH = 2;
 		const bodyH = Math.max(3, totalHeight - 2 - headerH - footerH - dividerH);
 
+		// Ship mode: replace the body with a single full-width ship UI.
+		if (this.ship) {
+			const border = (s: string) => fg(C.mauve, s);
+			const top = border(`╭${"─".repeat(innerW)}╮`);
+			const bot = border(`╰${"─".repeat(innerW)}╯`);
+			const rule = border("├") + fg(C.surface1, "─".repeat(innerW)) + border("┤");
+			const V = border("│");
+			const hdr = bold(fg(C.lavender, " ✨ Ship to GitHub ")) + fg(C.overlay1, "  pi-redline");
+			const header = `${V}${padTo(innerW, hdr)}${V}`;
+			const shipBody = this.ship.render(innerW, bodyH);
+			const body = shipBody.map((l) => `${V}${padTo(innerW, l)}${V}`);
+			const footer = `${V}${padTo(innerW, this.ship.renderFooter(innerW))}${V}`;
+			const lines = [top, header, rule, ...body, rule, footer, bot];
+			const tinted = lines.map((ln) => bg(C.mantle, padTo(width, ln)));
+			this.cachedLines = tinted;
+			this.cachedWidth = width;
+			this.cachedHeight = totalHeight;
+			return tinted;
+		}
+
 		this.lastRightW = rightWidth - 1; // 1 for inner left padding
 		this.lastInnerH = bodyH - 2; // 2 = file header + rule inside right pane
 
@@ -1011,6 +1604,7 @@ class SessionDiffView {
 				["←", "collapse"],
 				["→/⏎", "open diff"],
 				["A", `review (${this.annotations.length})`],
+				["P", "ship"],
 				["q", "close"],
 			];
 		} else if (this.mode === "select") {
@@ -1039,6 +1633,7 @@ class SessionDiffView {
 				["←", "back"],
 				["A", `review (${this.annotations.length})`],
 				["S", "submit"],
+				["P", "ship"],
 				["q", "close"],
 			];
 		}
@@ -1262,7 +1857,7 @@ export default function (pi: ExtensionAPI) {
 			let pendingPrompt: string | null = null;
 			await ctx.ui.custom<void>(
 				(tui, _theme, _kb, done) => {
-					const view = new SessionDiffView(files, annotations);
+					const view = new SessionDiffView(files, annotations, { ctx, pi });
 					view.onClose = () => done(undefined);
 					view.onSubmit = (prompt) => {
 						pendingPrompt = prompt;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-redline",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Redline pi sessions: an overlay TUI showing every file changed in the current pi session with syntax-highlighted diffs, per-line selection, fix/explain annotations, and a one-key submit-as-prompt flow.",
   "author": "Alon Martin",
   "license": "MIT",
@@ -9,11 +9,15 @@
     "node": ">=20"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-ai": "*"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-coding-agent": {
       "optional": false
+    },
+    "@earendil-works/pi-ai": {
+      "optional": false
     }
   },
   "pi": {