@kapeta/local-cluster-service 0.50.0 → 0.51.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [0.51.0](https://github.com/kapetacom/local-cluster-service/compare/v0.50.0...v0.51.0) (2024-06-05)
+
+
+### Features
+
+* Handle file streaming events ([#164](https://github.com/kapetacom/local-cluster-service/issues/164)) ([441847a](https://github.com/kapetacom/local-cluster-service/commit/441847a12d20826d843e62627ea9bf584043effb))
+
 # [0.50.0](https://github.com/kapetacom/local-cluster-service/compare/v0.49.0...v0.50.0) (2024-06-05)
 
 

package/dist/cjs/src/storm/codegen.d.ts

@@ -18,7 +18,8 @@ export declare class StormCodegen {
     getStream(): StormStream;
     private handleTemplateFileOutput;
     private handleUiOutput;
-    private handleFileOutput;
+    private handleFileEvents;
+    private handleFileDoneOutput;
     private getBasePath;
     /**
      * Generates the code for a block and sends it to the AI
@@ -34,7 +35,7 @@ export declare class StormCodegen {
     /**
      * Emits the text-based files to the stream
      */
-    private emitFiles;
+    private emitStaticFiles;
     private emitFile;
     /**
      * Sends the template to the AI and processes the response

package/dist/cjs/src/storm/codegen.js

@@ -42,6 +42,49 @@ const path_1 = __importStar(require("path"));
 const node_os_1 = __importDefault(require("node:os"));
 const fs_1 = require("fs");
 const path_2 = __importDefault(require("path"));
+const SIMULATED_DELAY = 1000;
+class SimulatedFileDelay {
+    file;
+    stream;
+    constructor(file, stream) {
+        this.file = file;
+        this.stream = stream;
+    }
+    async start() {
+        const commonPayload = {
+            filename: this.file.payload.filename,
+            path: this.file.payload.path,
+            blockName: this.file.payload.blockName,
+            blockRef: this.file.payload.blockRef,
+            instanceId: this.file.payload.instanceId,
+        };
+        this.stream.emit('data', {
+            type: 'FILE_START',
+            created: Date.now(),
+            reason: 'File start',
+            payload: commonPayload,
+        });
+        const lines = this.file.payload.content.split('\n');
+        const delayPerLine = SIMULATED_DELAY / lines.length;
+        for (const line of lines) {
+            await new Promise((resolve) => {
+                setTimeout(() => {
+                    this.stream.emit('data', {
+                        type: 'FILE_CHUNK',
+                        created: Date.now(),
+                        reason: 'File chunk',
+                        payload: {
+                            ...commonPayload,
+                            content: line,
+                        },
+                    });
+                    resolve();
+                }, delayPerLine);
+            });
+        }
+        this.stream.emit('data', this.file);
+    }
+}
 class StormCodegen {
     userPrompt;
     blocks;
@@ -70,42 +113,132 @@ class StormCodegen {
         return this.out;
     }
     handleTemplateFileOutput(blockUri, aiName, template, data) {
+        if (this.handleFileEvents(blockUri, aiName, data)) {
+            return;
+        }
         switch (data.type) {
-            case 'FILE':
+            case 'FILE_DONE':
                 template.filename = data.payload.filename;
                 template.content = data.payload.content;
-                return this.handleFileOutput(blockUri, aiName, data);
+                this.handleFileDoneOutput(blockUri, aiName, data);
+                break;
         }
     }
-    handleUiOutput(blockUri, aiName, data) {
+    handleUiOutput(blockUri, blockName, data) {
+        const blockRef = blockUri.toNormalizedString();
+        const instanceId = event_parser_1.StormEventParser.toInstanceIdFromRef(blockRef);
+        if (this.handleFileEvents(blockUri, blockName, data)) {
+            return;
+        }
         switch (data.type) {
             case 'SCREEN':
-                const ref = blockUri.toNormalizedString();
                 this.out.emit('data', {
                     type: 'SCREEN',
                     reason: data.reason,
                     created: Date.now(),
                     payload: {
                         ...data.payload,
-                        blockName: aiName,
-                        blockRef: ref,
-                        instanceId: event_parser_1.StormEventParser.toInstanceIdFromRef(ref),
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                break;
+            case 'FILE_START':
+            case 'FILE_CHUNK_RESET':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        blockName,
+                        blockRef,
+                        instanceId,
                     },
                 });
-            case 'FILE':
-                return this.handleFileOutput(blockUri, aiName, data);
+                break;
+            case 'FILE_CHUNK':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                break;
+            case 'FILE_STATE':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                break;
+            case 'FILE_DONE':
+                this.handleFileDoneOutput(blockUri, blockName, data);
+                break;
         }
     }
-    handleFileOutput(blockUri, aiName, data) {
+    handleFileEvents(blockUri, blockName, data) {
+        const blockRef = blockUri.toNormalizedString();
+        const instanceId = event_parser_1.StormEventParser.toInstanceIdFromRef(blockRef);
+        const basePath = this.getBasePath(blockUri.fullName);
         switch (data.type) {
-            case 'FILE':
+            case 'FILE_START':
+            case 'FILE_CHUNK_RESET':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        path: (0, path_1.join)(basePath, data.payload.filename),
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                return true;
+            case 'FILE_CHUNK':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        path: (0, path_1.join)(basePath, data.payload.filename),
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                return true;
+            case 'FILE_STATE':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        path: (0, path_1.join)(basePath, data.payload.filename),
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                return true;
+        }
+        return false;
+    }
+    handleFileDoneOutput(blockUri, aiName, data) {
+        switch (data.type) {
+            case 'FILE_DONE':
                 const ref = blockUri.toNormalizedString();
                 this.emitFile(blockUri, aiName, data.payload.filename, data.payload.content, data.reason);
                 return {
-                    type: 'FILE',
+                    type: 'FILE_DONE',
                     created: Date.now(),
                     payload: {
                         filename: data.payload.filename,
+                        path: (0, path_1.join)(this.getBasePath(blockUri.fullName), data.payload.filename),
                         content: data.payload.content,
                         blockRef: ref,
                         instanceId: event_parser_1.StormEventParser.toInstanceIdFromRef(ref),
@@ -130,7 +263,7 @@ class StormCodegen {
         }
         const allFiles = this.toStormFiles(generatedResult);
         // Send all the non-ai files to the stream
-        this.emitFiles((0, nodejs_utils_1.parseKapetaUri)(block.uri), block.aiName, allFiles);
+        await this.emitStaticFiles((0, nodejs_utils_1.parseKapetaUri)(block.uri), block.aiName, allFiles);
         if (this.isAborted()) {
             return;
         }
@@ -285,8 +418,8 @@ class StormCodegen {
     /**
      * Emits the text-based files to the stream
      */
-    emitFiles(uri, aiName, files) {
-        files.forEach((file) => {
+    async emitStaticFiles(uri, aiName, files) {
+        const promises = files.map((file) => {
             if (!file.content || typeof file.content !== 'string') {
                 return;
             }
@@ -300,14 +433,30 @@ class StormCodegen {
                 // They will need to be implemented by the AI
                 return;
             }
-            this.emitFile(uri, aiName, file.filename, file.content);
+            const basePath = this.getBasePath(uri.fullName);
+            const ref = uri.toNormalizedString();
+            const fileEvent = {
+                type: 'FILE_DONE',
+                reason: 'File generated',
+                created: Date.now(),
+                payload: {
+                    filename: file.filename,
+                    path: (0, path_1.join)(basePath, file.filename),
+                    content: file.content,
+                    blockName: aiName,
+                    blockRef: ref,
+                    instanceId: event_parser_1.StormEventParser.toInstanceIdFromRef(ref),
+                },
+            };
+            return new SimulatedFileDelay(fileEvent, this.out).start();
         });
+        return Promise.all(promises);
     }
     emitFile(uri, blockName, filename, content, reason = 'File generated') {
         const basePath = this.getBasePath(uri.fullName);
         const ref = uri.toNormalizedString();
         this.out.emit('data', {
-            type: 'FILE',
+            type: 'FILE_DONE',
             reason,
             created: Date.now(),
             payload: {
@@ -330,21 +479,15 @@ class StormCodegen {
                 template: templateFile,
                 prompt: this.userPrompt,
             });
-            const files = [];
             this.out.on('aborted', () => {
                 stream.abort();
             });
             stream.on('data', (evt) => {
-                const file = this.handleTemplateFileOutput(blockUri, aiName, templateFile, evt);
-                if (file) {
-                    files.push(file);
-                }
+                this.handleTemplateFileOutput(blockUri, aiName, templateFile, evt);
             });
             await stream.waitForDone();
-            return files;
         });
-        const fileChunks = await Promise.all(promises);
-        return fileChunks.flat();
+        await Promise.all(promises);
     }
     /**
      * Converts the generated files to a format that can be sent to the AI

package/dist/cjs/src/storm/event-parser.js

@@ -211,10 +211,6 @@ class StormEventParser {
                 evt.payload.toBlockId = StormEventParser.toInstanceId(handle, evt.payload.toComponent);
                 this.connections.push(evt.payload);
                 break;
-            default:
-            case 'SCREEN_CANDIDATE':
-            case 'FILE':
-                break;
         }
         return this.toResult(handle);
     }

package/dist/cjs/src/storm/events.d.ts

@@ -150,19 +150,35 @@ export interface StormEventScreenCandidate {
         url: string;
     };
 }
-export interface StormEventFile {
-    type: 'FILE';
+export interface StormEventFileBasePayload {
+    filename: string;
+    path: string;
+    blockName: string;
+    blockRef: string;
+    instanceId: string;
+}
+export interface StormEventFileBase {
+    type: string;
     reason: string;
     created: number;
-    payload: {
-        filename: string;
-        path: string;
+    payload: StormEventFileBasePayload;
+}
+export interface StormEventFileLogical extends StormEventFileBase {
+    type: 'FILE_START' | 'FILE_CHUNK_RESET';
+}
+export interface StormEventFileState extends StormEventFileBase {
+    type: 'FILE_STATE';
+    payload: StormEventFileBasePayload & {
+        state: string;
+    };
+}
+export interface StormEventFileContent extends StormEventFileBase {
+    type: 'FILE_DONE' | 'FILE_CHUNK';
+    payload: StormEventFileBasePayload & {
         content: string;
-        blockName: string;
-        blockRef: string;
-        instanceId: string;
     };
 }
+export type StormEventFile = StormEventFileLogical | StormEventFileState | StormEventFileContent;
 export interface StormEventBlockReady {
     type: 'BLOCK_READY';
     reason: string;
@@ -196,4 +212,4 @@ export interface StormEventPhases {
         phaseType: StormEventPhaseType;
     };
 }
-export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventCreateDSLResource | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFile | StormEventDone | StormEventDefinitionChange | StormEventErrorClassifier | StormEventCodeFix | StormEventBlockReady | StormEventPhases;
+export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventCreateDSLResource | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFileLogical | StormEventFileState | StormEventFileContent | StormEventDone | StormEventDefinitionChange | StormEventErrorClassifier | StormEventCodeFix | StormEventBlockReady | StormEventPhases;

package/dist/esm/src/storm/codegen.d.ts

@@ -18,7 +18,8 @@ export declare class StormCodegen {
     getStream(): StormStream;
     private handleTemplateFileOutput;
     private handleUiOutput;
-    private handleFileOutput;
+    private handleFileEvents;
+    private handleFileDoneOutput;
     private getBasePath;
     /**
      * Generates the code for a block and sends it to the AI
@@ -34,7 +35,7 @@ export declare class StormCodegen {
     /**
      * Emits the text-based files to the stream
      */
-    private emitFiles;
+    private emitStaticFiles;
     private emitFile;
     /**
      * Sends the template to the AI and processes the response

package/dist/esm/src/storm/codegen.js

@@ -42,6 +42,49 @@ const path_1 = __importStar(require("path"));
 const node_os_1 = __importDefault(require("node:os"));
 const fs_1 = require("fs");
 const path_2 = __importDefault(require("path"));
+const SIMULATED_DELAY = 1000;
+class SimulatedFileDelay {
+    file;
+    stream;
+    constructor(file, stream) {
+        this.file = file;
+        this.stream = stream;
+    }
+    async start() {
+        const commonPayload = {
+            filename: this.file.payload.filename,
+            path: this.file.payload.path,
+            blockName: this.file.payload.blockName,
+            blockRef: this.file.payload.blockRef,
+            instanceId: this.file.payload.instanceId,
+        };
+        this.stream.emit('data', {
+            type: 'FILE_START',
+            created: Date.now(),
+            reason: 'File start',
+            payload: commonPayload,
+        });
+        const lines = this.file.payload.content.split('\n');
+        const delayPerLine = SIMULATED_DELAY / lines.length;
+        for (const line of lines) {
+            await new Promise((resolve) => {
+                setTimeout(() => {
+                    this.stream.emit('data', {
+                        type: 'FILE_CHUNK',
+                        created: Date.now(),
+                        reason: 'File chunk',
+                        payload: {
+                            ...commonPayload,
+                            content: line,
+                        },
+                    });
+                    resolve();
+                }, delayPerLine);
+            });
+        }
+        this.stream.emit('data', this.file);
+    }
+}
 class StormCodegen {
     userPrompt;
     blocks;
@@ -70,42 +113,132 @@ class StormCodegen {
         return this.out;
     }
     handleTemplateFileOutput(blockUri, aiName, template, data) {
+        if (this.handleFileEvents(blockUri, aiName, data)) {
+            return;
+        }
         switch (data.type) {
-            case 'FILE':
+            case 'FILE_DONE':
                 template.filename = data.payload.filename;
                 template.content = data.payload.content;
-                return this.handleFileOutput(blockUri, aiName, data);
+                this.handleFileDoneOutput(blockUri, aiName, data);
+                break;
         }
     }
-    handleUiOutput(blockUri, aiName, data) {
+    handleUiOutput(blockUri, blockName, data) {
+        const blockRef = blockUri.toNormalizedString();
+        const instanceId = event_parser_1.StormEventParser.toInstanceIdFromRef(blockRef);
+        if (this.handleFileEvents(blockUri, blockName, data)) {
+            return;
+        }
         switch (data.type) {
             case 'SCREEN':
-                const ref = blockUri.toNormalizedString();
                 this.out.emit('data', {
                     type: 'SCREEN',
                     reason: data.reason,
                     created: Date.now(),
                     payload: {
                         ...data.payload,
-                        blockName: aiName,
-                        blockRef: ref,
-                        instanceId: event_parser_1.StormEventParser.toInstanceIdFromRef(ref),
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                break;
+            case 'FILE_START':
+            case 'FILE_CHUNK_RESET':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        blockName,
+                        blockRef,
+                        instanceId,
                     },
                 });
-            case 'FILE':
-                return this.handleFileOutput(blockUri, aiName, data);
+                break;
+            case 'FILE_CHUNK':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                break;
+            case 'FILE_STATE':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                break;
+            case 'FILE_DONE':
+                this.handleFileDoneOutput(blockUri, blockName, data);
+                break;
         }
     }
-    handleFileOutput(blockUri, aiName, data) {
+    handleFileEvents(blockUri, blockName, data) {
+        const blockRef = blockUri.toNormalizedString();
+        const instanceId = event_parser_1.StormEventParser.toInstanceIdFromRef(blockRef);
+        const basePath = this.getBasePath(blockUri.fullName);
         switch (data.type) {
-            case 'FILE':
+            case 'FILE_START':
+            case 'FILE_CHUNK_RESET':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        path: (0, path_1.join)(basePath, data.payload.filename),
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                return true;
+            case 'FILE_CHUNK':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        path: (0, path_1.join)(basePath, data.payload.filename),
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                return true;
+            case 'FILE_STATE':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        path: (0, path_1.join)(basePath, data.payload.filename),
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                return true;
+        }
+        return false;
+    }
+    handleFileDoneOutput(blockUri, aiName, data) {
+        switch (data.type) {
+            case 'FILE_DONE':
                 const ref = blockUri.toNormalizedString();
                 this.emitFile(blockUri, aiName, data.payload.filename, data.payload.content, data.reason);
                 return {
-                    type: 'FILE',
+                    type: 'FILE_DONE',
                     created: Date.now(),
                     payload: {
                         filename: data.payload.filename,
+                        path: (0, path_1.join)(this.getBasePath(blockUri.fullName), data.payload.filename),
                         content: data.payload.content,
                         blockRef: ref,
                         instanceId: event_parser_1.StormEventParser.toInstanceIdFromRef(ref),
@@ -130,7 +263,7 @@ class StormCodegen {
         }
         const allFiles = this.toStormFiles(generatedResult);
         // Send all the non-ai files to the stream
-        this.emitFiles((0, nodejs_utils_1.parseKapetaUri)(block.uri), block.aiName, allFiles);
+        await this.emitStaticFiles((0, nodejs_utils_1.parseKapetaUri)(block.uri), block.aiName, allFiles);
         if (this.isAborted()) {
             return;
         }
@@ -285,8 +418,8 @@ class StormCodegen {
     /**
      * Emits the text-based files to the stream
      */
-    emitFiles(uri, aiName, files) {
-        files.forEach((file) => {
+    async emitStaticFiles(uri, aiName, files) {
+        const promises = files.map((file) => {
             if (!file.content || typeof file.content !== 'string') {
                 return;
             }
@@ -300,14 +433,30 @@ class StormCodegen {
                 // They will need to be implemented by the AI
                 return;
             }
-            this.emitFile(uri, aiName, file.filename, file.content);
+            const basePath = this.getBasePath(uri.fullName);
+            const ref = uri.toNormalizedString();
+            const fileEvent = {
+                type: 'FILE_DONE',
+                reason: 'File generated',
+                created: Date.now(),
+                payload: {
+                    filename: file.filename,
+                    path: (0, path_1.join)(basePath, file.filename),
+                    content: file.content,
+                    blockName: aiName,
+                    blockRef: ref,
+                    instanceId: event_parser_1.StormEventParser.toInstanceIdFromRef(ref),
+                },
+            };
+            return new SimulatedFileDelay(fileEvent, this.out).start();
         });
+        return Promise.all(promises);
     }
     emitFile(uri, blockName, filename, content, reason = 'File generated') {
         const basePath = this.getBasePath(uri.fullName);
         const ref = uri.toNormalizedString();
         this.out.emit('data', {
-            type: 'FILE',
+            type: 'FILE_DONE',
             reason,
             created: Date.now(),
             payload: {
@@ -330,21 +479,15 @@ class StormCodegen {
                 template: templateFile,
                 prompt: this.userPrompt,
             });
-            const files = [];
             this.out.on('aborted', () => {
                 stream.abort();
             });
             stream.on('data', (evt) => {
-                const file = this.handleTemplateFileOutput(blockUri, aiName, templateFile, evt);
-                if (file) {
-                    files.push(file);
-                }
+                this.handleTemplateFileOutput(blockUri, aiName, templateFile, evt);
             });
             await stream.waitForDone();
-            return files;
         });
-        const fileChunks = await Promise.all(promises);
-        return fileChunks.flat();
+        await Promise.all(promises);
     }
     /**
      * Converts the generated files to a format that can be sent to the AI

package/dist/esm/src/storm/event-parser.js

@@ -211,10 +211,6 @@ class StormEventParser {
                 evt.payload.toBlockId = StormEventParser.toInstanceId(handle, evt.payload.toComponent);
                 this.connections.push(evt.payload);
                 break;
-            default:
-            case 'SCREEN_CANDIDATE':
-            case 'FILE':
-                break;
         }
         return this.toResult(handle);
     }

package/dist/esm/src/storm/events.d.ts

@@ -150,19 +150,35 @@ export interface StormEventScreenCandidate {
         url: string;
     };
 }
-export interface StormEventFile {
-    type: 'FILE';
+export interface StormEventFileBasePayload {
+    filename: string;
+    path: string;
+    blockName: string;
+    blockRef: string;
+    instanceId: string;
+}
+export interface StormEventFileBase {
+    type: string;
     reason: string;
     created: number;
-    payload: {
-        filename: string;
-        path: string;
+    payload: StormEventFileBasePayload;
+}
+export interface StormEventFileLogical extends StormEventFileBase {
+    type: 'FILE_START' | 'FILE_CHUNK_RESET';
+}
+export interface StormEventFileState extends StormEventFileBase {
+    type: 'FILE_STATE';
+    payload: StormEventFileBasePayload & {
+        state: string;
+    };
+}
+export interface StormEventFileContent extends StormEventFileBase {
+    type: 'FILE_DONE' | 'FILE_CHUNK';
+    payload: StormEventFileBasePayload & {
         content: string;
-        blockName: string;
-        blockRef: string;
-        instanceId: string;
     };
 }
+export type StormEventFile = StormEventFileLogical | StormEventFileState | StormEventFileContent;
 export interface StormEventBlockReady {
     type: 'BLOCK_READY';
     reason: string;
@@ -196,4 +212,4 @@ export interface StormEventPhases {
         phaseType: StormEventPhaseType;
     };
 }
-export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventCreateDSLResource | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFile | StormEventDone | StormEventDefinitionChange | StormEventErrorClassifier | StormEventCodeFix | StormEventBlockReady | StormEventPhases;
+export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventCreateDSLResource | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFileLogical | StormEventFileState | StormEventFileContent | StormEventDone | StormEventDefinitionChange | StormEventErrorClassifier | StormEventCodeFix | StormEventBlockReady | StormEventPhases;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.50.0",
+    "version": "0.51.0",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {

package/src/storm/codegen.ts

@@ -15,7 +15,7 @@ import {
 import { BlockDefinition } from '@kapeta/schemas';
 import { codeGeneratorManager } from '../codeGeneratorManager';
 import { STORM_ID, stormClient } from './stormClient';
-import { StormEvent, StormEventFile } from './events';
+import { StormEvent, StormEventFileContent, StormEventFileLogical } from './events';
 import { BlockDefinitionInfo, StormEventParser } from './event-parser';
 import { StormFileImplementationPrompt, StormFileInfo, StormStream } from './stream';
 import { KapetaURI, parseKapetaUri } from '@kapeta/nodejs-utils';
@@ -27,6 +27,54 @@ import Path from 'path';
 
 type ImplementationGenerator = (prompt: StormFileImplementationPrompt, conversationId?: string) => Promise<StormStream>;
 
+const SIMULATED_DELAY = 1000;
+
+class SimulatedFileDelay {
+    private readonly file: StormEventFileContent;
+    public readonly stream;
+    constructor(file: StormEventFileContent, stream: StormStream) {
+        this.file = file;
+        this.stream = stream;
+    }
+
+    public async start() {
+        const commonPayload = {
+            filename: this.file.payload.filename,
+            path: this.file.payload.path,
+            blockName: this.file.payload.blockName,
+            blockRef: this.file.payload.blockRef,
+            instanceId: this.file.payload.instanceId,
+        };
+        this.stream.emit('data', {
+            type: 'FILE_START',
+            created: Date.now(),
+            reason: 'File start',
+            payload: commonPayload,
+        } satisfies StormEventFileLogical);
+
+        const lines = this.file.payload.content.split('\n');
+        const delayPerLine = SIMULATED_DELAY / lines.length;
+        for (const line of lines) {
+            await new Promise<void>((resolve) => {
+                setTimeout(() => {
+                    this.stream.emit('data', {
+                        type: 'FILE_CHUNK',
+                        created: Date.now(),
+                        reason: 'File chunk',
+                        payload: {
+                            ...commonPayload,
+                            content: line,
+                        },
+                    } satisfies StormEventFileContent);
+                    resolve();
+                }, delayPerLine);
+            });
+        }
+
+        this.stream.emit('data', this.file);
+    }
+}
+
 export class StormCodegen {
     private readonly userPrompt: string;
     private readonly blocks: BlockDefinitionInfo[];
@@ -59,50 +107,150 @@ export class StormCodegen {
         return this.out;
     }
 
-    private handleTemplateFileOutput(blockUri: KapetaURI, aiName: string, template: StormFileInfo, data: StormEvent) {
+    private handleTemplateFileOutput(
+        blockUri: KapetaURI,
+        aiName: string,
+        template: StormFileInfo,
+        data: StormEvent
+    ): void {
+        if (this.handleFileEvents(blockUri, aiName, data)) {
+            return;
+        }
+
         switch (data.type) {
-            case 'FILE':
+            case 'FILE_DONE':
                 template.filename = data.payload.filename;
                 template.content = data.payload.content;
-                return this.handleFileOutput(blockUri, aiName, data);
+                this.handleFileDoneOutput(blockUri, aiName, data);
+                break;
         }
     }
 
-    private handleUiOutput(blockUri: KapetaURI, aiName: string, data: StormEvent) {
+    private handleUiOutput(blockUri: KapetaURI, blockName: string, data: StormEvent) {
+        const blockRef = blockUri.toNormalizedString();
+        const instanceId = StormEventParser.toInstanceIdFromRef(blockRef);
+
+        if (this.handleFileEvents(blockUri, blockName, data)) {
+            return;
+        }
+
         switch (data.type) {
             case 'SCREEN':
-                const ref = blockUri.toNormalizedString();
                 this.out.emit('data', {
                     type: 'SCREEN',
                     reason: data.reason,
                     created: Date.now(),
                     payload: {
                         ...data.payload,
-                        blockName: aiName,
-                        blockRef: ref,
-                        instanceId: StormEventParser.toInstanceIdFromRef(ref),
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                break;
+            case 'FILE_START':
+            case 'FILE_CHUNK_RESET':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                break;
+            case 'FILE_CHUNK':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        blockName,
+                        blockRef,
+                        instanceId,
                     },
                 });
-            case 'FILE':
-                return this.handleFileOutput(blockUri, aiName, data);
+                break;
+            case 'FILE_STATE':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                break;
+            case 'FILE_DONE':
+                this.handleFileDoneOutput(blockUri, blockName, data);
+                break;
+        }
+    }
+
+    private handleFileEvents(blockUri: KapetaURI, blockName: string, data: StormEvent) {
+        const blockRef = blockUri.toNormalizedString();
+        const instanceId = StormEventParser.toInstanceIdFromRef(blockRef);
+        const basePath = this.getBasePath(blockUri.fullName);
+        switch (data.type) {
+            case 'FILE_START':
+            case 'FILE_CHUNK_RESET':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        path: join(basePath, data.payload.filename),
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                return true;
+            case 'FILE_CHUNK':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        path: join(basePath, data.payload.filename),
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                return true;
+            case 'FILE_STATE':
+                this.out.emit('data', {
+                    ...data,
+                    payload: {
+                        ...data.payload,
+                        path: join(basePath, data.payload.filename),
+                        blockName,
+                        blockRef,
+                        instanceId,
+                    },
+                });
+                return true;
         }
+
+        return false;
     }
 
-    private handleFileOutput(blockUri: KapetaURI, aiName: string, data: StormEvent) {
+    private handleFileDoneOutput(blockUri: KapetaURI, aiName: string, data: StormEvent) {
         switch (data.type) {
-            case 'FILE':
+            case 'FILE_DONE':
                 const ref = blockUri.toNormalizedString();
                 this.emitFile(blockUri, aiName, data.payload.filename, data.payload.content, data.reason);
                 return {
-                    type: 'FILE',
+                    type: 'FILE_DONE',
                     created: Date.now(),
                     payload: {
                         filename: data.payload.filename,
+                        path: join(this.getBasePath(blockUri.fullName), data.payload.filename),
                         content: data.payload.content,
                         blockRef: ref,
                         instanceId: StormEventParser.toInstanceIdFromRef(ref),
                     },
-                } as StormEventFile;
+                } as StormEventFileContent;
         }
     }
 
@@ -126,7 +274,7 @@ export class StormCodegen {
         const allFiles = this.toStormFiles(generatedResult);
 
         // Send all the non-ai files to the stream
-        this.emitFiles(parseKapetaUri(block.uri), block.aiName, allFiles);
+        await this.emitStaticFiles(parseKapetaUri(block.uri), block.aiName, allFiles);
 
         if (this.isAborted()) {
             return;
@@ -318,8 +466,8 @@ export class StormCodegen {
     /**
      * Emits the text-based files to the stream
      */
-    private emitFiles(uri: KapetaURI, aiName: string, files: StormFileInfo[]) {
-        files.forEach((file) => {
+    private async emitStaticFiles(uri: KapetaURI, aiName: string, files: StormFileInfo[]) {
+        const promises = files.map((file) => {
             if (!file.content || typeof file.content !== 'string') {
                 return;
             }
@@ -336,8 +484,25 @@ export class StormCodegen {
                 return;
             }
 
-            this.emitFile(uri, aiName, file.filename, file.content);
+            const basePath = this.getBasePath(uri.fullName);
+            const ref = uri.toNormalizedString();
+            const fileEvent: StormEventFileContent = {
+                type: 'FILE_DONE',
+                reason: 'File generated',
+                created: Date.now(),
+                payload: {
+                    filename: file.filename,
+                    path: join(basePath, file.filename),
+                    content: file.content,
+                    blockName: aiName,
+                    blockRef: ref,
+                    instanceId: StormEventParser.toInstanceIdFromRef(ref),
+                },
+            };
+            return new SimulatedFileDelay(fileEvent, this.out).start();
         });
+
+        return Promise.all(promises);
     }
 
     private emitFile(
@@ -350,7 +515,7 @@ export class StormCodegen {
         const basePath = this.getBasePath(uri.fullName);
         const ref = uri.toNormalizedString();
         this.out.emit('data', {
-            type: 'FILE',
+            type: 'FILE_DONE',
             reason,
             created: Date.now(),
             payload: {
@@ -361,7 +526,7 @@ export class StormCodegen {
                 blockRef: ref,
                 instanceId: StormEventParser.toInstanceIdFromRef(ref),
             },
-        } satisfies StormEventFile);
+        } satisfies StormEventFileContent);
     }
 
     /**
@@ -373,7 +538,7 @@ export class StormCodegen {
         generator: ImplementationGenerator,
         templates: StormFileInfo[],
         contextFiles: StormFileInfo[]
-    ) {
+    ): Promise<void> {
         const promises = templates.map(async (templateFile) => {
             const stream = await generator({
                 context: contextFiles,
@@ -381,26 +546,18 @@ export class StormCodegen {
                 prompt: this.userPrompt,
             });
 
-            const files: StormEventFile[] = [];
-
             this.out.on('aborted', () => {
                 stream.abort();
             });
 
             stream.on('data', (evt) => {
-                const file = this.handleTemplateFileOutput(blockUri, aiName, templateFile, evt);
-                if (file) {
-                    files.push(file);
-                }
+                this.handleTemplateFileOutput(blockUri, aiName, templateFile, evt);
             });
 
             await stream.waitForDone();
-            return files;
         });
 
-        const fileChunks = await Promise.all(promises);
-
-        return fileChunks.flat();
+        await Promise.all(promises);
     }
 
     /**

package/src/storm/event-parser.ts

@@ -325,11 +325,6 @@ export class StormEventParser {
                 evt.payload.toBlockId = StormEventParser.toInstanceId(handle, evt.payload.toComponent);
                 this.connections.push(evt.payload);
                 break;
-
-            default:
-            case 'SCREEN_CANDIDATE':
-            case 'FILE':
-                break;
         }
 
         return this.toResult(handle);

package/src/storm/events.ts

@@ -182,20 +182,41 @@ export interface StormEventScreenCandidate {
     };
 }
 
-export interface StormEventFile {
-    type: 'FILE';
+export interface StormEventFileBasePayload {
+    filename: string;
+    path: string;
+    blockName: string;
+    blockRef: string;
+    instanceId: string;
+}
+
+export interface StormEventFileBase {
+    type: string;
     reason: string;
     created: number;
-    payload: {
-        filename: string;
-        path: string;
+    payload: StormEventFileBasePayload;
+}
+
+export interface StormEventFileLogical extends StormEventFileBase {
+    type: 'FILE_START' | 'FILE_CHUNK_RESET';
+}
+
+export interface StormEventFileState extends StormEventFileBase {
+    type: 'FILE_STATE';
+    payload: StormEventFileBasePayload & {
+        state: string;
+    };
+}
+
+export interface StormEventFileContent extends StormEventFileBase {
+    type: 'FILE_DONE' | 'FILE_CHUNK';
+    payload: StormEventFileBasePayload & {
         content: string;
-        blockName: string;
-        blockRef: string;
-        instanceId: string;
     };
 }
 
+export type StormEventFile = StormEventFileLogical | StormEventFileState | StormEventFileContent;
+
 export interface StormEventBlockReady {
     type: 'BLOCK_READY';
     reason: string;
@@ -245,7 +266,9 @@ export type StormEvent =
     | StormEventError
     | StormEventScreen
     | StormEventScreenCandidate
-    | StormEventFile
+    | StormEventFileLogical
+    | StormEventFileState
+    | StormEventFileContent
     | StormEventDone
     | StormEventDefinitionChange
     | StormEventErrorClassifier