whitesmith 0.0.2 → 0.0.4

package/src/git.ts

@@ -13,6 +13,7 @@ export class GitManager {
 
 	constructor(workDir: string) {
 		this.workDir = workDir;
+		this.ensureExcluded();
 	}
 
 	private async git(args: string): Promise<string> {
@@ -28,17 +29,28 @@ export class GitManager {
 	}
 
 	/**
-	 * Remove all .whitesmith-* temp files from the working directory.
+	 * Ensure .whitesmith-* is excluded from git via .git/info/exclude.
+	 * This prevents the agent from accidentally committing temp files
+	 * without requiring changes to the user's .gitignore.
 	 */
-	cleanupTempFiles(): void {
-		for (const entry of fs.readdirSync(this.workDir)) {
-			if (entry.startsWith('.whitesmith-')) {
-				try {
-					fs.unlinkSync(path.join(this.workDir, entry));
-				} catch {
-					// ignore
-				}
-			}
+	private ensureExcluded(): void {
+		const gitDir = path.join(this.workDir, '.git');
+		if (!fs.existsSync(gitDir)) return;
+
+		const excludeDir = path.join(gitDir, 'info');
+		const excludeFile = path.join(excludeDir, 'exclude');
+		const pattern = '.whitesmith-*';
+
+		fs.mkdirSync(excludeDir, {recursive: true});
+
+		let content = '';
+		if (fs.existsSync(excludeFile)) {
+			content = fs.readFileSync(excludeFile, 'utf-8');
+		}
+
+		if (!content.split('\n').some((line) => line.trim() === pattern)) {
+			const separator = content.length > 0 && !content.endsWith('\n') ? '\n' : '';
+			fs.appendFileSync(excludeFile, `${separator}${pattern}\n`);
 		}
 	}
 
@@ -72,31 +84,12 @@ export class GitManager {
 	/**
 	 * Stage all changes and commit
 	 */
-	async commitAll(message: string, exclude?: string[]): Promise<boolean> {
-		// Always exclude whitesmith temp files
-		const allExclude = ['.whitesmith-*', ...(exclude || [])];
-
-		// Remove any whitesmith temp files from the working tree
-		this.cleanupTempFiles();
-
+	async commitAll(message: string): Promise<boolean> {
 		// Check if there are changes
 		const status = await this.git('status --porcelain');
 		if (!status) return false;
 
-		// Add all then unstage excluded patterns
 		await this.git('add -A');
-		for (const pattern of allExclude) {
-			try {
-				await this.git(`reset HEAD -- ${pattern}`);
-			} catch {
-				// File might not be staged
-			}
-		}
-
-		// Check if anything is still staged after exclusions
-		const staged = await this.git('diff --cached --name-only');
-		if (!staged) return false;
-
 		await this.git(`commit -m "${message.replace(/"/g, '\\"')}"`);
 		return true;
 	}

package/src/harnesses/pi.ts

@@ -49,10 +49,29 @@ export class PiHarness implements AgentHarness {
 			);
 		}
 
-		// Check auth.json exists and has the expected provider
+		// Check for auth configuration (auth.json or models.json)
 		const homeDir = process.env.HOME || homedir();
 		const authJsonPath = path.join(homeDir, '.pi', 'agent', 'auth.json');
-		if (fs.existsSync(authJsonPath)) {
+		const modelsJsonPath = path.join(homeDir, '.pi', 'agent', 'models.json');
+		const hasAuthJson = fs.existsSync(authJsonPath);
+		const hasModelsJson = fs.existsSync(modelsJsonPath);
+
+		if (hasModelsJson) {
+			try {
+				const modelsData = JSON.parse(fs.readFileSync(modelsJsonPath, 'utf-8'));
+				const providers = Object.keys(modelsData.providers || {});
+				console.log(
+					`Models config found at ${modelsJsonPath} with providers: ${providers.join(', ')}`,
+				);
+				if (!modelsData.providers?.[this.provider]) {
+					console.warn(
+						`WARNING: Provider '${this.provider}' not found in models.json (has: ${providers.join(', ')})`,
+					);
+				}
+			} catch (e: any) {
+				console.warn(`WARNING: Could not parse models.json: ${e.message}`);
+			}
+		} else if (hasAuthJson) {
 			try {
 				const authData = JSON.parse(fs.readFileSync(authJsonPath, 'utf-8'));
 				const providers = Object.keys(authData);
@@ -66,7 +85,9 @@ export class PiHarness implements AgentHarness {
 				console.warn(`WARNING: Could not parse auth.json: ${e.message}`);
 			}
 		} else {
-			console.warn(`WARNING: No auth.json found at ${authJsonPath}`);
+			console.warn(
+				`WARNING: No auth configuration found (checked ${modelsJsonPath} and ${authJsonPath})`,
+			);
 		}
 
 		// Validate auth by making a minimal API call
@@ -87,9 +108,9 @@ export class PiHarness implements AgentHarness {
 				[stderr, stdout].filter(Boolean).join('\n') || error.message || 'unknown error';
 			throw new Error(
 				`Agent auth validation failed. Ensure valid credentials are configured.\n` +
-					`Set ANTHROPIC_API_KEY or configure OAuth via ~/.pi/agent/auth.json\n` +
-					`Auth file path: ${authJsonPath}\n` +
-					`Auth file exists: ${fs.existsSync(authJsonPath)}\n` +
+					`Configure providers via ~/.pi/agent/models.json or ~/.pi/agent/auth.json\n` +
+					`models.json exists: ${hasModelsJson}\n` +
+					`auth.json exists: ${hasAuthJson}\n` +
 					`HOME: ${homeDir}\n` +
 					`Details: ${details.slice(0, 800)}`,
 			);

package/src/index.ts

@@ -1,7 +1,15 @@
 export {Orchestrator} from './orchestrator.js';
 export {TaskManager} from './task-manager.js';
 export {GitManager} from './git.js';
-export {buildInvestigatePrompt, buildImplementPrompt} from './prompts.js';
+export {
+	buildInvestigatePrompt,
+	buildImplementPrompt,
+	buildReviewTaskProposalPrompt,
+	buildReviewImplementationPRPrompt,
+	buildReviewTaskCompletionPrompt,
+} from './prompts.js';
+export {performReview, detectReviewTarget, parseReviewVerdict} from './review.js';
+export type {ReviewConfig, ReviewTarget, ReviewResult, ReviewVerdict} from './review.js';
 
 export type {IssueProvider} from './providers/issue-provider.js';
 export {GitHubProvider} from './providers/github.js';

package/src/orchestrator.ts

@@ -6,6 +6,8 @@ import {TaskManager} from './task-manager.js';
 import {GitManager} from './git.js';
 import {buildInvestigatePrompt, buildImplementPrompt} from './prompts.js';
 import {isAutoWorkEnabled} from './auto-work.js';
+import {performReview} from './review.js';
+import type {ReviewResult} from './review.js';
 
 /**
  * Main orchestrator for whitesmith.
@@ -44,6 +46,9 @@ export class Orchestrator {
 		console.log(`Agent command: ${this.config.agentCmd}`);
 		console.log(`Provider: ${this.config.provider}`);
 		console.log(`Model: ${this.config.model}`);
+		if (this.config.issueNumber !== undefined) {
+			console.log(`Target issue: #${this.config.issueNumber}`);
+		}
 		console.log('');
 
 		// Skip agent validation and label creation in dry-run mode
@@ -57,6 +62,12 @@ export class Orchestrator {
 			await this.issues.ensureLabels(Object.values(LABELS));
 		}
 
+		// Delegate to single-issue mode if --issue is set
+		if (this.config.issueNumber !== undefined) {
+			await this.runForIssue(this.config.issueNumber);
+			return;
+		}
+
 		for (let i = 1; i <= this.config.maxIterations; i++) {
 			console.log('');
 			console.log(`=== Iteration ${i}/${this.config.maxIterations} ===`);
@@ -122,6 +133,146 @@ export class Orchestrator {
 		console.log('=== Iteration limit reached ===');
 	}
 
+	/**
+	 * Run the full pipeline for a single issue.
+	 *
+	 * Re-fetches the issue after each action to get updated labels, then decides
+	 * the next action based on the current state. Loops until idle or the
+	 * iteration limit is reached.
+	 */
+	private async runForIssue(issueNumber: number): Promise<void> {
+		console.log(`Running single-issue mode for issue #${issueNumber}`);
+
+		for (let i = 1; i <= this.config.maxIterations; i++) {
+			console.log('');
+			console.log(`=== Iteration ${i}/${this.config.maxIterations} ===`);
+
+			// Make sure we're on main with latest
+			await this.git.fetch();
+			await this.git.checkoutMain();
+
+			// Re-fetch the issue to get current labels
+			const issue = await this.issues.getIssue(issueNumber);
+
+			// Determine the action based on the issue's current state
+			const action = await this.decideActionForIssue(issue);
+			console.log(`Action: ${action.type}`);
+
+			if (this.config.dryRun) {
+				switch (action.type) {
+					case 'reconcile':
+						console.log(`Would reconcile issue #${action.issue.number}: ${action.issue.title}`);
+						break;
+					case 'auto-approve':
+						console.log(
+							`Would auto-approve task PR for issue #${action.issue.number}: ${action.issue.title}`,
+						);
+						break;
+					case 'investigate':
+						console.log(`Would investigate issue #${action.issue.number}: ${action.issue.title}`);
+						break;
+					case 'implement':
+						console.log(
+							`Would implement task ${action.task.id}: ${action.task.title} (issue #${action.issue.number})`,
+						);
+						break;
+					case 'idle':
+						console.log('Nothing to do. Issue is either completed or no actions are applicable.');
+						break;
+				}
+				return;
+			}
+
+			switch (action.type) {
+				case 'reconcile':
+					await this.reconcile(action.issue);
+					break;
+				case 'auto-approve':
+					await this.autoApprove(action.issue);
+					break;
+				case 'investigate':
+					await this.investigate(action.issue);
+					break;
+				case 'implement':
+					await this.implement(action.task, action.issue);
+					break;
+				case 'idle':
+					console.log('Nothing to do. Issue is either completed or no actions are applicable.');
+					return;
+			}
+
+			if (!this.config.noSleep && i < this.config.maxIterations) {
+				console.log('Sleeping 5s...');
+				await new Promise((r) => setTimeout(r, 5000));
+			}
+		}
+
+		console.log('');
+		console.log('=== Iteration limit reached ===');
+	}
+
+	/**
+	 * Decide the next action for a single issue based on its current labels.
+	 */
+	private async decideActionForIssue(issue: Issue): Promise<Action> {
+		const labels = issue.labels;
+
+		// Handle stale investigating label (crashed previous run)
+		if (labels.includes(LABELS.INVESTIGATING)) {
+			console.log(`Issue #${issue.number} has stale '${LABELS.INVESTIGATING}' label, clearing it`);
+			await this.issues.removeLabel(issue.number, LABELS.INVESTIGATING);
+			// Treat as uninvestigated — re-investigate
+			return {type: 'investigate', issue};
+		}
+
+		// tasks-accepted: check if all tasks are done (reconcile) or implement next task
+		if (labels.includes(LABELS.TASKS_ACCEPTED)) {
+			const allDone = await this.allTasksCompletedOnBranch(issue.number);
+			if (allDone) {
+				return {type: 'reconcile', issue};
+			}
+
+			// Find an available task to implement
+			const implementAction = await this.findAvailableTask([issue]);
+			if (implementAction) {
+				return implementAction;
+			}
+
+			return {type: 'idle'};
+		}
+
+		// tasks-proposed: check if PR was already merged (tasks on main) → transition inline
+		if (labels.includes(LABELS.TASKS_PROPOSED)) {
+			if (this.tasks.hasRemainingTasks(issue.number)) {
+				// Tasks exist on main = investigate PR was merged
+				console.log(`Issue #${issue.number}: tasks PR merged, transitioning to tasks-accepted`);
+				await this.issues.removeLabel(issue.number, LABELS.TASKS_PROPOSED);
+				await this.issues.addLabel(issue.number, LABELS.TASKS_ACCEPTED);
+				// Find an available task to implement
+				const implementAction = await this.findAvailableTask([issue]);
+				if (implementAction) {
+					return implementAction;
+				}
+				return {type: 'idle'};
+			}
+
+			// PR not yet merged — auto-approve if auto-work is enabled
+			if (isAutoWorkEnabled(this.config, issue)) {
+				return {type: 'auto-approve', issue};
+			}
+
+			return {type: 'idle'};
+		}
+
+		// completed: nothing to do
+		if (labels.includes(LABELS.COMPLETED)) {
+			return {type: 'idle'};
+		}
+
+		// No whitesmith labels — investigate
+		return {type: 'investigate', issue};
+	}
+
 	/**
 	 * Check whether all tasks for an issue have been completed on the issue branch.
 	 * Works without checking out the branch by inspecting the remote via git ls-tree.
@@ -141,11 +292,19 @@ export class Orchestrator {
 	 */
 	private async decideAction(): Promise<Action> {
 		// Priority 1: Reconcile — issues with tasks-accepted where all tasks are done
+		// but no PR exists yet (safety net for crash recovery).
 		const acceptedIssues = await this.issues.listIssues({labels: [LABELS.TASKS_ACCEPTED]});
 		for (const issue of acceptedIssues) {
 			const allDone = await this.allTasksCompletedOnBranch(issue.number);
 			if (allDone) {
-				return {type: 'reconcile', issue};
+				// Only reconcile if no PR exists yet — if a PR is already open,
+				// the issue is waiting for merge and there's nothing more to do.
+				const branch = `issue/${issue.number}`;
+				const existingPR = await this.issues.getPRForBranch(branch);
+				if (!existingPR || existingPR.state === 'closed') {
+					return {type: 'reconcile', issue};
+				}
+				// PR exists and is open or merged — skip
 			}
 		}
 
@@ -226,13 +385,16 @@ export class Orchestrator {
 	}
 
 	/**
-	 * Phase 1: Reconcile — mark issue as completed, close it.
-	 * Also serves as safety net: creates PR if all tasks are done but no PR exists
+	 * Phase 1: Reconcile — safety net for crash recovery.
+	 * Creates PR if all tasks are done on the issue branch but no PR exists
 	 * (e.g. agent crashed after last task push but before PR creation).
+	 *
+	 * Does NOT close the issue — that happens when the PR is merged and the
+	 * CLI `reconcile` command detects that task files are gone from main.
 	 */
 	private async reconcile(issue: Issue): Promise<void> {
 		console.log(`Reconciling issue #${issue.number}: ${issue.title}`);
-		console.log('All tasks completed. Marking issue as done.');
+		console.log('All tasks completed on branch. Ensuring PR exists.');
 
 		// Safety net: ensure a PR exists for the issue branch
 		const branch = `issue/${issue.number}`;
@@ -253,22 +415,17 @@ export class Orchestrator {
 					body: `## Implementation for #${issue.number}\n\n${taskSummary}\n\n---\n*Implemented by whitesmith*\n\nCloses #${issue.number}`,
 				});
 				console.log(`Safety net PR created: ${prUrl}`);
+			} else {
+				console.log(`PR already exists: ${existingPR.url}`);
 			}
 		}
 
-		await this.issues.addLabel(issue.number, LABELS.COMPLETED);
-		await this.issues.removeLabel(issue.number, LABELS.TASKS_ACCEPTED);
-		await this.issues.comment(
-			issue.number,
-			`✅ All tasks for this issue have been implemented and merged. Closing.`,
-		);
-		await this.issues.closeIssue(issue.number);
-
-		console.log(`Issue #${issue.number} closed.`);
+		console.log(`Issue #${issue.number} awaiting PR merge.`);
 	}
 
 	/**
-	 * Phase 1.5: Auto-approve — merge the task-proposal PR when auto-work is enabled
+	 * Phase 1.5: Auto-approve — merge the task-proposal PR when auto-work is enabled.
+	 * When review is enabled, runs a review first and only merges if approved.
 	 */
 	private async autoApprove(issue: Issue): Promise<void> {
 		console.log(`Auto-approving task PR for issue #${issue.number}: ${issue.title}`);
@@ -281,6 +438,27 @@ export class Orchestrator {
 			return;
 		}
 
+		// Run review before merging (if review is enabled)
+		if (this.config.review) {
+			let reviewResult: ReviewResult | null = null;
+			try {
+				reviewResult = await this.reviewTaskProposal(issue.number);
+			} catch (error) {
+				console.error('Review failed:', error instanceof Error ? error.message : error);
+			}
+
+			if (reviewResult && reviewResult.verdict === 'request_changes') {
+				console.log(`Review requested changes for task PR #${pr.number}. Skipping auto-merge.`);
+				await this.issues.comment(
+					issue.number,
+					`🔍 Review of task PR #${pr.number} requested changes. Auto-merge skipped — please review manually.`,
+				);
+				// Remove tasks-proposed so auto-approve doesn't retry every iteration
+				await this.issues.removeLabel(issue.number, LABELS.TASKS_PROPOSED);
+				return;
+			}
+		}
+
 		await this.issues.mergePR(pr.number);
 		console.log(`Merged PR #${pr.number}: ${pr.url}`);
 
@@ -396,6 +574,17 @@ export class Orchestrator {
 				);
 
 				console.log(`PR created: ${prUrl}`);
+
+				// Queue review of the task proposal (skip if auto-work — auto-approve will review)
+				if (this.config.review && !isAutoWorkEnabled(this.config, issue)) {
+					await this.git.checkoutMain();
+					try {
+						await this.reviewTaskProposal(issue.number);
+					} catch (error) {
+						console.error('Review failed:', error instanceof Error ? error.message : error);
+					}
+					return; // Already on main after review
+				}
 			}
 		} catch (error) {
 			console.error('Investigation failed:', error instanceof Error ? error.message : error);
@@ -496,6 +685,16 @@ export class Orchestrator {
 					}
 
 					console.log(`PR created: ${prUrl}`);
+					// Queue review of the implementation PR
+					if (this.config.review) {
+						await this.git.checkoutMain();
+						try {
+							await this.reviewImplementationPR(issue.number);
+						} catch (error) {
+							console.error('Review failed:', error instanceof Error ? error.message : error);
+						}
+						return; // Already on main after review
+					}
 				} else {
 					console.log(
 						`Task ${task.id} committed. ${remainingTasks.length} task(s) remaining for issue #${issue.number}.`,
@@ -509,4 +708,44 @@ export class Orchestrator {
 		// Return to main
 		await this.git.checkoutMain();
 	}
+
+	/**
+	 * Review a task proposal (investigate PR).
+	 * Posts the review as a comment on the task proposal PR.
+	 * Returns the review result so callers can check the verdict.
+	 */
+	private async reviewTaskProposal(issueNumber: number): Promise<ReviewResult> {
+		console.log(`Reviewing task proposal for issue #${issueNumber}...`);
+		return performReview(
+			{type: 'issue-tasks', issueNumber},
+			{
+				workDir: this.config.workDir,
+				repo: this.config.repo,
+				logFile: this.config.logFile,
+				post: !this.config.noPush,
+			},
+			this.issues,
+			this.agent,
+		);
+	}
+
+	/**
+	 * Review an implementation PR (all tasks completed for an issue).
+	 * Posts the review as a comment on the implementation PR.
+	 * Returns the review result so callers can check the verdict.
+	 */
+	private async reviewImplementationPR(issueNumber: number): Promise<ReviewResult> {
+		console.log(`Reviewing implementation for issue #${issueNumber}...`);
+		return performReview(
+			{type: 'issue-tasks-completed', issueNumber},
+			{
+				workDir: this.config.workDir,
+				repo: this.config.repo,
+				logFile: this.config.logFile,
+				post: !this.config.noPush,
+			},
+			this.issues,
+			this.agent,
+		);
+	}
 }