pi-harness-runtime 1.1.445 → 1.1.447

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];
-}

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

@@ -1,144 +0,0 @@
-/**
- * Task Compiler - Task Graph Builder
- *
- * Builds the deterministic DAG from compiled tasks,
- * performs topological sort, and detects root/terminal nodes.
- */
-
-import type { CompiledTask, TaskGraph } from "./types.js";
-
-/**
- * Build a TaskGraph from compiled tasks.
- *
- * The graph is built from task dependencies and includes:
- * - Roots: tasks with no incoming dependencies
- * - Terminals: tasks with no outgoing dependencies
- * - Deterministic topological order
- */
-export function buildGraph(tasks: CompiledTask[]): TaskGraph {
-	const taskMap = new Map<string, CompiledTask>();
-	for (const task of tasks) {
-		taskMap.set(task.id, task);
-	}
-
-	// --- Compute dependents --------------------------------------------
-
-	const dependents = new Map<string, string[]>();
-	for (const task of tasks) {
-		dependents.set(task.id, []);
-	}
-	for (const task of tasks) {
-		for (const depId of task.dependencies) {
-			const list = dependents.get(depId);
-			if (list) list.push(task.id);
-		}
-	}
-
-	// --- Find roots and terminals -------------------------------------
-
-	const roots = tasks
-		.filter((t) => t.dependencies.length === 0)
-		.map((t) => t.id);
-
-	const terminals = tasks
-		.filter((t) => (dependents.get(t.id)?.length ?? 0) === 0)
-		.map((t) => t.id);
-
-	// --- Deterministic topological sort --------------------------------
-
-	const order = topologicalSort([...tasks], taskMap);
-
-	return {
-		jobId: tasks[0]?.jobId ?? "",
-		tasks,
-		roots,
-		terminalTasks: terminals,
-		topologicalOrder: order,
-	};
-}
-
-// --- Kahn's topological sort with deterministic tiebreaking -----------------
-
-function topologicalSort(
-	tasks: CompiledTask[],
-	taskMap: Map<string, CompiledTask>,
-): string[] {
-	const result: string[] = [];
-
-	// in-degree for each task
-	const inDegree = new Map<string, number>();
-	for (const task of tasks) {
-		inDegree.set(task.id, 0);
-	}
-	for (const task of tasks) {
-		for (const dep of task.dependencies) {
-			inDegree.set(dep, inDegree.get(dep) ?? 0);
-		}
-	}
-
-	// Tasks with no incoming edges
-	const ready: string[] = [];
-	for (const [id, degree] of inDegree.entries()) {
-		if (degree === 0) ready.push(id);
-	}
-
-	// Sort ready queue deterministically: by explicit priority first,
-	// then by dependency depth, then by task ID
-	const taskById = new Map(tasks.map((t) => [t.id, t]));
-
-	while (ready.length > 0) {
-		// Sort ready queue deterministically
-		ready.sort((a, b) => {
-			const ta = taskById.get(a);
-			const tb = taskById.get(b);
-			if (!ta || !tb) return a.localeCompare(b);
-			// Priority: lower number = higher priority
-			const pa = ta.priority ?? 999;
-			const pb = tb.priority ?? 999;
-			if (pa !== pb) return pa - pb;
-			// Dependency depth: tasks with more deps should come later
-			const depthA = countDepth(a, taskMap);
-			const depthB = countDepth(b, taskMap);
-			if (depthA !== depthB) return depthA - depthB;
-			// Finally, task ID string order for determinism
-			return a.localeCompare(b);
-		});
-
-		const next = ready.shift();
-		if (!next) break;
-		result.push(next);
-
-		// Reduce in-degree for dependents
-		for (const dependent of dependents.get(next ?? "") ?? []) {
-			const newDegree = (inDegree.get(dependent) ?? 1) - 1;
-			inDegree.set(dependent, newDegree);
-			if (newDegree === 0) {
-				ready.push(dependent);
-			}
-		}
-	}
-
-	return result;
-}
-
-// --- Dependency depth helper -----------------------------------------------
-
-function countDepth(
-	taskId: string,
-	taskMap: Map<string, CompiledTask>,
-): number {
-	const task = taskMap.get(taskId);
-	if (!task || task.dependencies.length === 0) return 0;
-	let max = 0;
-	for (const dep of task.dependencies) {
-		const d = countDepth(dep, taskMap);
-		if (d > max) max = d;
-	}
-	return max + 1;
-}
-
-// --- Dependency map (for use by topologicalSort) ---------------------------
-
-const dependents = new Map<string, string[]>();
-
-export { dependents };

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

@@ -1,38 +0,0 @@
-/**
- * Task Compiler
- *
- * Compiles requirements into executable, dependency-aware task graphs.
- *
- * @example
- * import { compileTasks } from "@pi-harness/task-compiler";
- *
- * const graph = await compileTasks({
- *   requirement: compiledRequirement,
- *   project: projectProfile,
- *   jobId: "job-001",
- * });
- */
-
-// --- SDK Version -------------------------------------------------------
-
-export { SDK_VERSION } from "./types.js";
-
-// --- Main API ---------------------------------------------------------
-
-export { compileTasks } from "./compiler.js";
-
-// --- Exported types (for consumers) ------------------------------------
-
-export type {
-	CompiledTask,
-	ComplexityEstimate,
-	DependencyInfo,
-	FileOwnership,
-	FileOwnershipMode,
-	TaskCompileInput,
-	TaskCompilerConfig,
-	TaskGraph,
-	TaskOutput,
-	TaskType,
-} from "./types.js";
-export { TaskCompilerError, TaskCompilerErrorCode } from "./types.js";

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

@@ -1,225 +0,0 @@
-/**
- * Task Compiler - Type Definitions
- *
- * Core types for task decomposition, DAG construction, and verification.
- */
-
-// --- SDK Version -------------------------------------------------------
-
-export const SDK_VERSION = "1.0.0" as const;
-
-// --- Task Types --------------------------------------------------------
-
-export type TaskType =
-	| "analysis"
-	| "design"
-	| "implementation"
-	| "test"
-	| "e2e_test"
-	| "review"
-	| "repair"
-	| "documentation";
-
-export type ComplexityEstimate = 1 | 2 | 3 | 5 | 8;
-
-// --- Task Output --------------------------------------------------------
-
-export interface TaskOutput {
-	kind: "file" | "test_result" | "report" | "schema" | "diff" | "verification";
-	path?: string;
-	description: string;
-	required: boolean;
-}
-
-// --- Compiled Task -----------------------------------------------------
-
-export interface CompiledTask {
-	id: string;
-	jobId: string;
-	title: string;
-	objective: string;
-	type: TaskType;
-	dependencies: string[];
-	filesInScope: string[];
-	filesExclude?: string[];
-	expectedOutputs: TaskOutput[];
-	acceptanceCriteria: string[];
-	requiredCapabilities: string[];
-	permittedCommands: string[];
-	prohibitedCommands: string[];
-	preferredProvider?: string;
-	estimatedComplexity: ComplexityEstimate;
-	fileOwnership: FileOwnership;
-	priority?: number;
-}
-
-// --- File Ownership ----------------------------------------------------
-
-export type FileOwnershipMode = "exclusive" | "shared_read";
-
-export interface FileOwnership {
-	taskId: string;
-	include: string[];
-	exclude: string[];
-	mode: FileOwnershipMode;
-}
-
-// --- Task Graph --------------------------------------------------------
-
-export interface TaskGraph {
-	jobId: string;
-	tasks: CompiledTask[];
-	roots: string[];
-	terminalTasks: string[];
-	topologicalOrder: string[];
-}
-
-// --- Standard Engineering Flow ----------------------------------------
-
-export const STANDARD_FLOW: TaskType[] = [
-	"analysis",
-	"design",
-	"implementation",
-	"test",
-	"e2e_test",
-	"review",
-	"repair",
-	"documentation",
-];
-
-// --- Provider Hints ---------------------------------------------------
-
-export const PROVIDER_HINTS: Partial<Record<TaskType, string[]>> = {
-	analysis: ["codex", "gpt", "glm"],
-	design: ["codex", "gpt", "glm"],
-	implementation: ["minimax", "claude", "glm"],
-	test: ["minimax", "claude"],
-	e2e_test: ["playwright"],
-	review: ["claude", "glm"],
-	repair: ["glm", "claude"],
-	documentation: ["codex", "gpt"],
-};
-
-// --- Default Command Policy ---------------------------------------------
-
-export const PROHIBITED_BY_DEFAULT: string[] = [
-	"git commit",
-	"git push",
-	"bench build",
-	"bench migrate",
-	"bench install-app",
-	"bench restart",
-	"npm run build",
-	"yarn build",
-	"pnpm build",
-	"python manage.py migrate",
-	"docker compose up",
-	"docker compose down",
-	"rm -rf",
-	"DROP DATABASE",
-	"TRUNCATE",
-];
-
-// --- Forward-declared types (from other workspace packages) -------------
-// In production these are imported from @pi-harness/requirement-compiler and @pi/project-analyzer.
-// Declaring them as interfaces here allows the type checker to resolve without building those packages first.
-
-export interface CompiledRequirement {
-	id: string;
-	title: string;
-	problemStatement: string;
-	goals: Array<{ id: string; description: string }>;
-	constraints: Array<{ id: string; description: string; blocking: boolean }>;
-	nonGoals?: string[];
-	acceptanceCriteria: Array<{ id: string; outcome: string[] }>;
-	riskTags: Array<{ risk: string; affectedId: string }>;
-}
-
-export interface ProjectProfile {
-	projectPath: string;
-	projectName?: string;
-	frameworks?: Array<{ name: string; confidence: number }>;
-	testCapabilities?: Array<{ runner: string; supported: boolean }>;
-	commands?: Record<string, string>;
-	rules?: Array<{
-		id: string;
-		section: string;
-		permittedCommands?: string[];
-		prohibitedCommands?: string[];
-	}>;
-}
-
-// --- Compiler Input ----------------------------------------------------
-
-export interface TaskCompileInput {
-	requirement: CompiledRequirement;
-	project: ProjectProfile;
-	dependencies?: DependencyInfo[];
-	jobId: string;
-	clock?: () => Date;
-	insertE2E?: boolean;
-	maxComplexity?: ComplexityEstimate;
-}
-
-export interface DependencyInfo {
-	requirementId: string;
-	dependsOn: string[];
-	files: string[];
-}
-
-// --- Candidate Task ---------------------------------------------------
-
-export interface TaskCandidate {
-	id: string;
-	title: string;
-	objective: string;
-	type: TaskType;
-	roughDependencies: string[];
-	criteria: string[];
-	estimatedComplexity: ComplexityEstimate;
-	priority?: number;
-}
-
-// --- Compiler Configuration ----------------------------------------------
-
-export interface TaskCompilerConfig {
-	insertE2E: boolean;
-	maxComplexity: ComplexityEstimate;
-	extraProhibitedCommands: string[];
-	clock: () => Date;
-}
-
-export const DEFAULT_TASK_COMPILER_CONFIG: TaskCompilerConfig = {
-	insertE2E: true,
-	maxComplexity: 5,
-	extraProhibitedCommands: [],
-	clock: () => new Date(),
-};
-
-// --- Compiler Errors -----------------------------------------------------
-
-export enum TaskCompilerErrorCode {
-	CYCLIC_DEPENDENCY = "CYCLIC_DEPENDENCY",
-	EMPTY_OBJECTIVE = "EMPTY_OBJECTIVE",
-	NO_VERIFICATION = "NO_VERIFICATION",
-	FILE_OVERLAP_CONFLICT = "FILE_OVERLAP_CONFLICT",
-	UNSATISFIED_CRITERION = "UNSATISFIED_CRITERION",
-	MISSING_CAPABILITY = "MISSING_CAPILITY",
-	DESTRUCTIVE_COMMAND_APPROVAL = "DESTRUCTIVE_COMMAND_APPROVAL",
-}
-
-export class TaskCompilerError extends Error {
-	readonly code: TaskCompilerErrorCode;
-	readonly details?: Record<string, unknown>;
-
-	constructor(
-		code: TaskCompilerErrorCode,
-		message: string,
-		details?: Record<string, unknown>,
-	) {
-		super(message);
-		this.name = "TaskCompilerError";
-		this.code = code;
-		this.details = details;
-	}
-}