@powerhousedao/vetra 4.1.0-dev.9 → 4.1.0-dev.91

package/dist/processors/codegen/__tests__/factory.test.js

@@ -0,0 +1,190 @@
+import { VETRA_PROCESSOR_CONFIG_KEY } from "@powerhousedao/config";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { codegenProcessorFactory } from "../factory.js";
+// Mock CodegenProcessor to avoid file operations
+vi.mock("../index.js", () => ({
+    CodegenProcessor: vi.fn(() => ({
+        onStrands: vi.fn(),
+    })),
+}));
+describe("Codegen Processor Factory - Drive Filtering", () => {
+    let mockModule;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Setup default module with no config
+        mockModule = {
+            config: new Map(),
+        };
+    });
+    describe("Vetra Drive Pattern Matching (No Explicit Config)", () => {
+        it("should create processor for drive with slug 'vetra'", () => {
+            const driveHeader = {
+                id: "some-id",
+                slug: "vetra",
+            };
+            const result = codegenProcessorFactory(mockModule)(driveHeader);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toHaveProperty("processor");
+            expect(result[0]).toHaveProperty("filter");
+        });
+        it("should create processor for drive with id 'vetra'", () => {
+            const driveHeader = {
+                id: "vetra",
+                slug: "other-slug",
+            };
+            const result = codegenProcessorFactory(mockModule)(driveHeader);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toHaveProperty("processor");
+        });
+        it("should create processor for drive with slug starting with 'vetra-'", () => {
+            const driveHeader = {
+                id: "some-id",
+                slug: "vetra-dev",
+            };
+            const result = codegenProcessorFactory(mockModule)(driveHeader);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toHaveProperty("processor");
+        });
+        it("should create processor for drive with id starting with 'vetra-'", () => {
+            const driveHeader = {
+                id: "vetra-production",
+                slug: "other-slug",
+            };
+            const result = codegenProcessorFactory(mockModule)(driveHeader);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toHaveProperty("processor");
+        });
+        it("should reject drive with non-vetra slug and id", () => {
+            const driveHeader = {
+                id: "other-drive-id",
+                slug: "other-drive",
+            };
+            const result = codegenProcessorFactory(mockModule)(driveHeader);
+            expect(result).toHaveLength(0);
+        });
+        it("should reject drive with slug containing 'vetra' but not starting with it", () => {
+            const driveHeader = {
+                id: "some-id",
+                slug: "my-vetra-drive",
+            };
+            const result = codegenProcessorFactory(mockModule)(driveHeader);
+            expect(result).toHaveLength(0);
+        });
+    });
+    describe("Case-Insensitive Matching", () => {
+        it("should match slug 'VETRA' (uppercase)", () => {
+            const driveHeader = {
+                id: "some-id",
+                slug: "VETRA",
+            };
+            const result = codegenProcessorFactory(mockModule)(driveHeader);
+            expect(result).toHaveLength(1);
+        });
+        it("should match slug 'Vetra' (mixed case)", () => {
+            const driveHeader = {
+                id: "some-id",
+                slug: "Vetra",
+            };
+            const result = codegenProcessorFactory(mockModule)(driveHeader);
+            expect(result).toHaveLength(1);
+        });
+        it("should match slug 'VETRA-DEV' (uppercase with suffix)", () => {
+            const driveHeader = {
+                id: "some-id",
+                slug: "VETRA-DEV",
+            };
+            const result = codegenProcessorFactory(mockModule)(driveHeader);
+            expect(result).toHaveLength(1);
+        });
+        it("should match id 'Vetra-Production' (mixed case with suffix)", () => {
+            const driveHeader = {
+                id: "Vetra-Production",
+                slug: "other-slug",
+            };
+            const result = codegenProcessorFactory(mockModule)(driveHeader);
+            expect(result).toHaveLength(1);
+        });
+    });
+    describe("Explicit Drive ID Configuration", () => {
+        it("should match exact slug when explicit driveId is configured", () => {
+            mockModule.config?.set(VETRA_PROCESSOR_CONFIG_KEY, {
+                driveId: "my-custom-drive",
+            });
+            const driveHeader = {
+                id: "some-id",
+                slug: "my-custom-drive",
+            };
+            const result = codegenProcessorFactory(mockModule)(driveHeader);
+            expect(result).toHaveLength(1);
+        });
+        it("should match exact id when explicit driveId is configured", () => {
+            mockModule.config?.set(VETRA_PROCESSOR_CONFIG_KEY, {
+                driveId: "custom-drive-id",
+            });
+            const driveHeader = {
+                id: "custom-drive-id",
+                slug: "other-slug",
+            };
+            const result = codegenProcessorFactory(mockModule)(driveHeader);
+            expect(result).toHaveLength(1);
+        });
+        it("should reject vetra pattern when explicit driveId is configured and does not match", () => {
+            mockModule.config?.set(VETRA_PROCESSOR_CONFIG_KEY, {
+                driveId: "my-custom-drive",
+            });
+            const driveHeader = {
+                id: "vetra-dev",
+                slug: "vetra",
+            };
+            const result = codegenProcessorFactory(mockModule)(driveHeader);
+            // Should be rejected because explicit driveId requires exact match
+            expect(result).toHaveLength(0);
+        });
+        it("should reject non-matching drive when explicit driveId is configured", () => {
+            mockModule.config?.set(VETRA_PROCESSOR_CONFIG_KEY, {
+                driveId: "my-custom-drive",
+            });
+            const driveHeader = {
+                id: "other-id",
+                slug: "other-slug",
+            };
+            const result = codegenProcessorFactory(mockModule)(driveHeader);
+            expect(result).toHaveLength(0);
+        });
+    });
+    describe("ProcessorRecord Filter Configuration", () => {
+        it("should configure filter with correct branch, documentType, and scope", () => {
+            const driveHeader = {
+                id: "vetra",
+                slug: "vetra",
+            };
+            const result = codegenProcessorFactory(mockModule)(driveHeader);
+            expect(result).toHaveLength(1);
+            expect(result[0].filter).toEqual({
+                branch: ["main"],
+                documentId: ["*"],
+                documentType: [
+                    "powerhouse/document-model",
+                    "powerhouse/package",
+                    "powerhouse/document-editor",
+                    "powerhouse/subgraph",
+                    "powerhouse/processor",
+                    "powerhouse/app",
+                ],
+                scope: ["global"],
+            });
+        });
+        it("should pass interactive mode to CodegenProcessor when configured", () => {
+            mockModule.config?.set(VETRA_PROCESSOR_CONFIG_KEY, {
+                interactive: true,
+            });
+            const driveHeader = {
+                id: "vetra",
+                slug: "vetra",
+            };
+            const result = codegenProcessorFactory(mockModule)(driveHeader);
+            expect(result).toHaveLength(1);
+            // Processor is created with interactive: true (verified by mock being called)
+        });
+    });
+});

package/dist/processors/codegen/document-handlers/base-document-gen.d.ts

@@ -0,0 +1,34 @@
+import type { InternalTransmitterUpdate } from "document-drive";
+import type { Config } from "./types.js";
+/**
+ * Abstract base class for document generators
+ * Defines the interface that all document-type handlers must implement
+ */
+export declare abstract class BaseDocumentGen {
+    protected config: Config;
+    /**
+     * The document type(s) this generator supports
+     * Can be a single string or an array of strings for generators that handle multiple types
+     */
+    abstract readonly supportedDocumentTypes: string | string[];
+    constructor(config: Config);
+    /**
+     * Generate code for the given document
+     * Must be implemented by each specific document generator
+     */
+    abstract generate(strand: InternalTransmitterUpdate): Promise<void>;
+    /**
+     * Check if this generator supports the given document type
+     */
+    supportsDocumentType(documentType: string): boolean;
+    /**
+     * Get all supported document types as an array
+     */
+    getSupportedDocumentTypes(): string[];
+    /**
+     * Validate if this strand should be processed
+     * Override this method in specific generators to add custom validation logic
+     */
+    shouldProcess(strand: InternalTransmitterUpdate): boolean;
+}
+//# sourceMappingURL=base-document-gen.d.ts.map

package/dist/processors/codegen/document-handlers/base-document-gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-document-gen.d.ts","sourceRoot":"","sources":["../../../../processors/codegen/document-handlers/base-document-gen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC;;;GAGG;AACH,8BAAsB,eAAe;IAOvB,SAAS,CAAC,MAAM,EAAE,MAAM;IANpC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,sBAAsB,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;gBAEtC,MAAM,EAAE,MAAM;IAEpC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;IAEnE;;OAEG;IACH,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAOnD;;OAEG;IACH,yBAAyB,IAAI,MAAM,EAAE;IAOrC;;;OAGG;IACH,aAAa,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO;CAc1D"}

package/dist/processors/codegen/document-handlers/base-document-gen.js

@@ -0,0 +1,44 @@
+/**
+ * Abstract base class for document generators
+ * Defines the interface that all document-type handlers must implement
+ */
+export class BaseDocumentGen {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * 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) {
+        // Basic validation: ensure strand has required properties
+        if (!strand.documentId || !strand.documentType) {
+            return false;
+        }
+        // Basic validation: check if document type is supported
+        if (!this.supportsDocumentType(strand.documentType)) {
+            return false;
+        }
+        // Default to processing if basic validation passes
+        return true;
+    }
+}

package/dist/processors/codegen/document-handlers/document-codegen-factory.d.ts

@@ -0,0 +1,29 @@
+import { DocumentCodegenManager } from "./document-codegen-manager.js";
+import { AppGenerator, DocumentEditorGenerator, DocumentModelGenerator, PackageGenerator, ProcessorGenerator, SubgraphGenerator } from "./generators/index.js";
+import type { Config } from "./types.js";
+/**
+ * Factory class for creating and configuring DocumentCodegenManager instances
+ * with all the standard generators pre-registered
+ */
+export declare class DocumentCodegenFactory {
+    /**
+     * Create a DocumentCodegenManager with all standard generators registered
+     */
+    static createManager(config: Config, interactiveMode?: boolean): DocumentCodegenManager;
+    /**
+     * Create a DocumentCodegenManager with only specific generators
+     */
+    static createManagerWithGenerators(config: Config, generators: Array<new (config: Config) => any>, interactiveMode?: boolean): DocumentCodegenManager;
+    /**
+     * Get all available generator classes
+     */
+    static getAvailableGenerators(): {
+        DocumentModelGenerator: typeof DocumentModelGenerator;
+        PackageGenerator: typeof PackageGenerator;
+        AppGenerator: typeof AppGenerator;
+        DocumentEditorGenerator: typeof DocumentEditorGenerator;
+        SubgraphGenerator: typeof SubgraphGenerator;
+        ProcessorGenerator: typeof ProcessorGenerator;
+    };
+}
+//# sourceMappingURL=document-codegen-factory.d.ts.map

package/dist/processors/codegen/document-handlers/document-codegen-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-codegen-factory.d.ts","sourceRoot":"","sources":["../../../../processors/codegen/document-handlers/document-codegen-factory.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EACL,YAAY,EACZ,uBAAuB,EACvB,sBAAsB,EACtB,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC;;;GAGG;AACH,qBAAa,sBAAsB;IACjC;;OAEG;IACH,MAAM,CAAC,aAAa,CAClB,MAAM,EAAE,MAAM,EACd,eAAe,GAAE,OAAe,GAC/B,sBAAsB;IAoBzB;;OAEG;IACH,MAAM,CAAC,2BAA2B,CAChC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,KAAK,CAAC,KAAK,MAAM,EAAE,MAAM,KAAK,GAAG,CAAC,EAC9C,eAAe,GAAE,OAAe,GAC/B,sBAAsB;IAezB;;OAEG;IACH,MAAM,CAAC,sBAAsB;;;;;;;;CAU9B"}

package/dist/processors/codegen/document-handlers/document-codegen-factory.js

@@ -0,0 +1,49 @@
+import { DocumentCodegenManager } from "./document-codegen-manager.js";
+import { AppGenerator, DocumentEditorGenerator, DocumentModelGenerator, PackageGenerator, ProcessorGenerator, SubgraphGenerator, } from "./generators/index.js";
+/**
+ * Factory class for creating and configuring DocumentCodegenManager instances
+ * with all the standard generators pre-registered
+ */
+export class DocumentCodegenFactory {
+    /**
+     * Create a DocumentCodegenManager with all standard generators registered
+     */
+    static createManager(config, interactiveMode = false) {
+        const manager = new DocumentCodegenManager(config, interactiveMode);
+        // Register all the standard generators
+        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, interactiveMode = false) {
+        const manager = new DocumentCodegenManager(config, interactiveMode);
+        for (const generatorClass of generators) {
+            const generator = new generatorClass(config);
+            const supportedTypes = generator.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,
+        };
+    }
+}

package/dist/processors/codegen/document-handlers/document-codegen-manager.d.ts

@@ -0,0 +1,73 @@
+import type { InternalTransmitterUpdate } from "document-drive";
+import type { BaseDocumentGen } from "./base-document-gen.js";
+import type { Config } from "./types.js";
+/**
+ * Manager class responsible for routing documents to the correct generator
+ * and managing generator registration and instantiation
+ */
+export declare class DocumentCodegenManager {
+    private config;
+    private generators;
+    private debounceTimers;
+    private processingQueue;
+    private interactiveManager;
+    constructor(config: Config, interactiveMode?: boolean);
+    /**
+     * Register a generator class for a specific document type
+     */
+    registerGenerator(documentType: string, generatorClass: new (config: Config) => BaseDocumentGen): void;
+    /**
+     * Register a generator class that supports multiple document types
+     */
+    registerMultiTypeGenerator(generatorClass: new (config: Config) => BaseDocumentGen): void;
+    /**
+     * Get a generator instance for the given document type
+     * Public method to allow external access for validation
+     */
+    getGenerator(documentType: string): BaseDocumentGen | undefined;
+    /**
+     * Get all registered document types
+     */
+    getRegisteredDocumentTypes(): string[];
+    /**
+     * Check if a document type is supported
+     */
+    isDocumentTypeSupported(documentType: string): boolean;
+    /**
+     * Route a document to the appropriate generator and handle the generation
+     * Handles both interactive and non-interactive modes with queue-based processing
+     */
+    routeAndGenerate(strand: InternalTransmitterUpdate): Promise<void>;
+    /**
+     * Process multiple strands in priority order (document-model types first)
+     */
+    private processQueuedStrands;
+    /**
+     * Process a single strand (used internally by processQueuedStrands)
+     */
+    private processStrand;
+    /**
+     * Clear all registered generators
+     */
+    clearGenerators(): void;
+    /**
+     * Get statistics about registered generators
+     */
+    getStats(): {
+        totalGenerators: number;
+        supportedTypes: string[];
+    };
+    /**
+     * Set interactive mode for code generation
+     */
+    setInteractiveMode(enabled: boolean): void;
+    /**
+     * Check if interactive mode is enabled
+     */
+    isInteractiveMode(): boolean;
+    /**
+     * Check if the manager is currently processing an interactive confirmation
+     */
+    isProcessingInteractive(): boolean;
+}
+//# sourceMappingURL=document-codegen-manager.d.ts.map

package/dist/processors/codegen/document-handlers/document-codegen-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-codegen-manager.d.ts","sourceRoot":"","sources":["../../../../processors/codegen/document-handlers/document-codegen-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAIhE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAIzC;;;GAGG;AACH,qBAAa,sBAAsB;IAO/B,OAAO,CAAC,MAAM;IANhB,OAAO,CAAC,UAAU,CAAsC;IACxD,OAAO,CAAC,cAAc,CAAqC;IAC3D,OAAO,CAAC,eAAe,CAAoC;IAC3D,OAAO,CAAC,kBAAkB,CAAqB;gBAGrC,MAAM,EAAE,MAAM,EACtB,eAAe,UAAQ;IAKzB;;OAEG;IACH,iBAAiB,CACf,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,KAAK,MAAM,EAAE,MAAM,KAAK,eAAe,GACtD,IAAI;IAWP;;OAEG;IACH,0BAA0B,CACxB,cAAc,EAAE,KAAK,MAAM,EAAE,MAAM,KAAK,eAAe,GACtD,IAAI;IAkBP;;;OAGG;IACI,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAItE;;OAEG;IACH,0BAA0B,IAAI,MAAM,EAAE;IAItC;;OAEG;IACH,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAItD;;;OAGG;IACG,gBAAgB,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;IAsGxE;;OAEG;YACW,oBAAoB;IA8BlC;;OAEG;YACW,aAAa;IA0B3B;;OAEG;IACH,eAAe,IAAI,IAAI;IAKvB;;OAEG;IACH,QAAQ,IAAI;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,EAAE,CAAA;KAAE;IAOjE;;OAEG;IACH,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAI1C;;OAEG;IACH,iBAAiB,IAAI,OAAO;IAI5B;;OAEG;IACH,uBAAuB,IAAI,OAAO;CAGnC"}

package/dist/processors/codegen/document-handlers/document-codegen-manager.js

@@ -0,0 +1,215 @@
+import { InteractiveManager } from "../interactive-manager.js";
+import { logger } from "../logger.js";
+const DEFAULT_DEBOUNCE_TIME = 1000; // 1 second
+/**
+ * Manager class responsible for routing documents to the correct generator
+ * and managing generator registration and instantiation
+ */
+export class DocumentCodegenManager {
+    config;
+    generators = new Map();
+    debounceTimers = new Map();
+    processingQueue = Promise.resolve();
+    interactiveManager;
+    constructor(config, interactiveMode = false) {
+        this.config = config;
+        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));
+        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);
+        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}`);
+        }
+        // Validate if this strand should be processed
+        if (!generator.shouldProcess(strand)) {
+            logger.debug(`>>> Generator validation failed for ${documentType}:${strand.documentId}, skipping processing`);
+            return;
+        }
+        // Different flow for interactive vs non-interactive mode
+        if (this.interactiveManager.isInteractive()) {
+            // Interactive mode: queue strands and use debounce timer to trigger batch processing
+            logger.debug(`>>> Queueing strand for interactive processing: ${documentType}:${strand.documentId}`);
+            // Add strand to queue (will replace any existing strand for same document)
+            this.interactiveManager.queueStrand(strand);
+            // Clear any existing debounce timer for interactive processing
+            const existingTimer = this.debounceTimers.get("interactive");
+            if (existingTimer) {
+                clearTimeout(existingTimer);
+            }
+            // Set up debounce timer for batch interactive processing
+            // eslint-disable-next-line @typescript-eslint/no-misused-promises
+            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 {
+                    // Clean up the timer reference
+                    this.debounceTimers.delete("interactive");
+                }
+            }, DEFAULT_DEBOUNCE_TIME);
+            // Store the timer reference using 'interactive' key
+            this.debounceTimers.set("interactive", debounceTimer);
+        }
+        else {
+            // Non-interactive mode: use debouncing per document instance
+            // Create unique key for this specific document instance
+            const timerKey = `${documentType}:${strand.documentId}`;
+            // Clear any existing debounce timer for this document instance
+            const existingTimer = this.debounceTimers.get(timerKey);
+            if (existingTimer) {
+                clearTimeout(existingTimer);
+            }
+            // Set up new debounced generation (no interactive confirmation)
+            // eslint-disable-next-line @typescript-eslint/no-misused-promises
+            const debounceTimer = setTimeout(async () => {
+                try {
+                    logger.debug(`🔄 Routing document type "${documentType}" to generator (debounced)`);
+                    // Direct generation, no interactive confirmation
+                    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);
+                    // Don't throw - let codegen continue with other documents
+                }
+                finally {
+                    // Clean up the timer reference
+                    this.debounceTimers.delete(documentType);
+                }
+            }, DEFAULT_DEBOUNCE_TIME);
+            // Store the timer reference
+            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)`);
+        // Sort by priority (document-model first to ensure dependencies exist)
+        const documentModelStrands = queuedStrands.filter((qs) => qs.strand.documentType === "powerhouse/document-model");
+        const otherStrands = queuedStrands.filter((qs) => qs.strand.documentType !== "powerhouse/document-model");
+        // Process document models first
+        for (const queuedStrand of documentModelStrands) {
+            await this.processStrand(queuedStrand.strand);
+        }
+        // Then process other document types
+        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);
+            // Don't throw here to allow other strands to be processed
+        }
+    }
+    /**
+     * 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();
+    }
+}

package/dist/processors/codegen/document-handlers/generators/app-generator.d.ts

@@ -0,0 +1,14 @@
+import type { InternalTransmitterUpdate } from "document-drive";
+import { BaseDocumentGen } from "../base-document-gen.js";
+/**
+ * Generator for app documents
+ */
+export declare class AppGenerator extends BaseDocumentGen {
+    readonly supportedDocumentTypes = "powerhouse/app";
+    /**
+     * Validate if this app strand should be processed
+     */
+    shouldProcess(strand: InternalTransmitterUpdate): boolean;
+    generate(strand: InternalTransmitterUpdate): Promise<void>;
+}
+//# sourceMappingURL=app-generator.d.ts.map

package/dist/processors/codegen/document-handlers/generators/app-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-generator.d.ts","sourceRoot":"","sources":["../../../../../processors/codegen/document-handlers/generators/app-generator.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAEhE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D;;GAEG;AACH,qBAAa,YAAa,SAAQ,eAAe;IAC/C,QAAQ,CAAC,sBAAsB,oBAAoB;IAEnD;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO;IA4BnD,QAAQ,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;CA0EjE"}