@payconductor/houndsman 0.7.0 → 0.10.0

package/src/server/pr-inbox.ts

@@ -19,6 +19,13 @@ export type WorktreeState = {
 	sample: string[];
 };
 
+/** Run associada à branch de uma PR. */
+export type PrRunInfo = {
+	slug: string;
+	worktreePath?: string;
+	prNumber?: number;
+};
+
 /** PR aberta exibida na sidebar. */
 export type PrListItem = {
 	number: number;
@@ -32,6 +39,8 @@ export type PrListItem = {
 	url?: string;
 	/** Run local correspondente à branch, quando existir. */
 	runSlug?: string;
+	/** Worktree ativo da PR (revisão paralela). */
+	worktreePath?: string;
 };
 
 /** Resposta de `GET /api/prs`. */
@@ -70,11 +79,12 @@ type GhPrListItem = {
 
 function toItem(
 	raw: GhPrListItem,
-	runSlugs: ReadonlyMap<string, string>,
+	runs: ReadonlyMap<string, PrRunInfo>,
 ): PrListItem | null {
 	const number = Number(raw.number);
 	const headRefName = raw.headRefName?.trim();
 	if (!Number.isFinite(number) || number <= 0 || !headRefName) return null;
+	const run = runs.get(headRefName);
 	return {
 		number,
 		title: raw.title?.trim() || `PR #${number}`,
@@ -85,7 +95,8 @@ function toItem(
 		isDraft: Boolean(raw.isDraft),
 		reviewDecision: raw.reviewDecision?.trim() || undefined,
 		url: raw.url,
-		runSlug: runSlugs.get(headRefName),
+		runSlug: run?.slug,
+		worktreePath: run?.worktreePath,
 	};
 }
 
@@ -115,7 +126,7 @@ export class PrInbox {
 	}
 
 	/** Lista as PRs abertas (limite 50) e o estado local do repositório. */
-	list(runSlugs: ReadonlyMap<string, string> = new Map()): PrListResponse {
+	list(runs: ReadonlyMap<string, PrRunInfo> = new Map()): PrListResponse {
 		const currentBranch = this.git.currentBranch();
 		const worktree = this.worktree();
 		const result = this.ghRunner([
@@ -162,7 +173,7 @@ export class PrInbox {
 		}
 
 		const prs = (parsed as GhPrListItem[])
-			.map((item) => toItem(item, runSlugs))
+			.map((item) => toItem(item, runs))
 			.filter((item): item is PrListItem => item !== null)
 			.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""));
 

package/src/server/run-repository.ts

@@ -5,6 +5,7 @@
  * O slug continua sendo o branch-slug (estável nas URLs).
  */
 
+import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import {
 	applyFindingUpdate,
@@ -35,7 +36,10 @@ import {
 import { pingFindingsStatus } from "../core/run-status";
 import { systemClock } from "../core/services/clock";
 import { defaultGhRunner } from "../core/services/gh-client";
+import type { WorktreeManager } from "../core/services/worktree-manager";
+import { workRoot } from "../core/storage/paths";
 import type { RepoIdentity, ReviewRecord, StorageProvider } from "../core/storage/types";
+import { ReviewWorkArea } from "../core/storage/work-area";
 import type { Severity } from "../core/types";
 import { isSlug } from "./artifacts";
 import { fetchPrComments, type PrCommentsResponse } from "./pr-comments";
@@ -44,6 +48,10 @@ import { fetchPrComments, type PrCommentsResponse } from "./pr-comments";
 export type RunListItem = {
 	slug: string;
 	branch: string;
+	/** Worktree onde a run foi executada (ausente = clone principal). */
+	worktreePath?: string;
+	/** PR revisada (quando iniciada via `--pr`). */
+	prNumber?: number;
 	updatedAt?: string;
 	startedAt?: string;
 	heartbeatAt?: string;
@@ -55,6 +63,10 @@ export type RunListItem = {
 export type RunDetail = {
 	slug: string;
 	branch: string;
+	/** Worktree onde a run foi executada (ausente = clone principal). */
+	worktreePath?: string;
+	/** PR revisada (quando iniciada via `--pr`). */
+	prNumber?: number;
 	status: ReviewRecord | null;
 	manifest: unknown;
 	summary: FindingsSummary;
@@ -63,6 +75,18 @@ export type RunDetail = {
 	deleted: string[];
 };
 
+/** Resultado da exclusão de uma run. */
+export type DeleteRunResult = {
+	deleted: boolean;
+	/** O usuário pediu para remover o worktree. */
+	worktreeRequested: boolean;
+	/** O worktree foi de fato removido. */
+	worktreeRemoved: boolean;
+	worktreePath?: string;
+	/** Aviso quando o worktree não pôde ser removido. */
+	warning?: string;
+};
+
 /** Resultado do envio dos findings à PR. */
 export type SubmitResult =
 	| { available: false; reason: string }
@@ -81,15 +105,18 @@ export class RunRepository {
 	private readonly storage: StorageProvider;
 	private readonly repo: RepoIdentity;
 	private readonly ghRunner: GhRunner;
+	private readonly worktrees?: WorktreeManager;
 
 	constructor(
 		storage: StorageProvider,
 		repo: RepoIdentity,
 		ghRunner: GhRunner = defaultGhRunner,
+		worktrees?: WorktreeManager,
 	) {
 		this.storage = storage;
 		this.repo = repo;
 		this.ghRunner = ghRunner;
+		this.worktrees = worktrees;
 	}
 
 	/** `true` se o slug aponta para uma run do repositório atual. */
@@ -104,6 +131,8 @@ export class RunRepository {
 			return {
 				slug: review.slug,
 				branch: review.branch,
+				worktreePath: review.worktreePath,
+				prNumber: review.prNumber,
 				updatedAt: review.updatedAt,
 				startedAt: review.startedAt,
 				heartbeatAt: review.heartbeatAt,
@@ -122,6 +151,23 @@ export class RunRepository {
 		);
 	}
 
+	/** Mapa branch → run + worktree (sidebar de PRs). */
+	workspaceIndex(): Map<
+		string,
+		{ slug: string; worktreePath?: string; prNumber?: number }
+	> {
+		return new Map(
+			this.storage.listReviews(this.repo.key).map((review) => [
+				review.branch,
+				{
+					slug: review.slug,
+					worktreePath: review.worktreePath,
+					prNumber: review.prNumber,
+				},
+			]),
+		);
+	}
+
 	/** Detalhe da run (null se o slug for inválido). */
 	detail(slug: string): RunDetail | null {
 		const review = this.findBySlug(slug);
@@ -135,6 +181,8 @@ export class RunRepository {
 		return {
 			slug: review.slug,
 			branch: review.branch,
+			worktreePath: review.worktreePath,
+			prNumber: review.prNumber,
 			status: review,
 			manifest: this.readArtifactJson(review, "manifest.json"),
 			summary: summarize(state),
@@ -144,6 +192,49 @@ export class RunRepository {
 		};
 	}
 
+	/**
+	 * Apaga a run por completo: staging local, findings, histórico, artefatos e a
+	 * review. Opcionalmente remove o worktree (com `--force`, pois a run foi
+	 * confirmada para exclusão).
+	 */
+	delete(
+		slug: string,
+		options: { removeWorktree?: boolean } = {},
+	): DeleteRunResult | null {
+		const review = this.findBySlug(slug);
+		if (!review) return null;
+
+		const worktreePath = review.worktreePath;
+		const removeWorktree = options.removeWorktree === true && Boolean(worktreePath);
+		let worktreeRemoved = false;
+		let warning: string | undefined;
+
+		if (removeWorktree && worktreePath) {
+			if (this.worktrees) {
+				const result = this.worktrees.remove(worktreePath, { force: true });
+				worktreeRemoved = result.removed;
+				if (!result.removed) {
+					warning = result.detail ?? "worktree não removido";
+				}
+			} else {
+				warning = "worktree não gerenciado por este servidor";
+			}
+		}
+
+		// Staging atual (dentro do worktree quando existe) + legado no home.
+		new ReviewWorkArea(review).clean();
+		new ReviewWorkArea(review, workRoot()).clean();
+
+		this.storage.deleteReview(review.id);
+		return {
+			deleted: true,
+			worktreeRequested: options.removeWorktree === true,
+			worktreeRemoved,
+			worktreePath,
+			warning,
+		};
+	}
+
 	/** Aplica `VACUUM`/`optimize` no backend (chamado no start do server). */
 	maintain(): void {
 		this.storage.maintain();
@@ -171,6 +262,12 @@ export class RunRepository {
 		return this.storage.readFindings(review.id) ?? emptyState(review.branch);
 	}
 
+	/** Raiz dos arquivos da review: worktree vivo ou clone principal. */
+	private rootOf(review: ReviewRecord): string {
+		const worktree = review.worktreePath;
+		return worktree && existsSync(worktree) ? worktree : this.repo.root;
+	}
+
 	private readArtifactJson<T>(review: ReviewRecord, name: string): T | null {
 		const artifact = this.storage.readArtifact(review.id, name);
 		if (!artifact) return null;
@@ -252,7 +349,7 @@ export class RunRepository {
 		const review = this.findBySlug(slug);
 		if (!review) return null;
 		const state = this.loadState(review);
-		const result = syncState(state, fileReader(process.cwd()));
+		const result = syncState(state, fileReader(this.rootOf(review)));
 		this.storage.writeFindings(review.id, state);
 		pingFindingsStatus(this.storage, review.id, state);
 		return { result, summary: summarize(state) };
@@ -336,5 +433,9 @@ function toClientFinding(
 	finding: FindingState,
 	review: ReviewRecord,
 ): FindingState & { absFile: string } {
-	return { ...finding, absFile: resolve(review.repoRoot, finding.file) };
+	const root =
+		review.worktreePath && existsSync(review.worktreePath)
+			? review.worktreePath
+			: review.repoRoot;
+	return { ...finding, absFile: resolve(root, finding.file) };
 }