pi-harness-runtime 0.10.7 → 0.10.11

package/packages/task-compiler/src/compiler.ts

@@ -1,114 +0,0 @@
-/**
- * Task Compiler - Main Entry Point
- *
- * Compiles a compiled requirement + project profile into an executable task DAG.
- *
- * Algorithm:
- * 1. Decompose requirement into candidate tasks
- * 2. Assign file scope and ownership
- * 3. Assign verification outputs
- * 4. Apply command policy
- * 5. Build DAG with topological sort
- * 6. Validate: cycles, overlap, verification
- * 7. Assign provider hints
- */
-
-import { applyCommandPolicy } from "./command-policy.js";
-import { decomposeRequirement } from "./decompose.js";
-import { assignFileScope } from "./file-scope.js";
-import { buildGraph } from "./graph.js";
-import type {
-	TaskCompileInput,
-	TaskCompilerConfig,
-	TaskGraph,
-} from "./types.js";
-import {
-	DEFAULT_TASK_COMPILER_CONFIG,
-	PROVIDER_HINTS,
-	TaskCompilerError,
-	TaskCompilerErrorCode,
-} from "./types.js";
-import {
-	assertEveryCriterionAssigned,
-	assertEveryTaskHasVerification,
-	assertNoCycles,
-	assertNoEmptyObjectives,
-	assertNoExclusiveFileOverlap,
-} from "./validate.js";
-import { assignVerification } from "./verification.js";
-
-/**
- * Compile a requirement + project profile into an executable task graph.
- *
- * This is the main public API for the task compiler.
- */
-export async function compileTasks(
-	input: TaskCompileInput,
-	config?: Partial<TaskCompilerConfig>,
-): Promise<TaskGraph> {
-	const fullConfig: TaskCompilerConfig = {
-		...DEFAULT_TASK_COMPILER_CONFIG,
-		...config,
-	};
-
-	// Clock used for reproducible timestamps (available for future use)
-	fullConfig.clock;
-	const jobId = input.jobId;
-
-	// --- Step 1: Decompose requirement into candidates -------------------------
-
-	const candidates = decomposeRequirement(input);
-
-	if (candidates.length === 0) {
-		throw new TaskCompilerError(
-			TaskCompilerErrorCode.EMPTY_OBJECTIVE,
-			`Requirement "${input.requirement.id}" produced no tasks after decomposition.`,
-			{ requirementId: input.requirement.id },
-		);
-	}
-
-	// --- Step 2: Assign file scope and ownership -----------------------------
-
-	const tasksWithScope = assignFileScope(candidates, input.project);
-
-	// --- Step 3: Assign verification outputs --------------------------------
-
-	const tasksWithVerification = assignVerification(
-		tasksWithScope,
-		input.requirement,
-	);
-
-	// --- Step 4: Apply command policy -----------------------------------
-
-	const tasksWithPolicy = applyCommandPolicy(
-		tasksWithVerification,
-		input.project,
-	);
-
-	// --- Step 5: Assign jobId, provider hints, and finalize ---------------
-
-	const finalizedTasks = tasksWithPolicy.map((task) => ({
-		...task,
-		jobId,
-		preferredProvider: PROVIDER_HINTS[task.type]?.[0],
-	}));
-
-	// --- Step 6: Build graph ---------------------------------------------
-
-	const graph = buildGraph(finalizedTasks);
-
-	// --- Step 7: Validate ------------------------------------------------
-
-	assertNoEmptyObjectives(graph);
-	assertNoCycles(graph);
-	assertNoExclusiveFileOverlap(graph);
-	assertEveryTaskHasVerification(graph);
-
-	// Every acceptance criterion must be assigned to at least one task
-	const acIds = input.requirement.acceptanceCriteria.map((c) => c.id);
-	if (acIds.length > 0) {
-		assertEveryCriterionAssigned(graph, acIds);
-	}
-
-	return graph;
-}

package/packages/task-compiler/src/decompose.ts

@@ -1,265 +0,0 @@
-/**
- * Task Compiler - Requirement Decomposition
- *
- * Breaks a compiled requirement into candidate tasks following
- * the standard engineering flow and decomposition policy.
- */
-
-import type {
-	CompiledRequirement,
-	ComplexityEstimate,
-	ProjectProfile,
-	TaskCandidate,
-	TaskCompileInput,
-} from "./types.js";
-
-/**
- * Decompose a compiled requirement into task candidates.
- *
- * Policy: split when different capabilities needed, unrelated modules,
- * incoherent test set, destructive+edit mix, >maxComplexity, or
- * independently-proceeding outputs. Do NOT split to inflate count.
- */
-export function decomposeRequirement(input: TaskCompileInput): TaskCandidate[] {
-	const { requirement, project, maxComplexity = 5 } = input;
-
-	const candidates: TaskCandidate[] = [];
-	let priority = 1;
-
-	// --- Stage detection ------------------------------------------------
-
-	const needsAnalysis =
-		requirement.problemStatement.length > 200 || requirement.goals.length > 3;
-	const needsDesign = requirement.problemStatement.length > 100;
-	const hasTests = requirement.acceptanceCriteria.length > 0;
-	const hasBrowserWorkflow = detectBrowserWorkflow(project);
-	const needsRepair = requirement.riskTags.some(
-		(r) => r.risk === "destructive_operation",
-	);
-
-	// --- Analysis ------------------------------------------------------
-
-	if (needsAnalysis) {
-		candidates.push({
-			id: "analysis-0",
-			title: `Analyze: ${truncate(requirement.title, 40)}`,
-			objective: `Analyze the requirement "${requirement.title}": ${requirement.problemStatement}. Identify affected modules, detect dependencies, and outline implementation approach.`,
-			type: "analysis",
-			roughDependencies: [],
-			criteria: [],
-			estimatedComplexity: estimateComplexity(requirement.problemStatement),
-			priority: priority++,
-		});
-	}
-
-	// --- Design --------------------------------------------------------
-
-	if (needsDesign) {
-		candidates.push({
-			id: "design-0",
-			title: `Design: ${truncate(requirement.title, 40)}`,
-			objective: `Design the architecture for: ${requirement.problemStatement}. Produce a schema or design document capturing the component model, API contracts, and data flow.`,
-			type: "design",
-			roughDependencies: needsAnalysis ? ["analysis-0"] : [],
-			criteria: [],
-			estimatedComplexity: 3,
-			priority: priority++,
-		});
-	}
-
-	// --- Implementation ------------------------------------------------
-
-	for (let i = 0; i < requirement.goals.length; i++) {
-		const goal = requirement.goals[i];
-		const implDeps: string[] = [];
-		if (needsDesign) implDeps.push("design-0");
-		else if (needsAnalysis) implDeps.push("analysis-0");
-
-		candidates.push({
-			id: `impl-${i}`,
-			title: `Implement: ${truncate(goal.description, 45)}`,
-			objective: goal.description,
-			type: "implementation",
-			roughDependencies: implDeps,
-			criteria: mapGoalToCriteria(goal.id, requirement),
-			estimatedComplexity: estimateComplexity(goal.description),
-			priority: priority++,
-		});
-	}
-
-	// Blocking constraints as an implementation concern
-	const blockingConstraints = requirement.constraints.filter((c) => c.blocking);
-	if (blockingConstraints.length > 0) {
-		const firstImplId = requirement.goals.length > 0 ? "impl-0" : undefined;
-		candidates.push({
-			id: "impl-constraints",
-			title: `Implement constraints: ${truncate(blockingConstraints[0].description, 40)}`,
-			objective: blockingConstraints.map((c) => c.description).join("; "),
-			type: "implementation",
-			roughDependencies: firstImplId ? [firstImplId] : [],
-			criteria: [],
-			estimatedComplexity: 3,
-			priority: priority++,
-		});
-	}
-
-	// --- Unit tests ---------------------------------------------------
-
-	if (hasTests) {
-		candidates.push({
-			id: "test-0",
-			title: `Write unit tests for: ${truncate(requirement.title, 35)}`,
-			objective: `Write unit tests that verify the acceptance criteria for: ${requirement.problemStatement}. Each test must map to at least one acceptance criterion.`,
-			type: "test",
-			roughDependencies: requirement.goals.length > 0 ? ["impl-0"] : [],
-			criteria: requirement.acceptanceCriteria.map((c) => c.id),
-			estimatedComplexity: 3,
-			priority: priority++,
-		});
-	}
-
-	// --- E2E tests ---------------------------------------------------
-
-	if (hasBrowserWorkflow && input.insertE2E !== false) {
-		candidates.push({
-			id: "e2e-0",
-			title: `Write E2E tests for: ${truncate(requirement.title, 35)}`,
-			objective: `Write end-to-end browser tests for: ${requirement.problemStatement}. Cover the critical user flows identified in the requirements.`,
-			type: "e2e_test",
-			roughDependencies: hasTests
-				? ["test-0"]
-				: requirement.goals.length > 0
-					? ["impl-0"]
-					: [],
-			criteria: [],
-			estimatedComplexity: 5,
-			priority: priority++,
-		});
-	}
-
-	// --- Review --------------------------------------------------------
-
-	const reviewDeps: string[] = [];
-	if (hasTests) reviewDeps.push("test-0");
-	if (hasBrowserWorkflow && input.insertE2E !== false) reviewDeps.push("e2e-0");
-	if (reviewDeps.length === 0 && requirement.goals.length > 0)
-		reviewDeps.push("impl-0");
-
-	candidates.push({
-		id: "review-0",
-		title: `Review changes for: ${truncate(requirement.title, 35)}`,
-		objective: `Review all code changes for: ${requirement.problemStatement}. Verify code quality, test coverage, and alignment with acceptance criteria.`,
-		type: "review",
-		roughDependencies: reviewDeps,
-		criteria: requirement.acceptanceCriteria.map((c) => c.id),
-		estimatedComplexity: 2,
-		priority: priority++,
-	});
-
-	// --- Repair --------------------------------------------------------
-
-	if (needsRepair) {
-		candidates.push({
-			id: "repair-0",
-			title: `Repair / verify: ${truncate(requirement.title, 35)}`,
-			objective: `Address review findings and verify that destructive operations in: ${requirement.problemStatement} have proper approval and rollback plans.`,
-			type: "repair",
-			roughDependencies: ["review-0"],
-			criteria: [],
-			estimatedComplexity: 3,
-			priority: priority++,
-		});
-	}
-
-	// --- Documentation ------------------------------------------------
-
-	candidates.push({
-		id: "docs-0",
-		title: `Document: ${truncate(requirement.title, 40)}`,
-		objective: `Document the implementation of: ${requirement.title}. ${requirement.problemStatement}. Include usage examples, API documentation, and any relevant diagrams.`,
-		type: "documentation",
-		roughDependencies: needsRepair ? ["repair-0"] : ["review-0"],
-		criteria: [],
-		estimatedComplexity: 2,
-		priority: priority++,
-	});
-
-	// --- Enforce complexity threshold ---------------------------------
-
-	const result: TaskCandidate[] = [];
-	for (const c of candidates) {
-		if (c.estimatedComplexity > maxComplexity) {
-			result.push(...splitByComplexity(c, maxComplexity));
-		} else {
-			result.push(c);
-		}
-	}
-
-	return result;
-}
-
-// --- Helpers ------------------------------------------------------------
-
-function estimateComplexity(text: string): ComplexityEstimate {
-	const words = text.split(/\s+/).length;
-	if (words < 20) return 1;
-	if (words < 50) return 2;
-	if (words < 100) return 3;
-	if (words < 200) return 5;
-	return 8;
-}
-
-function splitByComplexity(
-	task: TaskCandidate,
-	_maxComplexity: number,
-): TaskCandidate[] {
-	const half = Math.ceil(task.estimatedComplexity / 2) as ComplexityEstimate;
-	return [
-		{
-			...task,
-			id: `${task.id}-a`,
-			estimatedComplexity: half,
-			title: `${task.title} [Part 1]`,
-			objective: `${task.objective} (Part 1)`,
-		},
-		{
-			...task,
-			id: `${task.id}-b`,
-			estimatedComplexity: half,
-			title: `${task.title} [Part 2]`,
-			objective: `${task.objective} (Part 2)`,
-			roughDependencies: [...task.roughDependencies, `${task.id}-a`],
-		},
-	];
-}
-
-function mapGoalToCriteria(
-	goalId: string,
-	requirement: CompiledRequirement,
-): string[] {
-	const acs = requirement.acceptanceCriteria;
-	const goalIndex = requirement.goals.findIndex((g) => g.id === goalId);
-	if (goalIndex < 0) return acs.map((c) => c.id);
-	// Distribute criteria round-robin across goals
-	return acs
-		.filter((_, i) => i % requirement.goals.length === goalIndex)
-		.map((c) => c.id);
-}
-
-function detectBrowserWorkflow(project: ProjectProfile): boolean {
-	const frameworks = project.frameworks ?? [];
-	const testCapabilities = project.testCapabilities ?? [];
-	return (
-		frameworks.some((f) =>
-			/playwright|cypress|selenium|nightwatch/i.test(f.name),
-		) ||
-		testCapabilities.some((t) =>
-			/playwright|cypress|selenium|e2e|browser/i.test(t.runner),
-		)
-	);
-}
-
-function truncate(text: string, maxLen: number): string {
-	if (text.length <= maxLen) return text;
-	return `${text.slice(0, maxLen - 1)}…`;
-}

package/packages/task-compiler/src/file-scope.ts

@@ -1,240 +0,0 @@
-/**
- * Task Compiler - File Scope Assignment
- *
- * Assigns filesInScope and FileOwnership to each compiled task
- * based on the project structure and task type.
- */
-
-import type {
-	CompiledTask,
-	FileOwnership,
-	FileOwnershipMode,
-	ProjectProfile,
-	TaskCandidate,
-	TaskType,
-} from "./types.js";
-
-/**
- * Assign file scope and ownership to each task candidate.
- *
- * File scope is determined by:
- * - Task type (implementation → source files, test → test files)
- * - Project structure (detected by Project Analyzer)
- * - Requirement goals and constraints
- */
-export function assignFileScope(
-	candidates: TaskCandidate[],
-	project: ProjectProfile,
-): CompiledTask[] {
-	const __projectPath = project.projectPath;
-	const sourceExts = detectSourceExtensions(project);
-	const testExts = detectTestExtensions(project);
-
-	return candidates.map((candidate) => {
-		const filesInScope = inferFiles(candidate, project, sourceExts, testExts);
-		const mode = getOwnershipMode(candidate.type);
-		const ownership: FileOwnership = {
-			taskId: candidate.id,
-			include: filesInScope,
-			exclude: getExclusions(candidate.type, project),
-			mode,
-		};
-
-		return {
-			id: candidate.id,
-			jobId: "", // Set by compiler
-			title: candidate.title,
-			objective: candidate.objective,
-			type: candidate.type,
-			dependencies: candidate.roughDependencies,
-			filesInScope,
-			filesExclude: ownership.exclude,
-			expectedOutputs: [], // Set by verification.ts
-			acceptanceCriteria: candidate.criteria,
-			requiredCapabilities: inferCapabilities(candidate.type),
-			permittedCommands: [], // Set by command-policy.ts
-			prohibitedCommands: [], // Set by command-policy.ts
-			preferredProvider: undefined, // Set by compiler.ts
-			estimatedComplexity: candidate.estimatedComplexity,
-			fileOwnership: ownership,
-			priority: candidate.priority,
-		};
-	});
-}
-
-// --- File inference by task type ---------------------------------------
-
-function inferFiles(
-	candidate: TaskCandidate,
-	project: ProjectProfile,
-	_sourceExts: string[],
-	testExts: string[],
-): string[] {
-	const { type, objective } = candidate;
-	const base = project.projectPath;
-
-	switch (type) {
-		case "analysis": {
-			return [`${base}/src/**`];
-		}
-
-		case "design": {
-			return [`${base}/src/**/*.ts`, `${base}/docs/**`];
-		}
-
-		case "implementation": {
-			// Default to all source files; narrow by extracting file mentions from objective
-			const mentions = extractFileMentions(objective);
-			if (mentions.length > 0) return mentions;
-			return [`${base}/src/**`];
-		}
-
-		case "test": {
-			if (testExts.length > 0)
-				return [`${base}/test/**`, `${base}/**/*.test.*`];
-			return [`${base}/**/*.test.*`, `${base}/**/*.spec.*`];
-		}
-
-		case "e2e_test": {
-			return [`${base}/**/*.e2e.*`, `${base}/e2e/**`];
-		}
-
-		case "review": {
-			// Review reads everything that's been modified
-			return [`${base}/src/**`];
-		}
-
-		case "repair": {
-			// Repair targets whatever the review flagged
-			const mentions = extractFileMentions(objective);
-			return mentions.length > 0 ? mentions : [`${base}/src/**`];
-		}
-
-		case "documentation": {
-			return [`${base}/README.md`, `${base}/docs/**`, `${base}/src/**/*.md`];
-		}
-
-		default: {
-			return [`${base}/src/**`];
-		}
-	}
-}
-
-// --- Extract file mentions from objective text --------------------------
-
-function extractFileMentions(text: string): string[] {
-	// Match common file/directory patterns in natural language:
-	// - "src/components/Button.tsx"
-	// - "packages/foo/src/"
-	// - "test/user.test.ts"
-	const pattern =
-		/(?:src|test|packages?|apps?|lib|components?|hooks?|utils|docs?)[/\\][^\s"']+/gi;
-	const matches = text.match(pattern);
-	if (!matches) return [];
-	// Deduplicate and return
-	return [...new Set(matches)];
-}
-
-// --- Ownership mode ----------------------------------------------------
-
-function getOwnershipMode(type: TaskType): FileOwnershipMode {
-	// Parallel tasks with "exclusive" mode cannot modify the same files
-	switch (type) {
-		case "implementation":
-		case "test":
-		case "e2e_test":
-		case "repair":
-			return "exclusive";
-		case "analysis":
-		case "design":
-		case "review":
-		case "documentation":
-			return "shared_read";
-		default:
-			return "shared_read";
-	}
-}
-
-// --- Exclusions --------------------------------------------------------
-
-function getExclusions(_type: TaskType, project: ProjectProfile): string[] {
-	const exclusions: string[] = [
-		// Never touch these regardless of task type
-		"**/node_modules/**",
-		"**/dist/**",
-		"**/.git/**",
-		"**/coverage/**",
-		"**/build/**",
-	];
-
-	// Add project-specific exclusions from rules
-	if (project.rules) {
-		for (const rule of project.rules) {
-			if (rule.section === "scope" || rule.section === "files") {
-				// Rules may specify excluded patterns
-			}
-		}
-	}
-
-	return exclusions;
-}
-
-// --- Capability inference -----------------------------------------------
-
-function inferCapabilities(type: TaskType): string[] {
-	const caps: Record<TaskType, string[]> = {
-		analysis: ["plan", "analysis"],
-		design: ["plan", "analysis"],
-		implementation: ["code"],
-		test: ["code", "test"],
-		e2e_test: ["code", "e2e"],
-		review: ["review"],
-		repair: ["code", "debug"],
-		documentation: ["code"],
-	};
-	return caps[type] ?? ["code"];
-}
-
-// --- Extension detection -------------------------------------------------
-
-function detectSourceExtensions(project: ProjectProfile): string[] {
-	const frameworks = project.frameworks ?? [];
-	const exts = new Set<string>(["ts", "tsx", "js", "jsx"]);
-
-	if (frameworks.some((f) => /typescript|ts|tsx/i.test(f.name))) {
-		exts.add("ts");
-		exts.add("tsx");
-	}
-	if (frameworks.some((f) => /react|next\.?js|vue|svelte/i.test(f.name))) {
-		exts.add("jsx");
-		exts.add("tsx");
-	}
-	if (frameworks.some((f) => /python|flask|django|fastapi/i.test(f.name))) {
-		exts.add("py");
-	}
-	if (frameworks.some((f) => /frappe|erpnext/i.test(f.name))) {
-		exts.add("py");
-		exts.add("js");
-	}
-
-	return [...exts];
-}
-
-function detectTestExtensions(project: ProjectProfile): string[] {
-	const frameworks = project.frameworks ?? [];
-	const testCaps = project.testCapabilities ?? [];
-	const exts = new Set<string>();
-
-	if (
-		frameworks.some((f) =>
-			/playwright|cypress|selenium|nightwatch/i.test(f.name),
-		) ||
-		testCaps.some((t) =>
-			/playwright|cypress|selenium|nightwatch/i.test(t.runner),
-		)
-	) {
-		exts.add("e2e.ts");
-	}
-
-	return [...exts];
-}