@oh-my-pi/pi-coding-agent 16.0.0 → 16.0.2

package/src/extensibility/custom-commands/bundled/review/index.ts

@@ -17,6 +17,7 @@ import type { HookCommandContext } from "../../../../extensibility/hooks/types";
 import reviewCustomRequestTemplate from "../../../../prompts/review-custom-request.md" with { type: "text" };
 import reviewHeadlessRequestTemplate from "../../../../prompts/review-headless-request.md" with { type: "text" };
 import reviewRequestTemplate from "../../../../prompts/review-request.md" with { type: "text" };
+import * as gh from "../../../../tools/gh";
 import * as git from "../../../../utils/git";
 import * as jj from "../../../../utils/jj";
 
@@ -45,6 +46,25 @@ interface CurrentReviewDiff {
 	mode: string;
 }
 
+interface ReviewPrRef {
+	repo: string;
+	number: number;
+	raw: string;
+	kind: "github-url" | "pr-url";
+}
+
+interface ParsedReviewArgs {
+	prRef: ReviewPrRef | undefined;
+	extraInstructions: string;
+}
+
+type ReviewMenuChoice =
+	| { kind: "detected-pr"; ref: ReviewPrRef }
+	| { kind: "base-branch" }
+	| { kind: "uncommitted" }
+	| { kind: "commit" }
+	| { kind: "custom" };
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Exclusion patterns for noise files
 // ─────────────────────────────────────────────────────────────────────────────
@@ -204,6 +224,7 @@ function getDiffPreview(hunks: string, maxLines: number): string {
 const MAX_DIFF_CHARS = 50_000; // Don't include diff above this
 const MAX_FILES_FOR_INLINE_DIFF = 20; // Don't include diff if more files than this
 const DEFAULT_LARGE_DIFF_INSTRUCTION = "MUST run `git diff`/`git show` for assigned files";
+const DEFAULT_CONTEXT_INSTRUCTION = "MAY read full file context as needed via `read`";
 const GIT_UNCOMMITTED_DIFF_INSTRUCTION =
 	"MUST run both `git diff -- <path>` and `git diff --cached -- <path>` for assigned files";
 const JJ_UNCOMMITTED_DIFF_INSTRUCTION = "MUST run `jj --ignore-working-copy diff --git -- <path>` for assigned files";
@@ -215,7 +236,7 @@ function buildReviewPrompt(
 	mode: string,
 	stats: DiffStats,
 	rawDiff: string,
-	options: { additionalInstructions?: string; diffInstruction?: string } = {},
+	options: { additionalInstructions?: string; diffInstruction?: string; contextInstruction?: string } = {},
 ): string {
 	const agentCount = getRecommendedAgentCount(stats);
 	const skipDiff = rawDiff.length > MAX_DIFF_CHARS || stats.files.length > MAX_FILES_FOR_INLINE_DIFF;
@@ -242,6 +263,7 @@ function buildReviewPrompt(
 		linesPerFile,
 		additionalInstructions: options.additionalInstructions,
 		diffInstruction: options.diffInstruction ?? DEFAULT_LARGE_DIFF_INSTRUCTION,
+		contextInstruction: options.contextInstruction ?? DEFAULT_CONTEXT_INSTRUCTION,
 	});
 }
 
@@ -253,6 +275,203 @@ function buildHeadlessReviewPrompt(focus?: string): string {
 	return prompt.render(reviewHeadlessRequestTemplate, { focus });
 }
 
+const REVIEW_CONTEXT_PR_LIMIT = 3;
+const REPO_SEGMENT_PATTERN = /^[A-Za-z0-9_.-]+$/;
+const PR_SCHEME_PATTERN = /^pr:\/\/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)\/([1-9]\d*)(?:\/diff(?:\/(?:all|[1-9]\d*))?)?$/;
+const PR_REF_TEXT_PATTERN = /https:\/\/github\.com\/[^\s<>"']+|pr:\/\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/[^\s<>"']+/g;
+
+function stripTrailingPrRefPunctuation(text: string): string {
+	return text.replace(/[.,)\]>]+$/g, "");
+}
+
+function isValidRepoSegment(segment: string | undefined): segment is string {
+	return segment !== undefined && REPO_SEGMENT_PATTERN.test(segment);
+}
+
+function parsePositivePrNumber(value: string | undefined): number | undefined {
+	if (value === undefined || !/^[1-9]\d*$/.test(value)) return undefined;
+	const parsed = Number(value);
+	return Number.isSafeInteger(parsed) ? parsed : undefined;
+}
+
+function parseGithubPrUrl(text: string): ReviewPrRef | undefined {
+	let url: URL;
+	try {
+		url = new URL(text);
+	} catch {
+		return undefined;
+	}
+
+	if (url.protocol !== "https:" || url.hostname !== "github.com") return undefined;
+
+	const parts = url.pathname.split("/").filter(Boolean);
+	if (parts.length < 4 || parts[2] !== "pull") return undefined;
+
+	const [owner, repo, , numberPart] = parts;
+	if (!isValidRepoSegment(owner) || !isValidRepoSegment(repo)) return undefined;
+
+	const number = parsePositivePrNumber(numberPart);
+	if (number === undefined) return undefined;
+
+	return { repo: `${owner}/${repo}`, number, raw: text, kind: "github-url" };
+}
+
+function parsePrSchemeRef(text: string): ReviewPrRef | undefined {
+	const match = PR_SCHEME_PATTERN.exec(text);
+	if (!match) return undefined;
+
+	const [, owner, repo, numberPart] = match;
+	const number = parsePositivePrNumber(numberPart);
+	if (number === undefined) return undefined;
+
+	return { repo: `${owner}/${repo}`, number, raw: text, kind: "pr-url" };
+}
+
+function parseReviewPrRef(text: string): ReviewPrRef | undefined {
+	const candidate = stripTrailingPrRefPunctuation(text);
+	return parseGithubPrUrl(candidate) ?? parsePrSchemeRef(candidate);
+}
+
+function buildPrLargeDiffInstruction(ref: ReviewPrRef): string {
+	const prDiffUrl = `pr://${ref.repo}/${ref.number}/diff`;
+	return `MUST read assigned PR file diffs from \`${prDiffUrl}/all\` or per-file \`${prDiffUrl}/<index>\`; NEVER use local \`git diff\`/\`git show\` for PR diff content`;
+}
+
+function buildPrContextInstruction(ref: ReviewPrRef): string {
+	const prDiffUrl = `pr://${ref.repo}/${ref.number}/diff`;
+	return `MUST NOT read local workspace files for PR file context; use the fetched PR diff and \`${prDiffUrl}/all\` or per-file \`${prDiffUrl}/<index>\` only`;
+}
+
+function extractReviewPrRefFromArgs(args: string[]): ParsedReviewArgs {
+	let prRef: ReviewPrRef | undefined;
+	let prRefIndex = -1;
+	for (const [idx, arg] of args.entries()) {
+		const parsed = parseReviewPrRef(arg);
+		if (parsed) {
+			prRef = parsed;
+			prRefIndex = idx;
+			break;
+		}
+	}
+
+	return {
+		prRef,
+		extraInstructions: args.filter((_, idx) => idx !== prRefIndex).join(" "),
+	};
+}
+
+function extractReviewPrRefsFromText(text: string): ReviewPrRef[] {
+	return Array.from(text.matchAll(PR_REF_TEXT_PATTERN), match => parseReviewPrRef(match[0])).filter(
+		(ref): ref is ReviewPrRef => ref !== undefined,
+	);
+}
+
+function buildReviewPromptFromDiff(
+	ctx: HookCommandContext,
+	mode: string,
+	diffText: string,
+	extraInstructions: string | undefined,
+	emptyMessage: string,
+	options: { diffInstruction?: string; filteredMessage?: string; contextInstruction?: string } = {},
+): string | undefined {
+	if (!diffText.trim()) {
+		if (ctx.hasUI) ctx.ui.notify(emptyMessage, "warning");
+		return undefined;
+	}
+
+	const stats = parseDiff(diffText);
+	if (stats.files.length === 0) {
+		if (ctx.hasUI)
+			ctx.ui.notify(options.filteredMessage ?? "No reviewable files (all changes filtered out)", "warning");
+		return undefined;
+	}
+
+	return buildReviewPrompt(mode, stats, diffText, {
+		additionalInstructions: extraInstructions,
+		diffInstruction: options.diffInstruction,
+		contextInstruction: options.contextInstruction,
+	});
+}
+
+async function buildPrReviewPrompt(
+	api: CustomCommandAPI,
+	ctx: HookCommandContext,
+	ref: ReviewPrRef,
+	extraInstructions: string,
+): Promise<string | undefined> {
+	let diffText: string;
+	try {
+		const lookup = await gh.getOrFetchPrDiff({ cwd: api.cwd, repo: ref.repo, number: ref.number });
+		diffText = lookup.payload.unified;
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		const failure = `Failed to fetch PR diff for ${ref.repo}#${ref.number}: ${message}`;
+		if (ctx.hasUI) {
+			ctx.ui.notify(failure, "error");
+			return undefined;
+		}
+		return failure;
+	}
+
+	const promptText = buildReviewPromptFromDiff(
+		ctx,
+		`PR ${ref.repo}#${ref.number}`,
+		diffText,
+		extraInstructions || undefined,
+		`PR ${ref.repo}#${ref.number} has no diff content available`,
+		{ diffInstruction: buildPrLargeDiffInstruction(ref), contextInstruction: buildPrContextInstruction(ref) },
+	);
+	if (promptText !== undefined || ctx.hasUI) return promptText;
+	return `Unable to review PR ${ref.repo}#${ref.number}: no diff content available.`;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function getTextContentParts(content: unknown): string[] {
+	if (typeof content === "string") return [content];
+	if (!Array.isArray(content)) return [];
+
+	const parts: string[] = [];
+	for (const item of content) {
+		if (isRecord(item) && item.type === "text" && typeof item.text === "string") {
+			parts.push(item.text);
+		}
+	}
+	return parts;
+}
+
+function findRecentPrRefs(ctx: HookCommandContext, limit: number): ReviewPrRef[] {
+	const refs: ReviewPrRef[] = [];
+	const seen = new Set<string>();
+	const entries = ctx.sessionManager.getBranch();
+
+	for (let idx = entries.length - 1; idx >= 0 && refs.length < limit; idx--) {
+		const entry = entries[idx];
+		if (entry?.type !== "message") continue;
+		const message = entry.message;
+		if (message.role !== "user" && message.role !== "assistant") continue;
+
+		const parts = getTextContentParts(message.content);
+		for (let partIdx = parts.length - 1; partIdx >= 0; partIdx--) {
+			const part = parts[partIdx];
+			const partRefs = extractReviewPrRefsFromText(part);
+			for (let refIdx = partRefs.length - 1; refIdx >= 0; refIdx--) {
+				const ref = partRefs[refIdx];
+				const key = `${ref.repo.toLowerCase()}#${ref.number}`;
+				if (seen.has(key)) continue;
+				seen.add(key);
+				refs.push(ref);
+				if (refs.length >= limit) break;
+			}
+			if (refs.length >= limit) break;
+		}
+	}
+
+	return refs;
+}
+
 export class ReviewCommand implements CustomCommand {
 	name = "review";
 	description = "Launch interactive code review";
@@ -260,36 +479,56 @@ export class ReviewCommand implements CustomCommand {
 	constructor(private api: CustomCommandAPI) {}
 
 	async execute(args: string[], ctx: HookCommandContext): Promise<string | undefined> {
-		if (!ctx.hasUI) {
-			return buildHeadlessReviewPrompt(args.length > 0 ? args.join(" ") : undefined);
+		const parsedArgs = extractReviewPrRefFromArgs(args);
+		if (parsedArgs.prRef) {
+			return buildPrReviewPrompt(this.api, ctx, parsedArgs.prRef, parsedArgs.extraInstructions);
 		}
 
-		// Inline args act as additional instructions appended to the generated prompt.
-		// When present, skip option 4 (editor) — the args already provide the instructions.
-		const extraInstructions = args.length > 0 ? args.join(" ") : undefined;
+		const extraInstructions = parsedArgs.extraInstructions || undefined;
+		if (!ctx.hasUI) {
+			return buildHeadlessReviewPrompt(extraInstructions);
+		}
 
-		const menuItems = extraInstructions
-			? [
-					"1. Review against a base branch (PR Style)",
-					"2. Review uncommitted changes",
-					"3. Review a specific commit",
-				]
-			: [
-					"1. Review against a base branch (PR Style)",
-					"2. Review uncommitted changes",
-					"3. Review a specific commit",
-					"4. Custom review instructions",
-				];
+		const choices: Array<{ label: string; value: ReviewMenuChoice }> = [
+			...findRecentPrRefs(ctx, REVIEW_CONTEXT_PR_LIMIT).map(ref => ({
+				label: `Review PR ${ref.repo}#${ref.number} from conversation`,
+				value: { kind: "detected-pr" as const, ref },
+			})),
+			{
+				label: "1. Review against a base branch (PR Style)",
+				value: { kind: "base-branch" },
+			},
+			{
+				label: "2. Review uncommitted changes",
+				value: { kind: "uncommitted" },
+			},
+			{
+				label: "3. Review a specific commit",
+				value: { kind: "commit" },
+			},
+		];
+
+		if (!extraInstructions) {
+			choices.push({
+				label: "4. Custom review instructions",
+				value: { kind: "custom" },
+			});
+		}
 
-		const mode = await ctx.ui.select("Review Mode", menuItems);
+		const selected = await ctx.ui.select(
+			"Review Mode",
+			choices.map(choice => choice.label),
+		);
+		if (!selected) return undefined;
 
-		if (!mode) return undefined;
+		const selectedChoice = choices.find(choice => choice.label === selected)?.value;
+		if (!selectedChoice) return undefined;
 
-		const modeNum = parseInt(mode[0], 10);
+		switch (selectedChoice.kind) {
+			case "detected-pr":
+				return buildPrReviewPrompt(this.api, ctx, selectedChoice.ref, extraInstructions ?? "");
 
-		switch (modeNum) {
-			case 1: {
-				// PR-style review against base branch
+			case "base-branch": {
 				const branches = await getGitBranches(this.api);
 				if (branches.length === 0) {
 					ctx.ui.notify("No git branches found", "error");
@@ -308,62 +547,43 @@ export class ReviewCommand implements CustomCommand {
 					return undefined;
 				}
 
-				if (!diffText.trim()) {
-					ctx.ui.notify(`No changes between ${baseBranch} and ${currentBranch}`, "warning");
-					return undefined;
-				}
-
-				const stats = parseDiff(diffText);
-				if (stats.files.length === 0) {
-					ctx.ui.notify("No reviewable files (all changes filtered out)", "warning");
-					return undefined;
-				}
-
-				return buildReviewPrompt(
+				return buildReviewPromptFromDiff(
+					ctx,
 					`Reviewing changes between \`${baseBranch}\` and \`${currentBranch}\` (PR-style)`,
-					stats,
 					diffText,
-					{ additionalInstructions: extraInstructions },
+					extraInstructions,
+					`No changes between ${baseBranch} and ${currentBranch}`,
 				);
 			}
 
-			case 2: {
+			case "uncommitted": {
 				const reviewDiff = await getUncommittedReviewDiff(this.api).catch(err => {
 					ctx.ui.notify(`Failed to get diff: ${err instanceof Error ? err.message : String(err)}`, "error");
 					return undefined;
 				});
 				if (!reviewDiff) return undefined;
 
-				if (!reviewDiff.diffText.trim()) {
-					ctx.ui.notify(reviewDiff.emptyMessage ?? "No diff content found", "warning");
-					return undefined;
-				}
-
-				const stats = parseDiff(reviewDiff.diffText);
-				if (stats.files.length === 0) {
-					ctx.ui.notify("No reviewable files (all changes filtered out)", "warning");
-					return undefined;
-				}
-
-				return buildReviewPrompt(reviewDiff.mode, stats, reviewDiff.diffText, {
-					additionalInstructions: extraInstructions,
-					diffInstruction: reviewDiff.diffInstruction,
-				});
+				return buildReviewPromptFromDiff(
+					ctx,
+					reviewDiff.mode,
+					reviewDiff.diffText,
+					extraInstructions,
+					reviewDiff.emptyMessage ?? "No diff content found",
+					{ diffInstruction: reviewDiff.diffInstruction },
+				);
 			}
 
-			case 3: {
-				// Specific commit
+			case "commit": {
 				const commits = await getRecentCommits(this.api, 20);
 				if (commits.length === 0) {
 					ctx.ui.notify("No commits found", "error");
 					return undefined;
 				}
 
-				const selected = await ctx.ui.select("Select commit to review", commits);
-				if (!selected) return undefined;
+				const selectedCommit = await ctx.ui.select("Select commit to review", commits);
+				if (!selectedCommit) return undefined;
 
-				// Extract commit hash from selection (format: "abc1234 message")
-				const hash = selected.split(" ")[0];
+				const hash = selectedCommit.split(" ")[0];
 
 				let diffText: string;
 				try {
@@ -373,24 +593,17 @@ export class ReviewCommand implements CustomCommand {
 					return undefined;
 				}
 
-				if (!diffText.trim()) {
-					ctx.ui.notify("Commit has no diff content", "warning");
-					return undefined;
-				}
-
-				const stats = parseDiff(diffText);
-				if (stats.files.length === 0) {
-					ctx.ui.notify("No reviewable files in commit (all changes filtered out)", "warning");
-					return undefined;
-				}
-
-				return buildReviewPrompt(`Reviewing commit \`${hash}\``, stats, diffText, {
-					additionalInstructions: extraInstructions,
-				});
+				return buildReviewPromptFromDiff(
+					ctx,
+					`Reviewing commit \`${hash}\``,
+					diffText,
+					extraInstructions,
+					"Commit has no diff content",
+					{ filteredMessage: "No reviewable files in commit (all changes filtered out)" },
+				);
 			}
 
-			case 4: {
-				// Custom instructions with opportunistic current-diff context.
+			case "custom": {
 				const instructions = await ctx.ui.editor(
 					"Enter custom review instructions",
 					"Review the following:\n\n",
@@ -403,7 +616,6 @@ export class ReviewCommand implements CustomCommand {
 
 				if (reviewDiff?.diffText.trim()) {
 					const stats = parseDiff(reviewDiff.diffText);
-					// Even if all files filtered, include the custom instructions
 					return buildReviewPrompt(
 						`Custom review: ${instructions.split("\n")[0].slice(0, 60)}…`,
 						stats,
@@ -417,9 +629,6 @@ export class ReviewCommand implements CustomCommand {
 
 				return buildCustomReviewPrompt(instructions);
 			}
-
-			default:
-				return undefined;
 		}
 	}
 }

package/src/extensibility/extensions/runner.ts

@@ -543,7 +543,9 @@ export class ExtensionRunner {
 			event.type === "session_before_tree"
 		);
 	}
-
+	#isSessionShutdownEvent(event: RunnerEmitEvent): event is Extract<RunnerEmitEvent, { type: "session_shutdown" }> {
+		return event.type === "session_shutdown";
+	}
 	async #runHandlerWithTimeout<TEvent extends { type: string }, TResult>(
 		handler: (event: TEvent, ctx: ExtensionContext) => Promise<TResult | undefined> | TResult | undefined,
 		event: TEvent,
@@ -588,6 +590,20 @@ export class ExtensionRunner {
 		const ctx = this.createContext();
 		let result: SessionBeforeEventResult | SessionCompactingResult | undefined;
 
+		if (this.#isSessionShutdownEvent(event)) {
+			const timeoutMs = handlerTimeoutForEvent(event.type);
+			const promises: Promise<unknown>[] = [];
+			for (const ext of this.extensions) {
+				const handlers = ext.handlers.get(event.type);
+				if (!handlers || handlers.length === 0) continue;
+				for (const handler of handlers) {
+					promises.push(this.#runHandlerWithTimeout(handler, event, ctx, ext, timeoutMs));
+				}
+			}
+			await Promise.all(promises);
+			return result as RunnerEmitResult<TEvent>;
+		}
+
 		for (const ext of this.extensions) {
 			const handlers = ext.handlers.get(event.type);
 			if (!handlers || handlers.length === 0) continue;