@powerhousedao/vetra 6.0.0-dev.23 → 6.0.0-dev.231

package/dist/codegen-kWVjy8i2.js

@@ -0,0 +1,882 @@
+import { t as logger } from "./logger-BLNtquAC.js";
+import { PROCESSOR_APPS } from "@powerhousedao/shared/processors";
+import { createInterface } from "readline";
+import { generateApp, generateDocumentModel, generateEditor, generateProcessor, generateSubgraph, validateDocumentModelState } from "@powerhousedao/codegen";
+import { kebabCase } from "change-case";
+import { baseMinimalSaveToFile } from "document-model/node";
+import { mkdir } from "fs/promises";
+import { join } from "path";
+import { createOrUpdateManifest } from "@powerhousedao/codegen/file-builders";
+//#region processors/codegen/document-handlers/base-document-gen.ts
+/**
+* Abstract base class for document generators
+* Defines the interface that all document-type handlers must implement
+*/
+var BaseDocumentGen = class {
+	project;
+	constructor(config, project) {
+		this.config = config;
+		this.project = project;
+	}
+	/**
+	* Check if this generator supports the given document type
+	*/
+	supportsDocumentType(documentType) {
+		if (typeof this.supportedDocumentTypes === "string") return this.supportedDocumentTypes === documentType;
+		return this.supportedDocumentTypes.includes(documentType);
+	}
+	/**
+	* Get all supported document types as an array
+	*/
+	getSupportedDocumentTypes() {
+		if (typeof this.supportedDocumentTypes === "string") return [this.supportedDocumentTypes];
+		return [...this.supportedDocumentTypes];
+	}
+	/**
+	* Validate if this strand should be processed
+	* Override this method in specific generators to add custom validation logic
+	*/
+	shouldProcess(strand) {
+		if (!strand.documentId || !strand.documentType) return false;
+		if (!this.supportsDocumentType(strand.documentType)) return false;
+		return true;
+	}
+};
+//#endregion
+//#region processors/codegen/interactive-manager.ts
+/**
+* InteractiveManager handles user interaction for code generation confirmation
+* Supports both individual strand processing and queue-based batch processing
+*/
+var InteractiveManager = class {
+	isInteractiveMode;
+	processingConfirmation = false;
+	strandQueue = /* @__PURE__ */ new Map();
+	constructor(interactiveMode = false) {
+		this.isInteractiveMode = interactiveMode;
+	}
+	getDocumentKey(documentType, documentId) {
+		return `${documentType}:${documentId}`;
+	}
+	/**
+	* Add a strand to the queue, replacing any existing strand for the same document
+	*/
+	queueStrand(strand) {
+		const documentKey = this.getDocumentKey(strand.documentType, strand.documentId);
+		this.strandQueue.set(documentKey, {
+			strand,
+			timestamp: Date.now()
+		});
+		logger.debug(`>>> Queued strand for ${documentKey}, queue size: ${this.strandQueue.size}`);
+	}
+	/**
+	* Get all queued strands
+	*/
+	getQueuedStrands() {
+		return Array.from(this.strandQueue.values());
+	}
+	/**
+	* Clear and return all queued strands
+	*/
+	clearQueue() {
+		const queuedStrands = Array.from(this.strandQueue.values());
+		this.strandQueue.clear();
+		return queuedStrands;
+	}
+	/**
+	* Get the current queue size
+	*/
+	getQueueSize() {
+		return this.strandQueue.size;
+	}
+	async promptUserConfirmation() {
+		return new Promise((resolve) => {
+			const rl = createInterface({
+				input: process.stdin,
+				output: process.stdout
+			});
+			console.log("\n" + "=".repeat(50));
+			console.log("🔄 Code generation ready to run.");
+			console.log("=".repeat(50));
+			process.stdout.write("Do you want to proceed with code generation? (y/n): \n\n");
+			rl.on("line", (answer) => {
+				rl.close();
+				console.log("");
+				resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+			});
+		});
+	}
+	/**
+	* Process generation with user confirmation (legacy single-strand method)
+	* This method assumes interactive mode is already enabled (checked by caller)
+	*/
+	async processWithConfirmation(documentType, generator) {
+		if (this.processingConfirmation) {
+			logger.debug("Already processing confirmation, skipping");
+			return null;
+		}
+		this.processingConfirmation = true;
+		try {
+			if (!await this.promptUserConfirmation()) {
+				logger.info(`❌ Code generation cancelled by user for ${documentType}`);
+				return null;
+			}
+			logger.info(`✅ User approved code generation for ${documentType}`);
+			return await generator();
+		} catch (error) {
+			logger.error(`❌ Error during interactive code generation for ${documentType}:`, error);
+			throw error;
+		} finally {
+			this.processingConfirmation = false;
+		}
+	}
+	/**
+	* Process all queued strands with a single user confirmation
+	* This is the main method for queue-based interactive processing
+	*/
+	async processQueueWithConfirmation(processor) {
+		if (this.processingConfirmation) {
+			logger.debug("Already processing confirmation, skipping queue processing");
+			return;
+		}
+		let queuedStrands = this.getQueuedStrands();
+		if (queuedStrands.length === 0) {
+			logger.debug("No strands in queue to process");
+			return;
+		}
+		this.processingConfirmation = true;
+		try {
+			if (!await this.promptUserConfirmation()) {
+				logger.info("❌ Code generation cancelled by user");
+				this.clearQueue();
+				return;
+			}
+			queuedStrands = this.clearQueue();
+			if (queuedStrands.length === 0) {
+				logger.info("ℹ️ No documents to process");
+				return;
+			}
+			logger.info(`✅ User approved code generation for ${queuedStrands.length} document(s)`);
+			await processor(queuedStrands);
+			logger.info("✅ Code generation completed");
+		} catch (error) {
+			logger.error("❌ Error during interactive queue processing:", error);
+			throw error;
+		} finally {
+			this.processingConfirmation = false;
+		}
+	}
+	setInteractiveMode(enabled) {
+		this.isInteractiveMode = enabled;
+		logger.debug(`Interactive mode set to: ${enabled}`);
+	}
+	isInteractive() {
+		return this.isInteractiveMode;
+	}
+	isProcessing() {
+		return this.processingConfirmation;
+	}
+};
+//#endregion
+//#region processors/codegen/document-handlers/document-codegen-manager.ts
+const DEFAULT_DEBOUNCE_TIME = 1e3;
+/**
+* Manager class responsible for routing documents to the correct generator
+* and managing generator registration and instantiation
+*/
+var DocumentCodegenManager = class {
+	project;
+	generators = /* @__PURE__ */ new Map();
+	debounceTimers = /* @__PURE__ */ new Map();
+	processingQueue = Promise.resolve();
+	interactiveManager;
+	constructor(config, project, interactiveMode = false) {
+		this.config = config;
+		this.project = project;
+		this.interactiveManager = new InteractiveManager(interactiveMode);
+	}
+	/**
+	* Register a generator class for a specific document type
+	*/
+	registerGenerator(documentType, generatorClass) {
+		if (this.generators.has(documentType)) logger.warn(`⚠️ Generator for document type "${documentType}" is already registered. Overwriting.`);
+		this.generators.set(documentType, new generatorClass(this.config, this.project));
+		logger.debug(`✅ Registered generator for document type: ${documentType}`);
+	}
+	/**
+	* Register a generator class that supports multiple document types
+	*/
+	registerMultiTypeGenerator(generatorClass) {
+		const generator = new generatorClass(this.config, this.project);
+		const supportedTypes = generator.getSupportedDocumentTypes();
+		for (const documentType of supportedTypes) {
+			if (this.generators.has(documentType)) logger.warn(`⚠️ Generator for document type "${documentType}" is already registered. Overwriting.`);
+			this.generators.set(documentType, generator);
+		}
+		logger.debug(`✅ Registered multi-type generator for document types: ${supportedTypes.join(", ")}`);
+	}
+	/**
+	* Get a generator instance for the given document type
+	* Public method to allow external access for validation
+	*/
+	getGenerator(documentType) {
+		return this.generators.get(documentType);
+	}
+	/**
+	* Get all registered document types
+	*/
+	getRegisteredDocumentTypes() {
+		return Array.from(this.generators.keys());
+	}
+	/**
+	* Check if a document type is supported
+	*/
+	isDocumentTypeSupported(documentType) {
+		return this.generators.has(documentType);
+	}
+	/**
+	* Route a document to the appropriate generator and handle the generation
+	* Handles both interactive and non-interactive modes with queue-based processing
+	*/
+	async routeAndGenerate(strand) {
+		const documentType = strand.documentType;
+		if (!documentType) {
+			logger.error("❌ Document type is missing from strand state");
+			throw new Error("Document type is missing from strand state");
+		}
+		const generator = this.getGenerator(documentType);
+		if (!generator) {
+			logger.warn(`⚠️ No generator found for document type: ${documentType}`);
+			logger.warn(`ℹ️ Supported document types: ${this.getRegisteredDocumentTypes().join(", ")}`);
+			throw new Error(`Unsupported document type: ${documentType}`);
+		}
+		if (!generator.shouldProcess(strand)) {
+			logger.debug(`>>> Generator validation failed for ${documentType}:${strand.documentId}, skipping processing`);
+			return;
+		}
+		if (this.interactiveManager.isInteractive()) {
+			logger.debug(`>>> Queueing strand for interactive processing: ${documentType}:${strand.documentId}`);
+			this.interactiveManager.queueStrand(strand);
+			const existingTimer = this.debounceTimers.get("interactive");
+			if (existingTimer) clearTimeout(existingTimer);
+			const debounceTimer = setTimeout(async () => {
+				try {
+					await this.interactiveManager.processQueueWithConfirmation(async (queuedStrands) => {
+						await this.processQueuedStrands(queuedStrands);
+					});
+				} catch (error) {
+					logger.error("❌ Error during interactive batch processing:", error);
+				} finally {
+					this.debounceTimers.delete("interactive");
+				}
+			}, DEFAULT_DEBOUNCE_TIME);
+			this.debounceTimers.set("interactive", debounceTimer);
+		} else {
+			const timerKey = `${documentType}:${strand.documentId}`;
+			const existingTimer = this.debounceTimers.get(timerKey);
+			if (existingTimer) clearTimeout(existingTimer);
+			const debounceTimer = setTimeout(async () => {
+				try {
+					logger.debug(`🔄 Routing document type "${documentType}" to generator (debounced)`);
+					await generator.generate(strand);
+					logger.debug(`✅ Successfully generated code for document type: ${documentType}`);
+				} catch (error) {
+					logger.error(`❌ Error generating code for document type "${documentType}":`, error);
+				} finally {
+					this.debounceTimers.delete(timerKey);
+				}
+			}, DEFAULT_DEBOUNCE_TIME);
+			this.debounceTimers.set(timerKey, debounceTimer);
+		}
+	}
+	/**
+	* Process multiple strands in priority order (document-model types first)
+	*/
+	async processQueuedStrands(queuedStrands) {
+		logger.debug(`🔄 Processing ${queuedStrands.length} queued strand(s)`);
+		const documentModelStrands = queuedStrands.filter((qs) => qs.strand.documentType === "powerhouse/document-model");
+		const otherStrands = queuedStrands.filter((qs) => qs.strand.documentType !== "powerhouse/document-model");
+		for (const queuedStrand of documentModelStrands) await this.processStrand(queuedStrand.strand);
+		for (const queuedStrand of otherStrands) await this.processStrand(queuedStrand.strand);
+		logger.debug(`✅ Successfully processed all ${queuedStrands.length} queued strand(s)`);
+	}
+	/**
+	* Process a single strand (used internally by processQueuedStrands)
+	*/
+	async processStrand(strand) {
+		const documentType = strand.documentType;
+		const generator = this.getGenerator(documentType);
+		if (!generator) {
+			logger.warn(`⚠️ No generator found for document type: ${documentType}`);
+			return;
+		}
+		try {
+			logger.debug(`🔄 Generating code for document type: ${documentType}`);
+			await generator.generate(strand);
+			logger.debug(`✅ Successfully generated code for document type: ${documentType}`);
+		} catch (error) {
+			logger.error(`❌ Error generating code for document type "${documentType}":`, error);
+		}
+	}
+	/**
+	* Clear all registered generators
+	*/
+	clearGenerators() {
+		this.generators.clear();
+		logger.debug("🧹 Cleared all registered generators");
+	}
+	/**
+	* Get statistics about registered generators
+	*/
+	getStats() {
+		return {
+			totalGenerators: this.generators.size,
+			supportedTypes: this.getRegisteredDocumentTypes()
+		};
+	}
+	/**
+	* Set interactive mode for code generation
+	*/
+	setInteractiveMode(enabled) {
+		this.interactiveManager.setInteractiveMode(enabled);
+	}
+	/**
+	* Check if interactive mode is enabled
+	*/
+	isInteractiveMode() {
+		return this.interactiveManager.isInteractive();
+	}
+	/**
+	* Check if the manager is currently processing an interactive confirmation
+	*/
+	isProcessingInteractive() {
+		return this.interactiveManager.isProcessing();
+	}
+};
+//#endregion
+//#region processors/codegen/document-handlers/generators/utils.ts
+const BACKUP_FOLDER = "backup-documents";
+/**
+* Creates a minimal backup of a document from strand data.
+* Used when the full document is not available (e.g., in onOperations handler).
+*/
+async function minimalBackupDocument(data, workingDir, extension) {
+	try {
+		const backupPath = join(workingDir, BACKUP_FOLDER);
+		await mkdir(backupPath, { recursive: true });
+		const filePath = await baseMinimalSaveToFile(data, backupPath, extension ?? "");
+		logger.debug(`Document backed up to: ${filePath}`);
+		return filePath;
+	} catch (error) {
+		logger.warn(`Failed to backup document "${data.name}":`, error);
+		return;
+	}
+}
+//#endregion
+//#region processors/codegen/document-handlers/generators/app-generator.ts
+/**
+* Generator for app documents
+*/
+var AppGenerator = class extends BaseDocumentGen {
+	supportedDocumentTypes = "powerhouse/app";
+	/**
+	* Parse and extract the global state from the serialized state string
+	*/
+	extractGlobalState(input) {
+		if (!input.state) return;
+		return input.state.global;
+	}
+	/**
+	* Validate if this app strand should be processed
+	*/
+	shouldProcess(input) {
+		if (!super.shouldProcess(input)) return false;
+		const state = this.extractGlobalState(input);
+		if (!state) {
+			logger.debug(`No state found for app: ${input.documentId}`);
+			return false;
+		}
+		if (!state.name) {
+			logger.debug(`No name found for app: ${input.documentId}`);
+			return false;
+		}
+		if (state.status !== "CONFIRMED") {
+			logger.debug(`App not confirmed: ${state.name} (status: ${state.status})`);
+			return false;
+		}
+		return true;
+	}
+	async generate(input) {
+		const state = this.extractGlobalState(input);
+		if (!state) {
+			logger.error(`No state found for app: ${input.documentId}`);
+			return;
+		}
+		if (state.name && state.status === "CONFIRMED") {
+			logger.info(`🔄 Starting app generation for app: ${state.name}`);
+			try {
+				const appId = kebabCase(state.name);
+				await generateApp({
+					...this.config.PH_CONFIG,
+					appName: state.name,
+					appId,
+					allowedDocumentTypes: state.allowedDocumentTypes ?? [],
+					isDragAndDropEnabled: state.isDragAndDropEnabled
+				}, this.project);
+				await this.project.save();
+				logger.info(`✅ App generation completed successfully for app: ${state.name}`);
+				const fullState = input.state;
+				await minimalBackupDocument({
+					documentId: input.documentId,
+					documentType: input.documentType,
+					branch: input.branch,
+					state: fullState,
+					name: state.name
+				}, this.config.CURRENT_WORKING_DIR);
+			} catch (error) {
+				logger.error(`❌ Error during app generation for app ${state.name}:`, error);
+				if (error instanceof Error) logger.error(`❌ Error message: ${error.message}`);
+			}
+		} else if (!state.name) {
+			logger.error(`❌ Skipping app generation - missing name for app`);
+			return;
+		} else if (state.status !== "CONFIRMED") {
+			logger.error(`❌ Skipping app generation - app "${state.name}" is not confirmed (status: ${state.status})`);
+			return;
+		}
+	}
+};
+//#endregion
+//#region processors/codegen/document-handlers/generators/document-editor-generator.ts
+/**
+* Generator for document editor documents
+*/
+var DocumentEditorGenerator = class extends BaseDocumentGen {
+	supportedDocumentTypes = "powerhouse/document-editor";
+	/**
+	* Parse and extract the global state from the serialized state string
+	*/
+	extractGlobalState(input) {
+		if (!input.state) return;
+		return input.state.global;
+	}
+	/**
+	* Validate if this document editor strand should be processed
+	*/
+	shouldProcess(input) {
+		if (!super.shouldProcess(input)) return false;
+		const state = this.extractGlobalState(input);
+		if (!state) {
+			logger.debug(`No state found for document editor: ${input.documentId}`);
+			return false;
+		}
+		if (!state.name) {
+			logger.debug(`No name found for document editor: ${input.documentId}`);
+			return false;
+		}
+		if (!state.documentTypes || state.documentTypes.length === 0) {
+			logger.debug(`No document types found for document editor: ${state.name}`);
+			return false;
+		}
+		if (state.status !== "CONFIRMED") {
+			logger.debug(`Document editor not confirmed: ${state.name} (status: ${state.status})`);
+			return false;
+		}
+		return true;
+	}
+	async generate(input) {
+		const state = this.extractGlobalState(input);
+		if (!state) {
+			logger.error(`No state found for document editor: ${input.documentId}`);
+			return;
+		}
+		logger.info(`🔄 Starting editor generation for: ${state.name}`);
+		try {
+			const documentTypes = state.documentTypes.map((dt) => dt.documentType);
+			const editorId = kebabCase(state.name);
+			await generateEditor({
+				...this.config.PH_CONFIG,
+				editorName: state.name,
+				documentTypes,
+				editorId
+			}, this.project);
+			await this.project.save();
+			logger.info(`✅ Editor generation completed successfully for: ${state.name}`);
+			const fullState = input.state;
+			await minimalBackupDocument({
+				documentId: input.documentId,
+				documentType: input.documentType,
+				branch: input.branch,
+				state: fullState,
+				name: state.name
+			}, this.config.CURRENT_WORKING_DIR);
+		} catch (error) {
+			logger.error(`❌ Error during editor generation for ${state.name}:`, error);
+			if (error instanceof Error) logger.error(`❌ Error message: ${error.message}`);
+			return;
+		}
+	}
+};
+//#endregion
+//#region processors/codegen/document-handlers/generators/document-model-generator.ts
+/**
+* Generator for document model documents
+*/
+var DocumentModelGenerator = class extends BaseDocumentGen {
+	supportedDocumentTypes = "powerhouse/document-model";
+	/**
+	* Parse and extract the global state from the serialized state string
+	*/
+	extractGlobalState(input) {
+		if (!input.state) return;
+		return input.state.global;
+	}
+	/**
+	* Validate if this document model strand should be processed
+	*/
+	shouldProcess(input) {
+		if (!super.shouldProcess(input)) return false;
+		const globalState = this.extractGlobalState(input);
+		if (!globalState) {
+			logger.debug(`>>> No global state found for document model: ${input.documentId}`);
+			return false;
+		}
+		const validationResult = validateDocumentModelState(globalState);
+		if (!validationResult.isValid) {
+			const errorList = validationResult.errors.map((error) => `  - ${error}`).join("\n");
+			logger.info(`⚠️  Skipped code generation for '${globalState.name || input.documentId}' due to validation errors:\n${errorList}`);
+			return false;
+		}
+		logger.info(`Document model ${globalState.name} is valid, proceeding with code generation`);
+		return true;
+	}
+	async generate(input) {
+		const globalState = this.extractGlobalState(input);
+		if (!globalState) {
+			logger.error(`❌ No global state found for document model: ${input.documentId}`);
+			return;
+		}
+		logger.debug(`🔄 Starting code generation for document model: ${globalState.name}`);
+		try {
+			await generateDocumentModel(globalState, this.project);
+			await this.project.save();
+			logger.info(`✅ Code generation completed successfully for: ${globalState.name}`);
+			const fullState = input.state;
+			const extension = globalState.extension?.replace(/^\.+|\.+$/g, "") || "";
+			await minimalBackupDocument({
+				documentId: input.documentId,
+				documentType: input.documentType,
+				branch: input.branch,
+				state: fullState,
+				name: globalState.name
+			}, this.config.CURRENT_WORKING_DIR, extension);
+		} catch (error) {
+			logger.error(`❌ Error during code generation for ${globalState.name}:`, error);
+			return;
+		}
+	}
+};
+//#endregion
+//#region processors/codegen/document-handlers/generators/package-generator.ts
+/**
+* Generator for package documents
+*/
+var PackageGenerator = class extends BaseDocumentGen {
+	supportedDocumentTypes = "powerhouse/package";
+	/**
+	* Validate if this package strand should be processed
+	*/
+	shouldProcess(input) {
+		if (!super.shouldProcess(input)) return false;
+		if (!input.state) {
+			logger.debug(`>>> No state found for package: ${input.documentId}`);
+			return false;
+		}
+		return true;
+	}
+	async generate(input) {
+		const fullState = input.state;
+		const state = fullState.global;
+		await createOrUpdateManifest({
+			name: state.name ?? "",
+			category: state.category ?? "",
+			description: state.description ?? "",
+			publisher: {
+				name: state.author?.name ?? "",
+				url: state.author?.website ?? ""
+			}
+		}, this.config.CURRENT_WORKING_DIR);
+		await minimalBackupDocument({
+			documentId: input.documentId,
+			documentType: input.documentType,
+			branch: input.branch,
+			state: fullState,
+			name: "vetra-package"
+		}, this.config.CURRENT_WORKING_DIR);
+	}
+};
+//#endregion
+//#region processors/codegen/document-handlers/generators/processor-generator.ts
+/**
+* Generator for processor documents
+*/
+var ProcessorGenerator = class extends BaseDocumentGen {
+	supportedDocumentTypes = "powerhouse/processor";
+	/**
+	* Parse and extract the global state from the serialized state string
+	*/
+	extractGlobalState(input) {
+		if (!input.state) return;
+		return input.state.global;
+	}
+	/**
+	* Validate if this processor strand should be processed
+	*/
+	shouldProcess(input) {
+		if (!super.shouldProcess(input)) return false;
+		const state = this.extractGlobalState(input);
+		if (!state) {
+			logger.debug(`No state found for processor: ${input.documentId}`);
+			return false;
+		}
+		if (!state.name) {
+			logger.debug(`No name found for processor: ${input.documentId}`);
+			return false;
+		}
+		if (!state.type) {
+			logger.debug(`No type found for processor: ${state.name}`);
+			return false;
+		}
+		if (!state.documentTypes || state.documentTypes.length === 0) {
+			logger.debug(`No document types found for processor: ${state.name}`);
+			return false;
+		}
+		if (!state.processorApps || state.processorApps.length === 0) {
+			logger.debug(`No processor apps found for processor: ${state.name}`);
+			return false;
+		}
+		if (state.status !== "CONFIRMED") {
+			logger.debug(`Processor not confirmed: ${state.name} (status: ${state.status})`);
+			return false;
+		}
+		return true;
+	}
+	async generate(input) {
+		const state = this.extractGlobalState(input);
+		if (!state) {
+			logger.error(`No state found for processor: ${input.documentId}`);
+			return;
+		}
+		if (state.name && state.type && state.documentTypes.length > 0 && state.processorApps.length > 0 && state.status === "CONFIRMED") {
+			logger.info(`🔄 Starting processor generation for: ${state.name}`);
+			try {
+				let processorType;
+				if (state.type === "analytics") processorType = "analytics";
+				else if (state.type === "relational") processorType = "relationalDb";
+				else {
+					logger.error(`❌ Unsupported processor type: ${state.type}`);
+					return;
+				}
+				const documentTypes = state.documentTypes.map((dt) => dt.documentType);
+				const processorApps = state.processorApps;
+				if (!isProcessorApps(processorApps)) {
+					logger.error(`❌ Unsupported processor apps: ${processorApps.join(", ")}`);
+					return;
+				}
+				await generateProcessor({
+					processorName: state.name,
+					processorType,
+					documentTypes,
+					processorApps
+				}, this.project);
+				await this.project.save();
+				logger.info(`✅ Processor generation completed successfully for: ${state.name}`);
+				const fullState = input.state;
+				await minimalBackupDocument({
+					documentId: input.documentId,
+					documentType: input.documentType,
+					branch: input.branch,
+					state: fullState,
+					name: state.name
+				}, this.config.CURRENT_WORKING_DIR);
+			} catch (error) {
+				logger.error(`❌ Error during processor generation for ${state.name}:`, error);
+				if (error instanceof Error) logger.error(`❌ Error message: ${error.message}`);
+			}
+		} else if (!state.name) {
+			logger.error(`❌ Skipping processor generation - missing name for processor`);
+			return;
+		} else if (!state.type) {
+			logger.error(`❌ Skipping processor generation - missing type for processor "${state.name}"`);
+			return;
+		} else if (state.documentTypes.length === 0) {
+			logger.error(`❌ Skipping processor generation - missing document types for processor "${state.name}"`);
+			return;
+		} else if (state.status !== "CONFIRMED") {
+			logger.error(`❌ Skipping processor generation - processor "${state.name}" is not confirmed (status: ${state.status})`);
+			return;
+		}
+	}
+};
+function isProcessorApps(input) {
+	if (input.length === 0) return false;
+	if (new Set(input).size !== input.length) return false;
+	if (!input.every((i) => PROCESSOR_APPS.includes(i))) return false;
+	return true;
+}
+//#endregion
+//#region processors/codegen/document-handlers/generators/subgraph-generator.ts
+/**
+* Generator for subgraph documents
+*/
+var SubgraphGenerator = class extends BaseDocumentGen {
+	supportedDocumentTypes = "powerhouse/subgraph";
+	/**
+	* Parse and extract the global state from the serialized state string
+	*/
+	extractGlobalState(input) {
+		if (!input.state) return;
+		return input.state.global;
+	}
+	/**
+	* Validate if this subgraph strand should be processed
+	*/
+	shouldProcess(input) {
+		if (!super.shouldProcess(input)) return false;
+		const state = this.extractGlobalState(input);
+		if (!state) {
+			logger.debug(`No state found for subgraph: ${input.documentId}`);
+			return false;
+		}
+		if (!state.name) {
+			logger.debug(`No name found for subgraph: ${input.documentId}`);
+			return false;
+		}
+		if (state.status !== "CONFIRMED") {
+			logger.debug(`Subgraph not confirmed: ${state.name} (status: ${state.status})`);
+			return false;
+		}
+		return true;
+	}
+	async generate(input) {
+		const state = this.extractGlobalState(input);
+		if (!state) {
+			logger.error(`No state found for subgraph: ${input.documentId}`);
+			return;
+		}
+		if (state.name && state.status === "CONFIRMED") {
+			logger.info(`🔄 Starting subgraph generation for: ${state.name}`);
+			try {
+				await generateSubgraph(state.name, this.project);
+				await this.project.save();
+				logger.info(`✅ Subgraph generation completed successfully for: ${state.name}`);
+				const fullState = input.state;
+				await minimalBackupDocument({
+					documentId: input.documentId,
+					documentType: input.documentType,
+					branch: input.branch,
+					state: fullState,
+					name: state.name
+				}, this.config.CURRENT_WORKING_DIR);
+			} catch (error) {
+				logger.error(`❌ Error during subgraph generation for ${state.name}:`, error);
+			}
+		} else if (!state.name) {
+			logger.error(`❌ Skipping subgraph generation - missing name for subgraph`);
+			return;
+		} else if (state.status !== "CONFIRMED") {
+			logger.error(`❌ Skipping subgraph generation - subgraph "${state.name}" is not confirmed (status: ${state.status})`);
+			return;
+		}
+	}
+};
+//#endregion
+//#region processors/codegen/document-handlers/document-codegen-factory.ts
+/**
+* Factory class for creating and configuring DocumentCodegenManager instances
+* with all the standard generators pre-registered
+*/
+var DocumentCodegenFactory = class {
+	/**
+	* Create a DocumentCodegenManager with all standard generators registered
+	*/
+	static createManager(config, project, interactiveMode = false) {
+		const manager = new DocumentCodegenManager(config, project, interactiveMode);
+		manager.registerGenerator("powerhouse/document-model", DocumentModelGenerator);
+		manager.registerGenerator("powerhouse/package", PackageGenerator);
+		manager.registerGenerator("powerhouse/app", AppGenerator);
+		manager.registerGenerator("powerhouse/document-editor", DocumentEditorGenerator);
+		manager.registerGenerator("powerhouse/subgraph", SubgraphGenerator);
+		manager.registerGenerator("powerhouse/processor", ProcessorGenerator);
+		return manager;
+	}
+	/**
+	* Create a DocumentCodegenManager with only specific generators
+	*/
+	static createManagerWithGenerators(config, generators, project, interactiveMode = false) {
+		const manager = new DocumentCodegenManager(config, project, interactiveMode);
+		for (const generatorClass of generators) {
+			const supportedTypes = new generatorClass(config).getSupportedDocumentTypes();
+			for (const documentType of supportedTypes) manager.registerGenerator(documentType, generatorClass);
+		}
+		return manager;
+	}
+	/**
+	* Get all available generator classes
+	*/
+	static getAvailableGenerators() {
+		return {
+			DocumentModelGenerator,
+			PackageGenerator,
+			AppGenerator,
+			DocumentEditorGenerator,
+			SubgraphGenerator,
+			ProcessorGenerator
+		};
+	}
+};
+//#endregion
+//#region processors/codegen/index.ts
+var CodegenProcessor = class {
+	manager;
+	constructor(project, config, cwd, interactiveMode = false) {
+		this.manager = DocumentCodegenFactory.createManager({
+			PH_CONFIG: config,
+			CURRENT_WORKING_DIR: cwd
+		}, project, interactiveMode);
+		if (interactiveMode) logger.info(`CodegenProcessor initialized with interactive mode enabled`);
+		else logger.debug(`CodegenProcessor initialized with interactive mode disabled`);
+	}
+	async onOperations(operations) {
+		logger.info("CodegenProcessor.onOperations()");
+		for (const { context } of operations) {
+			const generator = this.manager.getGenerator(context.documentType);
+			if (!generator) {
+				logger.debug(`No generator found for document type: ${context.documentType}`);
+				continue;
+			}
+			const input = {
+				documentId: context.documentId,
+				documentType: context.documentType,
+				scope: context.scope,
+				branch: context.branch,
+				state: context.resultingState ? JSON.parse(context.resultingState) : void 0
+			};
+			if (generator.shouldProcess(input)) await this.manager.routeAndGenerate(input);
+		}
+	}
+	async onDisconnect() {}
+	setInteractiveMode(enabled) {
+		this.manager.setInteractiveMode(enabled);
+	}
+	isInteractive() {
+		return this.manager.isInteractiveMode();
+	}
+	isProcessingInteractive() {
+		return this.manager.isProcessingInteractive();
+	}
+};
+//#endregion
+export { CodegenProcessor as t };
+
+//# sourceMappingURL=codegen-kWVjy8i2.js.map