pi-harness-runtime 0.10.11 → 0.10.13

package/harness/project-detector/detector.ts

@@ -0,0 +1,328 @@
+/**
+ * Project Detector — RFC-0014
+ *
+ * Auto-detect project framework and choose suitable dummy data,
+ * seed strategy, and E2E approach.
+ */
+
+import type {
+	ProjectType,
+	ProjectDetection,
+	SeedStrategy,
+	E2EStrategy,
+} from "../../packages/types/src/runtime-types.ts";
+import { readJson } from "../../cli.ts";
+// @ts-expect-error - Bun has built-in Node.js types
+import { join } from "node:path";
+
+export interface DetectionSignal {
+	pattern: string;
+	weight: number;
+	matched: boolean;
+}
+
+export interface ProjectDetectorOptions {
+	rootDir?: string;
+	maxDepth?: number;
+}
+
+export class ProjectDetector {
+	private readonly signals: Map<ProjectType, DetectionSignal[]> = new Map([
+		[
+			"frappe_erpnext",
+			[
+				{ pattern: "frappe-bench/sites", weight: 0.3, matched: false },
+				{ pattern: "frappe-bench/apps", weight: 0.2, matched: false },
+				{ pattern: "hooks.py", weight: 0.2, matched: false },
+				{ pattern: "doctype/", weight: 0.2, matched: false },
+				{ pattern: "bench", weight: 0.1, matched: false },
+			],
+		],
+		[
+			"frappe_spa",
+			[
+				{
+					pattern: "frappe-bench/apps/*/frontend",
+					weight: 0.3,
+					matched: false,
+				},
+				{ pattern: "vite.config.", weight: 0.2, matched: false },
+				{ pattern: ".reactrc", weight: 0.15, matched: false },
+				{ pattern: "package.json", weight: 0.15, matched: false },
+				{ pattern: "tsx", weight: 0.2, matched: false },
+			],
+		],
+		[
+			"nextjs",
+			[
+				{ pattern: "next.config.", weight: 0.3, matched: false },
+				{ pattern: "package.json", weight: 0.15, matched: false },
+				{ pattern: "pages/", weight: 0.2, matched: false },
+				{ pattern: "app/", weight: 0.25, matched: false },
+				{ pattern: '"next"', weight: 0.1, matched: false },
+			],
+		],
+		[
+			"react_vite",
+			[
+				{ pattern: "vite.config.", weight: 0.3, matched: false },
+				{ pattern: "package.json", weight: 0.15, matched: false },
+				{ pattern: "src/main.tsx", weight: 0.25, matched: false },
+				{ pattern: "index.html", weight: 0.15, matched: false },
+				{ pattern: '"vite"', weight: 0.15, matched: false },
+			],
+		],
+		[
+			"django",
+			[
+				{ pattern: "manage.py", weight: 0.4, matched: false },
+				{ pattern: "settings.py", weight: 0.25, matched: false },
+				{ pattern: "wsgi.py", weight: 0.15, matched: false },
+				{ pattern: "migrations/", weight: 0.2, matched: false },
+			],
+		],
+		[
+			"laravel",
+			[
+				{ pattern: "artisan", weight: 0.4, matched: false },
+				{ pattern: "database/seeders", weight: 0.25, matched: false },
+				{ pattern: "composer.json", weight: 0.15, matched: false },
+				{ pattern: "routes/", weight: 0.2, matched: false },
+			],
+		],
+	]);
+
+	/**
+	 * Detect project type from a directory
+	 */
+	async detect(rootDir: string): Promise<ProjectDetection> {
+		const projectFiles = await this.scanDirectory(rootDir);
+
+		// Score each project type
+		const scores: Record<ProjectType, number> = {
+			frappe_erpnext: 0,
+			frappe_spa: 0,
+			nextjs: 0,
+			react_vite: 0,
+			django: 0,
+			laravel: 0,
+			generic_web: 0,
+			unknown: 0,
+		};
+
+		const signals: string[] = [];
+
+		for (const [projectType, signalList] of this.signals) {
+			for (const signal of signalList) {
+				signal.matched = false;
+				for (const file of projectFiles) {
+					if (file.includes(signal.pattern)) {
+						signal.matched = true;
+						scores[projectType] += signal.weight;
+						if (!signals.includes(signal.pattern)) {
+							signals.push(signal.pattern);
+						}
+						break;
+					}
+				}
+			}
+		}
+
+		// Find the project type with highest score
+		let bestType: ProjectType = "unknown";
+		let bestScore = 0;
+
+		for (const [projectType, score] of Object.entries(scores)) {
+			if (score > bestScore) {
+				bestScore = score;
+				bestType = projectType as ProjectType;
+			}
+		}
+
+		// Check for generic web
+		if (projectFiles.some((f) => f === "package.json")) {
+			if (bestType === "unknown") {
+				bestType = "generic_web";
+			}
+		}
+
+		// Determine confidence based on score
+		const confidence = Math.min(1, bestScore);
+
+		return {
+			projectType: bestType,
+			confidence,
+			signals,
+			recommendedSeedStrategy: this.getSeedStrategy(bestType),
+			recommendedE2EStrategy: this.getE2EStrategy(bestType),
+			...this.getAdditionalInfo(bestType, projectFiles),
+		};
+	}
+
+	/**
+	 * Scan directory for relevant files
+	 */
+	private async scanDirectory(rootDir: string): Promise<string[]> {
+		// This is a simplified implementation.
+		// In practice, you'd use recursive directory scanning.
+		const files: string[] = [];
+
+		try {
+			// Check for common files
+			const checks = [
+				"frappe-bench",
+				"frappe-bench/sites",
+				"frappe-bench/apps",
+				"hooks.py",
+				"doctype",
+				"bench",
+				"vite.config.ts",
+				"vite.config.js",
+				"next.config.js",
+				"next.config.ts",
+				"package.json",
+				"pages",
+				"app",
+				"src/main.tsx",
+				"index.html",
+				"manage.py",
+				"settings.py",
+				"artisan",
+				"database/seeders",
+			];
+
+			// @ts-expect-error - Bun has built-in file system access
+			const { existsSync } = await import("node:fs");
+			// @ts-expect-error - Bun has built-in file system access
+			const { readdirSync } = await import("node:fs");
+
+			for (const check of checks) {
+				const fullPath = join(rootDir, check);
+				if (existsSync(fullPath)) {
+					files.push(check);
+				}
+			}
+
+			// Scan root directory for common files
+			try {
+				const rootFiles = readdirSync(rootDir);
+				for (const file of rootFiles) {
+					if (file.includes("package.json")) files.push(file);
+					if (file.includes("vite.config")) files.push(file);
+					if (file.includes("next.config")) files.push(file);
+				}
+			} catch {
+				// Ignore errors
+			}
+		} catch {
+			// Return empty on error
+		}
+
+		return files;
+	}
+
+	/**
+	 * Get recommended seed strategy
+	 */
+	private getSeedStrategy(projectType: ProjectType): SeedStrategy {
+		const strategies: Record<ProjectType, SeedStrategy> = {
+			frappe_erpnext: "frappe_doc_insert",
+			frappe_spa: "frappe_site_seed",
+			nextjs: "nextjs_factory",
+			react_vite: "react_factory",
+			django: "django_fixture",
+			laravel: "laravel_factory",
+			generic_web: "generic_sql",
+			unknown: "generic_sql",
+		};
+		return strategies[projectType];
+	}
+
+	/**
+	 * Get recommended E2E strategy
+	 */
+	private getE2EStrategy(projectType: ProjectType): E2EStrategy {
+		const strategies: Record<ProjectType, E2EStrategy> = {
+			frappe_erpnext: "bench_site_browser_flow",
+			frappe_spa: "bench_site_browser_flow",
+			nextjs: "next_dev_server_flow",
+			react_vite: "vite_dev_server_flow",
+			django: "django_test_client_flow",
+			laravel: "laravel_dusk_flow",
+			generic_web: "generic_playwright_flow",
+			unknown: "generic_playwright_flow",
+		};
+		return strategies[projectType];
+	}
+
+	/**
+	 * Get additional project info
+	 */
+	private getAdditionalInfo(
+		projectType: ProjectType,
+		files: string[],
+	): { framework?: string; version?: string } {
+		const info: { framework?: string; version?: string } = {};
+
+		// Try to extract version from package.json (if rootDir is available)
+		if (files.includes("package.json")) {
+			try {
+				const pkgPath = join(".", "package.json");
+				const pkg = readJson(pkgPath) as {
+					version?: string;
+					dependencies?: Record<string, string>;
+				} | null;
+				if (pkg?.version) {
+					info.version = pkg.version;
+				}
+			} catch {
+				// Ignore
+			}
+		}
+
+		// Set framework name
+		const frameworks: Partial<Record<ProjectType, string>> = {
+			frappe_erpnext: "Frappe/ERPNext",
+			frappe_spa: "Frappe SPA",
+			nextjs: "Next.js",
+			react_vite: "React + Vite",
+			django: "Django",
+			laravel: "Laravel",
+			generic_web: "Generic Web",
+		};
+		info.framework = frameworks[projectType];
+
+		return info;
+	}
+
+	/**
+	 * Generate detection report
+	 */
+	generateReport(detection: ProjectDetection): string {
+		const lines = [
+			"Project Detection Report",
+			"=".repeat(40),
+			"",
+			`Type: ${detection.projectType}`,
+			`Framework: ${detection.framework ?? "Unknown"}`,
+			`Confidence: ${(detection.confidence * 100).toFixed(1)}%`,
+			"",
+			"Signals:",
+		];
+
+		for (const signal of detection.signals) {
+			lines.push(`  - ${signal}`);
+		}
+
+		lines.push("");
+		lines.push("Recommendations:");
+		lines.push(`  Seed Strategy: ${detection.recommendedSeedStrategy}`);
+		lines.push(`  E2E Strategy: ${detection.recommendedE2EStrategy}`);
+
+		if (detection.version) {
+			lines.push(`  Version: ${detection.version}`);
+		}
+
+		return lines.join("\n");
+	}
+}

package/harness/repair-engine.ts

@@ -0,0 +1,340 @@
+/**
+ * Repair Engine — RFC-0018
+ *
+ * Converts failures into repair tasks with retry policy and escalation.
+ */
+
+import type {
+	RepairTask,
+	FailureType,
+	AttemptedFix,
+	RetryPolicy,
+} from "../packages/types/src/runtime-types.ts";
+import { appendJsonl } from "../cli.ts";
+// @ts-expect-error - Bun has built-in Node.js types
+import { join, dirname } from "node:path";
+// @ts-expect-error - Bun has built-in Node.js types
+import { mkdirSync } from "node:fs";
+
+const DEFAULT_RETRY_POLICY: RetryPolicy = {
+	maxRetries: 3,
+	backoffMs: 5000,
+	backoffMultiplier: 2,
+	escalationAfter: 2,
+};
+
+const FAILURE_PATTERNS: Record<string, FailureType> = {
+	"test failed": "test_failure",
+	"assertion failed": "test_failure",
+	TypeError: "type_error",
+	SyntaxError: "build_error",
+	ESLint: "lint_error",
+	"build failed": "build_error",
+	"compilation error": "build_error",
+	quota: "quota_exhausted",
+	"rate limit": "quota_exhausted",
+	"429": "quota_exhausted",
+	"500": "provider_error",
+	"502": "provider_error",
+	"503": "provider_error",
+	connection: "provider_error",
+	timeout: "provider_error",
+};
+
+export interface RepairResult {
+	repairTask: RepairTask;
+	canRetry: boolean;
+	shouldEscalate: boolean;
+}
+
+export class RepairEngine {
+	private repairTasks: Map<string, RepairTask> = new Map();
+	private readonly rootDir: string;
+
+	constructor(rootDir: string) {
+		this.rootDir = rootDir;
+	}
+
+	/**
+	 * Classify a failure type from error message
+	 */
+	classifyFailure(errorMessage: string): FailureType {
+		const lower = errorMessage.toLowerCase();
+
+		for (const [pattern, type] of Object.entries(FAILURE_PATTERNS)) {
+			if (lower.includes(pattern.toLowerCase())) {
+				return type;
+			}
+		}
+
+		return "unknown";
+	}
+
+	/**
+	 * Create a repair task from a failed task
+	 */
+	createRepairTask(
+		originalTaskId: string,
+		failureType: FailureType,
+		errorMessage: string,
+		options?: { retryPolicy?: Partial<RetryPolicy> },
+	): RepairTask {
+		const id = `repair-${originalTaskId}-${Date.now()}`;
+		const retryPolicy: RetryPolicy = {
+			...DEFAULT_RETRY_POLICY,
+			...options?.retryPolicy,
+		};
+
+		const task: RepairTask = {
+			id,
+			originalTaskId,
+			failureType,
+			description: `Fix failure in task ${originalTaskId}: ${errorMessage}`,
+			attemptedFixes: [],
+			status: "pending",
+			retryPolicy,
+			createdAt: new Date().toISOString(),
+		};
+
+		this.repairTasks.set(id, task);
+		return task;
+	}
+
+	/**
+	 * Record an attempted fix
+	 */
+	recordAttempt(
+		repairTaskId: string,
+		description: string,
+		success: boolean,
+		output?: string,
+	): void {
+		const task = this.repairTasks.get(repairTaskId);
+		if (!task) return;
+
+		const attempt: AttemptedFix = {
+			attempt: task.attemptedFixes.length + 1,
+			description,
+			success,
+			output,
+			timestamp: new Date().toISOString(),
+		};
+
+		task.attemptedFixes.push(attempt);
+
+		if (success) {
+			task.status = "resolved";
+			task.resolvedAt = new Date().toISOString();
+		} else if (attempt.attempt >= task.retryPolicy.maxRetries) {
+			// Check if should escalate
+			if (
+				task.retryPolicy.escalationAfter &&
+				attempt.attempt >= task.retryPolicy.escalationAfter
+			) {
+				task.status = "escalated";
+			}
+		}
+
+		this.repairTasks.set(repairTaskId, task);
+		this.saveRepairTask(task);
+	}
+
+	/**
+	 * Get the next retry delay in milliseconds
+	 */
+	getNextRetryDelay(repairTaskId: string): number | null {
+		const task = this.repairTasks.get(repairTaskId);
+		if (!task) return null;
+
+		const attempt = task.attemptedFixes.length;
+		if (attempt >= task.retryPolicy.maxRetries) return null;
+
+		const { backoffMs, backoffMultiplier } = task.retryPolicy;
+		return backoffMs * backoffMultiplier ** attempt;
+	}
+
+	/**
+	 * Check if repair task should escalate to human
+	 */
+	shouldEscalate(repairTaskId: string): boolean {
+		const task = this.repairTasks.get(repairTaskId);
+		if (!task) return false;
+		return task.status === "escalated";
+	}
+
+	/**
+	 * Get all repair tasks for a job
+	 */
+	getRepairTasks(jobId: string): RepairTask[] {
+		// const path = join(this.rootDir, "jobs", jobId, "repair-tasks.jsonl");
+		// In practice, this would read from file. For now, return in-memory.
+		return Array.from(this.repairTasks.values()).filter((t) =>
+			t.originalTaskId.startsWith(`task-${jobId}`),
+		);
+	}
+
+	/**
+	 * Get repair summary
+	 */
+	getSummary(jobId: string): {
+		total: number;
+		pending: number;
+		resolved: number;
+		escalated: number;
+	} {
+		const tasks = this.getRepairTasks(jobId);
+		return {
+			total: tasks.length,
+			pending: tasks.filter(
+				(t) => t.status === "pending" || t.status === "in_progress",
+			).length,
+			resolved: tasks.filter((t) => t.status === "resolved").length,
+			escalated: tasks.filter((t) => t.status === "escalated").length,
+		};
+	}
+
+	/**
+	 * Analyze a failure and create repair task with guidance
+	 */
+	analyzeAndRepair(
+		originalTaskId: string,
+		errorMessage: string,
+		options?: { retryPolicy?: Partial<RetryPolicy> },
+	): { repairTask: RepairTask; guidance: string } {
+		const failureType = this.classifyFailure(errorMessage);
+		const repairTask = this.createRepairTask(
+			originalTaskId,
+			failureType,
+			errorMessage,
+			options,
+		);
+
+		const guidance = this.generateGuidance(repairTask);
+
+		return { repairTask, guidance };
+	}
+
+	/**
+	 * Generate repair guidance based on failure type
+	 */
+	private generateGuidance(repairTask: RepairTask): string {
+		switch (repairTask.failureType) {
+			case "test_failure":
+				return `Analyze the failing test. Check:
+1. Is the test correct? (Does it test what it claims?)
+2. Is the implementation correct? (Does it match the expected behavior?)
+3. Are there any recent changes that broke the test?
+4. Are there any environment-specific issues?`;
+
+			case "build_error":
+				return `Check the build error details:
+1. Look at the exact error message and line number
+2. Check for missing imports or type mismatches
+3. Verify all dependencies are installed
+4. Check for circular dependencies`;
+
+			case "type_error":
+				return `Fix TypeScript/JavaScript type errors:
+1. Check the type of each variable
+2. Ensure type assertions are correct
+3. Verify interface/type definitions match usage
+4. Consider adding type guards if needed`;
+
+			case "lint_error":
+				return `Fix linting errors:
+1. Review the linting rules being violated
+2. Check if code style matches project conventions
+3. Run linter with --fix if available
+4. Update eslint/prettier config if needed`;
+
+			case "quota_exhausted":
+				return `Quota exhausted. Options:
+1. Wait for quota reset
+2. Switch to an alternative provider
+3. Optimize prompts to use fewer tokens
+4. Reduce task scope to fit within quota`;
+
+			case "provider_error":
+				return `Provider error. Actions:
+1. Retry with exponential backoff
+2. Check provider status page
+3. Switch to fallback provider if available
+4. Log error details for debugging`;
+
+			case "e2e_failure":
+				return `E2E test failed. Check:
+1. Is the page/app in the expected state?
+2. Are selectors still valid?
+3. Is there a timing issue (need to wait longer)?
+4. Is the test assertion correct?`;
+
+			default:
+				return `Unknown failure. Gather more information:
+1. Collect full error stack trace
+2. Check system logs
+3. Reproduce the issue locally
+4. Consider asking for human assistance`;
+		}
+	}
+
+	/**
+	 * Save repair task to file
+	 */
+	private saveRepairTask(task: RepairTask): void {
+		const path = join(
+			this.rootDir,
+			"jobs",
+			task.originalTaskId.split("-")[1] ?? "unknown",
+			"repair-tasks.jsonl",
+		);
+		mkdirSync(dirname(path), { recursive: true });
+		appendJsonl(path, task);
+	}
+
+	/**
+	 * Load repair tasks from file
+	 */
+	loadRepairTasks(_jobId: string): void {
+		// const path = join(this.rootDir, "jobs", _jobId, "repair-tasks.jsonl");
+		// In practice, this would read from file and populate the map
+	}
+
+	/**
+	 * Export repair report
+	 */
+	exportReport(jobId: string): string {
+		const tasks = this.getRepairTasks(jobId);
+		const summary = this.getSummary(jobId);
+
+		const lines = [
+			`Repair Report for Job ${jobId}`,
+			"=".repeat(50),
+			`Total: ${summary.total}`,
+			`Pending: ${summary.pending}`,
+			`Resolved: ${summary.resolved}`,
+			`Escalated: ${summary.escalated}`,
+			"",
+			"Details:",
+			"-".repeat(50),
+		];
+
+		for (const task of tasks) {
+			lines.push(`\n[${task.status.toUpperCase()}] ${task.id}`);
+			lines.push(`  Original: ${task.originalTaskId}`);
+			lines.push(`  Type: ${task.failureType}`);
+			lines.push(`  Description: ${task.description}`);
+			lines.push(
+				`  Attempts: ${task.attemptedFixes.length}/${task.retryPolicy.maxRetries}`,
+			);
+
+			if (task.attemptedFixes.length > 0) {
+				lines.push("  Attempt History:");
+				for (const fix of task.attemptedFixes) {
+					lines.push(`    - [${fix.success ? "✓" : "✗"}] ${fix.description}`);
+				}
+			}
+		}
+
+		return lines.join("\n");
+	}
+}