pi-harness-runtime 0.10.7 → 0.10.11

package/harness/project-detector/detector.ts

@@ -1,328 +0,0 @@
-/**
- * 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

@@ -1,340 +0,0 @@
-/**
- * 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");
-	}
-}