@kapeta/local-cluster-service 0.49.0 → 0.51.0

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[];
@@ -51,54 +99,158 @@ export class StormCodegen {
         this.out.end();
     }
 
+    isAborted() {
+        return this.out.isAborted();
+    }
+
     public getStream() {
         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,
+                    },
+                });
+                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,
                     },
                 });
-            case 'FILE':
-                return this.handleFileOutput(blockUri, aiName, data);
+                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;
         }
     }
 
@@ -110,6 +262,9 @@ export class StormCodegen {
      * Generates the code for a block and sends it to the AI
      */
     private async processBlockCode(block: BlockDefinitionInfo) {
+        if (this.isAborted()) {
+            return;
+        }
         // Generate the code for the block using the standard codegen templates
         const generatedResult = await this.generateBlock(block.content);
         if (!generatedResult) {
@@ -119,7 +274,11 @@ 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;
+        }
 
         const relevantFiles: StormFileInfo[] = allFiles.filter(
             (file) => file.type !== AIFileTypes.IGNORE && file.type !== AIFileTypes.WEB_SCREEN
@@ -138,9 +297,17 @@ export class StormCodegen {
                 this.handleUiOutput(parseKapetaUri(block.uri), block.aiName, evt);
             });
 
+            this.out.on('aborted', () => {
+                uiStream.abort();
+            });
+
             await uiStream.waitForDone();
         }
 
+        if (this.isAborted()) {
+            return;
+        }
+
         // Gather the context files for implementation. These will be all be passed to the AI
         const contextFiles: StormFileInfo[] = relevantFiles.filter(
             (file) => ![AIFileTypes.SERVICE, AIFileTypes.WEB_SCREEN].includes(file.type)
@@ -160,6 +327,10 @@ export class StormCodegen {
 
         const basePath = this.getBasePath(block.content.metadata.name);
 
+        if (this.isAborted()) {
+            return;
+        }
+
         for (const serviceFile of serviceFiles) {
             const filePath = join(basePath, serviceFile.filename);
             await writeFile(filePath, serviceFile.content);
@@ -216,6 +387,10 @@ export class StormCodegen {
                     const errorStream = await stormClient.createErrorClassification(result.error, []);
                     const fixes = new Map<string, Promise<string>>();
 
+                    this.out.on('aborted', () => {
+                        errorStream.abort();
+                    });
+
                     errorStream.on('data', (evt) => {
                         if (evt.type === 'ERROR_CLASSIFIER') {
                             // find the file that caused the error
@@ -232,8 +407,8 @@ export class StormCodegen {
                             const fix = `${evt.payload.potentialFix}\n---\n${knownFiles
                                 .map((e) => e.filename)
                                 .join('\n')}\n---\n${content}`;
-                            console.log(`trying to fix the code in ${eventFileName}`);
-                            console.debug(`with the fix:\n${fix}`);
+                            //console.log(`trying to fix the code in ${eventFileName}`);
+                            //console.debug(`with the fix:\n${fix}`);
                             const code = this.codeFix(fix);
                             fixes.set(join(basePath, eventFileName), code);
                         }
@@ -278,6 +453,9 @@ export class StormCodegen {
                     resolve(evt.payload.content);
                 }
             });
+            this.out.on('aborted', () => {
+                fixStream.abort();
+            });
             fixStream.on('error', (err) => {
                 reject(err);
             });
@@ -288,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;
             }
@@ -306,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(
@@ -320,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: {
@@ -331,7 +526,7 @@ export class StormCodegen {
                 blockRef: ref,
                 instanceId: StormEventParser.toInstanceIdFromRef(ref),
             },
-        } satisfies StormEventFile);
+        } satisfies StormEventFileContent);
     }
 
     /**
@@ -343,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,
@@ -351,22 +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);
     }
 
     /**
@@ -411,6 +602,9 @@ export class StormCodegen {
      * Generates the code using codegen for a given block.
      */
     private async generateBlock(yamlContent: Definition) {
+        if (this.isAborted()) {
+            return;
+        }
         if (!yamlContent.spec.target?.kind) {
             //Not all block types have targets
             return;
@@ -427,4 +621,8 @@ export class StormCodegen {
         new CodeWriter(basePath).write(generatedResult);
         return generatedResult;
     }
+
+    abort() {
+        this.out.abort();
+    }
 }

package/src/storm/event-parser.ts

@@ -3,7 +3,15 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { StormBlockInfoFilled, StormBlockType, StormConnection, StormEvent, StormResourceType } from './events';
+import {
+    StormBlockInfoFilled,
+    StormBlockType,
+    StormConnection,
+    StormEvent,
+    StormEventPhases,
+    StormEventPhaseType,
+    StormResourceType,
+} from './events';
 import {
     BlockDefinition,
     BlockInstance,
@@ -87,6 +95,24 @@ function prettifyKaplang(source: string) {
     }
 }
 
+export function createPhaseStartEvent(type: StormEventPhaseType): StormEventPhases {
+    return createPhaseEvent(true, type);
+}
+
+export function createPhaseEndEvent(type: StormEventPhaseType): StormEventPhases {
+    return createPhaseEvent(false, type);
+}
+
+export function createPhaseEvent(start: boolean, type: StormEventPhaseType): StormEventPhases {
+    return {
+        type: start ? 'PHASE_START' : 'PHASE_END',
+        created: Date.now(),
+        payload: {
+            phaseType: type,
+        },
+    };
+}
+
 export async function resolveOptions(): Promise<StormOptions> {
     // Predefined types for now - TODO: Allow user to select / change
 
@@ -299,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);
@@ -325,7 +346,7 @@ export class StormEventParser {
     }
 
     public toResult(handle: string): StormDefinitions {
-        const planRef = StormEventParser.toRef(handle, this.planName ?? 'undefined');
+        const planRef = StormEventParser.toRef(handle, this.planName || 'undefined');
         const blockDefinitions = this.toBlockDefinitions(handle);
         const refIdMap: { [key: string]: string } = {};
         const blocks = Object.entries(blockDefinitions).map(([ref, block]) => {
@@ -337,7 +358,7 @@ export class StormEventParser {
                 block: {
                     ref,
                 },
-                name: block.content.metadata.title ?? block.content.metadata.name,
+                name: block.content.metadata.title || block.content.metadata.name,
                 dimensions: {
                     left: 0,
                     top: 0,

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;
@@ -220,6 +241,20 @@ export interface StormEventDefinitionChange {
     payload: StormDefinitions;
 }
 
+export enum StormEventPhaseType {
+    META = 'META',
+    DEFINITIONS = 'DEFINITIONS',
+    IMPLEMENTATION = 'IMPLEMENTATION',
+}
+
+export interface StormEventPhases {
+    type: 'PHASE_START' | 'PHASE_END';
+    created: number;
+    payload: {
+        phaseType: StormEventPhaseType;
+    };
+}
+
 export type StormEvent =
     | StormEventCreateBlock
     | StormEventCreateConnection
@@ -231,9 +266,12 @@ export type StormEvent =
     | StormEventError
     | StormEventScreen
     | StormEventScreenCandidate
-    | StormEventFile
+    | StormEventFileLogical
+    | StormEventFileState
+    | StormEventFileContent
     | StormEventDone
     | StormEventDefinitionChange
     | StormEventErrorClassifier
     | StormEventCodeFix
-    | StormEventBlockReady;
+    | StormEventBlockReady
+    | StormEventPhases;