pi-harness-runtime 0.10.7 → 0.10.11

package/packages/code-generation/src/generator.ts

@@ -1,421 +0,0 @@
-/**
- * Code Generation Pipeline - Generator
- *
- * Main code generation engine with template rendering and validation.
- */
-
-import { createHash } from "node:crypto";
-import { EjsRenderer } from "./templates/ejs-renderer.js";
-import { TemplateRegistry } from "./templates/registry.js";
-import type {
-	GeneratedFile,
-	GenerationError,
-	GenerationRequest,
-	GenerationResult,
-	GenerationWarning,
-	SchemaDefinition,
-	Template,
-	TemplateEngine,
-	ValidationContext,
-	ValidationResult,
-	ValidationRule,
-	VariableResolver,
-} from "./types.js";
-
-// --- Default Configuration -------------------------------------------------
-
-const DEFAULT_CONFIG: Required<GeneratorConfig> = {
-	outputDir: "./generated",
-	dryRun: false,
-	validate: true,
-	enableRollback: false,
-	defaultEngine: "ejs",
-	variableResolvers: [],
-	validationRules: [],
-};
-
-interface GeneratorConfig {
-	outputDir?: string;
-	dryRun?: boolean;
-	validate?: boolean;
-	enableRollback?: boolean;
-	defaultEngine?: TemplateEngine;
-	variableResolvers?: VariableResolver[];
-	validationRules?: ValidationRule[];
-}
-
-// --- Code Generator -------------------------------------------------------
-
-export class CodeGenerator {
-	private readonly config: Required<GeneratorConfig>;
-	private readonly registry: TemplateRegistry;
-	private readonly renderers: Map<TemplateEngine, TemplateRenderer>;
-	private readonly validationRules: ValidationRule[];
-	private readonly schemas: Map<string, SchemaDefinition>;
-
-	constructor(config: GeneratorConfig = {}) {
-		this.config = { ...DEFAULT_CONFIG, ...config } as Required<GeneratorConfig>;
-		this.registry = new TemplateRegistry();
-		this.renderers = new Map();
-		this.validationRules = [
-			...DEFAULT_CONFIG.validationRules,
-			...(config.validationRules ?? []),
-		];
-		this.schemas = new Map();
-
-		// Register default renderers
-		this.registerRenderer("ejs", new EjsRenderer());
-	}
-
-	/**
-	 * Register a template renderer
-	 */
-	registerRenderer(engine: TemplateEngine, renderer: TemplateRenderer): void {
-		this.renderers.set(engine, renderer);
-	}
-
-	/**
-	 * Add validation rule
-	 */
-	addValidationRule(rule: ValidationRule): void {
-		this.validationRules.push(rule);
-	}
-
-	/**
-	 * Register a schema for code generation.
-	 * Converts the schema into a template and registers it.
-	 */
-	registerSchema(schema: SchemaDefinition): void {
-		const id = schema.id ?? schema.name;
-		this.schemas.set(id, schema);
-
-		// Convert schema to a template for registration
-		const fieldsContent = schema.fields
-			.map((f) => ` * @param ${f.name} - ${f.description ?? f.type}`)
-			.join("\n");
-
-		const template: Template = {
-			id,
-			name: schema.name,
-			description: schema.description ?? `Schema: ${schema.name}`,
-			content: `/**\n${fieldsContent}\n */\nexport interface ${schema.name} {\n<% for (const field of fields) { %>\n  <%= field.name %>: <%= field.type %>;\n<% } %>\n}`,
-			tags: ["schema"],
-			engine: "ejs",
-			createdAt: new Date().toISOString(),
-			updatedAt: new Date().toISOString(),
-		};
-
-		this.registry.register(template);
-	}
-
-	/**
-	 * Get a registered schema by ID or name.
-	 */
-	getSchema(id: string): SchemaDefinition | undefined {
-		return this.schemas.get(id);
-	}
-
-	/**
-	 * Generate code from template
-	 */
-	async generate(request: GenerationRequest): Promise<GenerationResult> {
-		const startTime = Date.now();
-		const errors: GenerationError[] = [];
-		const warnings: GenerationWarning[] = [];
-		const files: GeneratedFile[] = [];
-
-		// Get template
-		const template =
-			request.template ??
-			(request.templateId
-				? this.registry.get(request.templateId)
-				: undefined) ??
-			(request.schemaId ? this.registry.get(request.schemaId) : undefined);
-
-		if (!template) {
-			return {
-				success: false,
-				files: [],
-				errors: [
-					{
-						code: "TEMPLATE_NOT_FOUND",
-						message: request.templateId
-							? `Template '${request.templateId}' not found`
-							: request.schemaId
-								? `Schema '${request.schemaId}' not found`
-								: "No template provided",
-					},
-				],
-				warnings: [],
-				durationMs: Date.now() - startTime,
-				dryRun: request.dryRun ?? this.config.dryRun,
-			};
-		}
-
-		// Validate variables
-		const variableValidation = this.validateVariables(
-			template,
-			request.variables,
-		);
-		errors.push(...variableValidation.errors);
-		warnings.push(...variableValidation.warnings);
-
-		if (errors.length > 0 && !request.validate) {
-			return {
-				success: false,
-				files: [],
-				errors,
-				warnings,
-				durationMs: Date.now() - startTime,
-				dryRun: request.dryRun ?? this.config.dryRun,
-			};
-		}
-
-		// Get renderer
-		const renderer = this.renderers.get(template.engine);
-		if (!renderer) {
-			return {
-				success: false,
-				files: [],
-				errors: [
-					{
-						code: "UNSUPPORTED_ENGINE",
-						message: `Template engine '${template.engine}' is not supported`,
-					},
-				],
-				warnings,
-				durationMs: Date.now() - startTime,
-				dryRun: request.dryRun ?? this.config.dryRun,
-			};
-		}
-
-		// Resolve variables
-		const resolvedVars = this.resolveVariables(request.variables);
-
-		// Render template
-		try {
-			const content = await renderer.render(template.content, resolvedVars);
-
-			const generatedFile: GeneratedFile = {
-				path:
-					request.outputPath ??
-					`${template.name}.${template.language ?? "txt"}`,
-				content,
-				language: template.language,
-				size: Buffer.byteLength(content),
-				checksum: this.calculateChecksum(content),
-				generatedAt: new Date().toISOString(),
-			};
-
-			files.push(generatedFile);
-
-			// Validate generated code
-			if (request.validate ?? this.config.validate) {
-				const validation = await this.validate({
-					template,
-					variables: resolvedVars,
-					generatedCode: content,
-					file: generatedFile,
-				});
-
-				if (!validation.valid) {
-					for (const error of validation.errors) {
-						errors.push({
-							code: `VALIDATION_${error.rule.toUpperCase()}`,
-							message: error.message,
-							line: error.location?.line,
-						});
-					}
-				}
-
-				for (const warning of validation.warnings) {
-					warnings.push({
-						code: `VALIDATION_${warning.rule.toUpperCase()}`,
-						message: warning.message,
-					});
-				}
-			}
-		} catch (error) {
-			errors.push({
-				code: "RENDER_ERROR",
-				message: error instanceof Error ? error.message : String(error),
-			});
-		}
-
-		return {
-			success: errors.length === 0,
-			files,
-			errors,
-			warnings,
-			durationMs: Date.now() - startTime,
-			dryRun: request.dryRun ?? this.config.dryRun,
-		};
-	}
-
-	/**
-	 * Validate variables against template schema
-	 */
-	private validateVariables(
-		template: Template,
-		variables: Record<string, unknown>,
-	): { errors: GenerationError[]; warnings: GenerationWarning[] } {
-		const errors: GenerationError[] = [];
-		const warnings: GenerationWarning[] = [];
-
-		if (!template.variables) {
-			return { errors, warnings };
-		}
-
-		// Check required variables
-		for (const variable of template.variables) {
-			if (variable.required && !(variable.name in variables)) {
-				errors.push({
-					code: "MISSING_REQUIRED_VARIABLE",
-					message: `Required variable '${variable.name}' is missing`,
-					variable: variable.name,
-				});
-			}
-		}
-
-		// Check variable types
-		for (const [name, value] of Object.entries(variables)) {
-			const variable = template.variables.find((v) => v.name === name);
-			if (variable && value !== undefined) {
-				const typeValid = this.validateVariableType(value, variable.type);
-				if (!typeValid) {
-					errors.push({
-						code: "INVALID_VARIABLE_TYPE",
-						message: `Variable '${name}' has invalid type. Expected '${variable.type}'`,
-						variable: name,
-					});
-				}
-			}
-		}
-
-		// Check for unknown variables
-		for (const name of Object.keys(variables)) {
-			const variable = template.variables.find((v) => v.name === name);
-			if (!variable && template.variables.length > 0) {
-				warnings.push({
-					code: "UNKNOWN_VARIABLE",
-					message: `Variable '${name}' is not defined in template schema`,
-					variable: name,
-				});
-			}
-		}
-
-		return { errors, warnings };
-	}
-
-	/**
-	 * Validate variable type
-	 */
-	private validateVariableType(value: unknown, type: string): boolean {
-		switch (type) {
-			case "string":
-				return typeof value === "string";
-			case "number":
-				return typeof value === "number";
-			case "boolean":
-				return typeof value === "boolean";
-			case "array":
-				return Array.isArray(value);
-			case "object":
-				return (
-					typeof value === "object" && value !== null && !Array.isArray(value)
-				);
-			case "enum":
-				return true; // Enum validation is done separately
-			default:
-				return true;
-		}
-	}
-
-	/**
-	 * Resolve variables using resolvers
-	 */
-	private resolveVariables(
-		variables: Record<string, unknown>,
-	): Record<string, unknown> {
-		const resolved = { ...variables };
-
-		for (const name of Object.keys(variables)) {
-			for (const resolver of this.config.variableResolvers ?? []) {
-				const resolvedValue = resolver.resolve(name, variables);
-				if (resolvedValue !== undefined) {
-					resolved[name] = resolvedValue;
-					break;
-				}
-			}
-		}
-
-		return resolved;
-	}
-
-	/**
-	 * Validate generated code
-	 */
-	private async validate(
-		context: ValidationContext,
-	): Promise<ValidationResult> {
-		const errors: ValidationResult["errors"] = [];
-		const warnings: ValidationResult["warnings"] = [];
-
-		for (const rule of this.validationRules) {
-			try {
-				const result = await rule.validate(context);
-
-				for (const error of result.errors) {
-					errors.push({
-						rule: rule.id,
-						message: error.message,
-						location: error.location,
-						suggestion: error.suggestion,
-					});
-				}
-
-				for (const warning of result.warnings) {
-					warnings.push({
-						rule: rule.id,
-						message: warning.message,
-						location: warning.location,
-						suggestion: warning.suggestion,
-					});
-				}
-			} catch (error) {
-				warnings.push({
-					rule: rule.id,
-					message: `Rule validation failed: ${error instanceof Error ? error.message : String(error)}`,
-				});
-			}
-		}
-
-		return {
-			valid: errors.length === 0,
-			errors,
-			warnings,
-		};
-	}
-
-	/**
-	 * Calculate checksum
-	 */
-	private calculateChecksum(content: string): string {
-		return createHash("sha256").update(content).digest("hex");
-	}
-}
-
-// --- Template Renderer Interface -------------------------------------------
-
-export interface TemplateRenderer {
-	render(template: string, variables: Record<string, unknown>): Promise<string>;
-}
-
-// --- Factory Function ------------------------------------------------------
-
-/**
- * Create a code generator
- */
-export function createCodeGenerator(config?: GeneratorConfig): CodeGenerator {
-	return new CodeGenerator(config);
-}

package/packages/code-generation/src/index.ts

@@ -1,56 +0,0 @@
-/**
- * Code Generation Pipeline
- *
- * Generate code from templates with variable substitution, validation,
- * and automatic rollback capabilities.
- */
-
-// --- Generator ----------------------------------------------------------
-
-export { createFaker } from "./faker.js";
-
-export {
-	CodeGenerator,
-	createCodeGenerator,
-	type TemplateRenderer,
-} from "./generator.js";
-
-// --- Templates ---------------------------------------------------------
-
-export { TemplateRegistry } from "./templates/registry.js";
-export { EjsRenderer } from "./templates/ejs-renderer.js";
-
-// --- Types ------------------------------------------------------------
-
-export {
-	SDK_VERSION,
-	type Template,
-	type TemplateVariable,
-	type TemplateEngine,
-	type TemplateSet,
-	type GenerationRequest,
-	type GeneratedFile,
-	type GenerationResult,
-	type GenerationError,
-	type GenerationWarning,
-	type ValidationRule,
-	type ValidationCategory,
-	type ValidationContext,
-	type ValidationResult,
-	type ValidationIssue,
-	type FileSnapshot,
-	type ChangeRecord,
-	type RollbackSession,
-	type RollbackResult,
-	type ChangeSet,
-	type FileChange,
-	type DiffChunk,
-	type RegistryEntry,
-	type RegistryQuery,
-	type GeneratorConfig,
-	type SchemaDefinition,
-	type SchemaField,
-	type VariableResolver,
-	type OutputFormat,
-	type OutputConfig,
-} from "./types.js";

package/packages/code-generation/src/templates/ejs-renderer.ts

@@ -1,142 +0,0 @@
-/**
- * Code Generation Pipeline - EJS Renderer
- *
- * EJS-based template rendering.
- */
-
-import type { TemplateRenderer } from "../generator.js";
-
-/**
- * EJS Renderer for template rendering
- */
-export class EjsRenderer implements TemplateRenderer {
-	private readonly options: EjsOptions;
-
-	constructor(options: EjsOptions = {}) {
-		this.options = {
-			...DEFAULT_EJS_OPTIONS,
-			...options,
-		};
-	}
-
-	/**
-	 * Render template with variables
-	 */
-	async render(
-		template: string,
-		variables: Record<string, unknown>,
-	): Promise<string> {
-		// Simple EJS-like template rendering
-		// In production, use the actual ejs package
-
-		let result = template;
-
-		// Process <%= variable %> expressions
-		result = result.replace(/<%=\s*([^%]+?)\s*%>/g, (_, expr) => {
-			return this.evaluateExpression(expr.trim(), variables);
-		});
-
-		// Process <% code %> blocks
-		result = result.replace(/<%\s*([^%]+?)\s*%>/g, (_, code) => {
-			return this.executeCode(code.trim(), variables);
-		});
-
-		// Process <%- unescaped %> expressions
-		result = result.replace(/<%-\s*([^%]+?)\s*-%>/g, (_, expr) => {
-			return this.evaluateExpression(expr.trim(), variables);
-		});
-
-		// Process includes (simple version)
-		result = result.replace(
-			/<%-?\s*include\s*\(\s*['"]([^'"]+)['"]\s*\)\s*-%>/g,
-			(_, name) => {
-				return `[Include: ${name}]`;
-			},
-		);
-
-		return result;
-	}
-
-	/**
-	 * Evaluate expression
-	 */
-	private evaluateExpression(
-		expr: string,
-		context: Record<string, unknown>,
-	): string {
-		try {
-			// Handle property access
-			if (expr.includes(".")) {
-				const parts = expr.split(".");
-				let value: unknown = context;
-				for (const part of parts) {
-					if (value && typeof value === "object") {
-						value = (value as Record<string, unknown>)[part];
-					} else {
-						return "";
-					}
-				}
-				return String(value ?? "");
-			}
-
-			// Handle simple variable
-			const value = context[expr];
-			if (value === undefined) {
-				return "";
-			}
-
-			// Handle arrays/objects
-			if (Array.isArray(value)) {
-				return value.join(", ");
-			}
-
-			if (typeof value === "object" && value !== null) {
-				return JSON.stringify(value);
-			}
-
-			return String(value);
-		} catch {
-			return "";
-		}
-	}
-
-	/**
-	 * Execute code block
-	 */
-	private executeCode(code: string, _context: Record<string, unknown>): string {
-		// Simple control flow support
-		// In production, use the actual ejs package
-
-		if (code.startsWith("if ")) {
-			return "";
-		}
-
-		if (code.startsWith("}")) {
-			return "";
-		}
-
-		if (code.startsWith("for ") || code.startsWith("while ")) {
-			return "";
-		}
-
-		if (code.startsWith("/")) {
-			return "";
-		}
-
-		return "";
-	}
-}
-
-interface EjsOptions {
-	strict?: boolean;
-	debug?: boolean;
-	open?: string;
-	close?: string;
-}
-
-const DEFAULT_EJS_OPTIONS: EjsOptions = {
-	strict: false,
-	debug: false,
-	open: "<%",
-	close: "%>",
-};