pi-harness-runtime 0.2.0 → 0.3.1

package/harness/master-planner.ts

@@ -0,0 +1,327 @@
+/**
+ * Master Planner — RFC-0017
+ *
+ * Converts a human requirement into an executable task graph.
+ * Uses a planning LLM to decompose the requirement into tasks with dependencies.
+ */
+
+import type { TaskGraph } from "../packages/types/src/runtime-types.ts";
+import { TaskGraphManager } from "./task-graph.ts";
+
+export interface PlanResult {
+	success: boolean;
+	graph?: TaskGraph;
+	error?: string;
+}
+
+export interface PlannerOptions {
+	planningProvider?: {
+		call: (prompt: string, systemPrompt: string) => Promise<string>;
+	};
+	maxTasks?: number;
+}
+
+const DEFAULT_SYSTEM_PROMPT = `You are a software project planner. Given a human requirement, decompose it into a clear task list.
+
+Rules:
+1. Each task should be atomic and independently testable
+2. Tasks must be ordered with proper dependencies
+3. Include acceptance criteria for each task
+4. Consider: analysis, implementation, testing, review phases
+5. Output ONLY valid JSON in the specified format
+
+Output format:
+{
+  "tasks": [
+    {
+      "id": "task-001",
+      "title": "Descriptive title",
+      "description": "What this task does",
+      "dependencies": [], // array of task IDs this depends on
+      "acceptanceCriteria": ["criterion 1", "criterion 2"]
+    }
+  ]
+}`;
+
+export class MasterPlanner {
+	constructor(private readonly options: PlannerOptions = {}) {}
+
+	/**
+	 * Create a plan from a requirement
+	 */
+	async createPlan(
+		requirement: string,
+		jobId: string,
+		rootDir: string,
+	): Promise<PlanResult> {
+		try {
+			// Build the planning prompt
+			const userPrompt = `Human requirement:\n${requirement}\n\nMax tasks: ${this.options.maxTasks ?? 20}`;
+
+			let taskList: {
+				id: string;
+				title: string;
+				description: string;
+				dependencies: string[];
+				acceptanceCriteria?: string[];
+			}[];
+
+			if (this.options.planningProvider) {
+				// Use LLM to generate task list
+				const response = await this.options.planningProvider.call(
+					userPrompt,
+					DEFAULT_SYSTEM_PROMPT,
+				);
+				const parsed = this.parsePlanningResponse(response);
+				if (!parsed) {
+					return { success: false, error: "Failed to parse planning response" };
+				}
+				taskList = parsed;
+			} else {
+				// Use heuristic planner for simple requirements
+				taskList = this.heuristicPlan(requirement);
+			}
+
+			// Validate the task list
+			if (taskList.length === 0) {
+				return { success: false, error: "No tasks generated from requirement" };
+			}
+
+			// Validate dependencies (no cycles, all deps exist)
+			const taskIds = new Set(taskList.map((t) => t.id));
+			for (const task of taskList) {
+				for (const dep of task.dependencies) {
+					if (!taskIds.has(dep)) {
+						return {
+							success: false,
+							error: `Task ${task.id} has invalid dependency: ${dep}`,
+						};
+					}
+				}
+			}
+
+			// Create task graph
+			const graphManager = new TaskGraphManager({ jobId });
+
+			for (const task of taskList) {
+				graphManager.addTask(
+					task.id,
+					task.title,
+					task.description,
+					task.dependencies,
+					task.acceptanceCriteria,
+				);
+			}
+
+			const graph = graphManager.getGraph();
+
+			// Save the graph
+			await graphManager.save(rootDir);
+
+			return { success: true, graph };
+		} catch (error) {
+			return { success: false, error: String(error) };
+		}
+	}
+
+	/**
+	 * Parse planning response from LLM
+	 */
+	private parsePlanningResponse(
+		response: string,
+	):
+		| {
+				id: string;
+				title: string;
+				description: string;
+				dependencies: string[];
+				acceptanceCriteria?: string[];
+		  }[]
+		| null {
+		// Try to extract JSON from response
+		const jsonMatch =
+			response.match(/```json\n([\s\S]*?)\n```/) ??
+			response.match(/\{[\s\S]*"tasks"[\s\S]*\}/);
+
+		if (!jsonMatch) {
+			console.error("Failed to extract JSON from planning response");
+			return null;
+		}
+
+		const jsonStr = jsonMatch[1] ?? jsonMatch[0];
+
+		try {
+			const parsed = JSON.parse(jsonStr);
+			return parsed.tasks ?? [];
+		} catch {
+			console.error("Failed to parse JSON from planning response");
+			return null;
+		}
+	}
+
+	/**
+	 * Heuristic planner for simple requirements
+	 * Used when no LLM provider is available
+	 */
+	heuristicPlan(
+		requirement: string,
+	): {
+		id: string;
+		title: string;
+		description: string;
+		dependencies: string[];
+		acceptanceCriteria?: string[];
+	}[] {
+		const tasks: {
+			id: string;
+			title: string;
+			description: string;
+			dependencies: string[];
+			acceptanceCriteria?: string[];
+		}[] = [];
+		const req = requirement.toLowerCase();
+
+		// Task 1: Analysis
+		tasks.push({
+			id: "task-001",
+			title: "Analyze requirements",
+			description: `Analyze and document the requirements: ${requirement}`,
+			dependencies: [],
+			acceptanceCriteria: [
+				"Requirements are clearly documented",
+				"All edge cases identified",
+				"Technical approach defined",
+			],
+		});
+
+		// Task 2: Implementation
+		if (
+			req.includes("api") ||
+			req.includes("endpoint") ||
+			req.includes("backend")
+		) {
+			tasks.push({
+				id: "task-002",
+				title: "Implement API endpoints",
+				description: "Create API endpoints based on requirements",
+				dependencies: ["task-001"],
+				acceptanceCriteria: [
+					"Endpoints return correct responses",
+					"Error handling implemented",
+					"Input validation in place",
+				],
+			});
+		}
+
+		if (
+			req.includes("database") ||
+			req.includes("model") ||
+			req.includes("schema")
+		) {
+			tasks.push({
+				id: "task-003",
+				title: "Implement database schema",
+				description: "Create database models and migrations",
+				dependencies: ["task-001"],
+				acceptanceCriteria: [
+					"Schema matches requirements",
+					"Migrations run successfully",
+					"Relationships defined correctly",
+				],
+			});
+		}
+
+		if (
+			req.includes("ui") ||
+			req.includes("frontend") ||
+			req.includes("page") ||
+			req.includes("component")
+		) {
+			tasks.push({
+				id: "task-004",
+				title: "Implement UI components",
+				description: "Create frontend UI components",
+				dependencies: ["task-001"],
+				acceptanceCriteria: [
+					"Components match design",
+					"Responsive on all devices",
+					"Accessible",
+				],
+			});
+		}
+
+		// Task 5: Tests
+		const implDeps = tasks
+			.filter((t) => t.id.startsWith("task-00"))
+			.map((t) => t.id);
+		tasks.push({
+			id: "task-010",
+			title: "Write unit tests",
+			description: "Write unit tests for all implemented code",
+			dependencies: implDeps.length > 0 ? implDeps : ["task-001"],
+			acceptanceCriteria: [
+				"All new code has >80% test coverage",
+				"All tests pass",
+				"Edge cases covered",
+			],
+		});
+
+		// Task 6: Integration
+		tasks.push({
+			id: "task-011",
+			title: "Integration testing",
+			description: "Run integration tests and verify end-to-end flow",
+			dependencies: ["task-010"],
+			acceptanceCriteria: [
+				"Integration tests pass",
+				"No regression in existing functionality",
+			],
+		});
+
+		// Task 7: Review
+		tasks.push({
+			id: "task-012",
+			title: "Code review",
+			description: "Review code for quality, security, and best practices",
+			dependencies: ["task-011"],
+			acceptanceCriteria: [
+				"Code follows project style guide",
+				"No security vulnerabilities",
+				"Documentation updated",
+			],
+		});
+
+		return tasks;
+	}
+
+	/**
+	 * Generate a simple task ID
+	 */
+	static generateTaskId(index: number): string {
+		return `task-${String(index).padStart(3, "0")}`;
+	}
+}
+
+/**
+ * Parse a requirement into a basic task list (synchronous, no LLM)
+ */
+export function parseRequirementIntoTasks(
+	requirement: string,
+	jobId: string,
+): TaskGraphManager {
+	const planner = new MasterPlanner();
+	const taskList = planner.heuristicPlan(requirement);
+
+	const graphManager = new TaskGraphManager({ jobId });
+	for (const task of taskList) {
+		graphManager.addTask(
+			task.id,
+			task.title,
+			task.description,
+			task.dependencies,
+			task.acceptanceCriteria,
+		);
+	}
+
+	return graphManager;
+}

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");
+	}
+}