@kapeta/local-cluster-service 0.53.4 → 0.54.0

package/src/storm/codegen.ts

@@ -13,6 +13,7 @@ import {
     GeneratedResult,
     MODE_CREATE_ONLY,
 } from '@kapeta/codegen';
+
 import { BlockDefinition } from '@kapeta/schemas';
 import { codeGeneratorManager } from '../codeGeneratorManager';
 import { STORM_ID, stormClient } from './stormClient';
@@ -23,6 +24,7 @@ import {
     StormEventFileChunk,
     StormEventFileDone,
     StormEventFileLogical,
+    StormEventScreen,
 } from './events';
 import { BlockDefinitionInfo, StormEventParser } from './event-parser';
 import { ConversationItem, StormFileImplementationPrompt, StormFileInfo, StormStream } from './stream';
@@ -31,11 +33,14 @@ import { writeFile } from 'fs/promises';
 import path from 'path';
 import Path, { join } from 'path';
 import os from 'node:os';
-import { readFileSync, writeFileSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
 import YAML from 'yaml';
-import * as fs from 'node:fs';
+import assert from 'assert';
 
-type ImplementationGenerator = (prompt: StormFileImplementationPrompt, conversationId?: string) => Promise<StormStream>;
+type ImplementationGenerator<T = StormFileImplementationPrompt> = (
+    prompt: T,
+    conversationId?: string
+) => Promise<StormStream>;
 
 interface ErrorClassification {
     error: string;
@@ -266,9 +271,13 @@ export class StormCodegen {
         const blockUri = parseKapetaUri(block.uri);
 
         const relevantFiles: StormFileInfo[] = allFiles.filter(
-            (file) => file.type !== AIFileTypes.IGNORE && file.type !== AIFileTypes.WEB_SCREEN
+            (file) =>
+                file.type !== AIFileTypes.IGNORE &&
+                file.type !== AIFileTypes.WEB_SCREEN &&
+                file.type !== AIFileTypes.WEB_ROUTER
         );
-        const uiTemplates: StormFileInfo[] = allFiles.filter((file) => file.type === AIFileTypes.WEB_SCREEN);
+        const uiTemplates = allFiles.filter((file) => file.type === AIFileTypes.WEB_SCREEN);
+        const webRouters = allFiles.filter((file) => file.type === AIFileTypes.WEB_ROUTER);
         const screenFiles: StormEventFileDone[] = [];
         let filteredEvents = [] as StormEvent[];
         for (const event of this.events) {
@@ -277,36 +286,96 @@ export class StormCodegen {
                 filteredEvents = [];
             }
         }
-        if (uiTemplates.length > 0) {
-            const uiStream = await stormClient.createUIImplementation({
-                events: filteredEvents,
-                templates: uiTemplates,
-                context: relevantFiles,
-                blockName: block.aiName,
-                prompt: this.userPrompt,
-            });
 
-            uiStream.on('data', (evt) => {
-                const uiFile = this.handleUiOutput(blockUri, block.aiName, evt);
-                if (uiFile != undefined) {
-                    screenFiles.push(uiFile);
-                }
-            });
+        const screenEvents: StormEventScreen[] = [];
+        // generate screens
+        const screenStream = await stormClient.listScreens({
+            events: filteredEvents,
+            templates: uiTemplates,
+            context: relevantFiles,
+            blockName: block.aiName,
+            prompt: this.userPrompt,
+        });
+        screenStream.on('data', (evt) => {
+            if (evt.type === 'SCREEN') {
+                screenEvents.push(evt);
+            }
+            this.handleUiOutput(blockUri, block.aiName, evt);
+        });
 
-            this.out.on('aborted', () => {
-                uiStream.abort();
-            });
+        this.out.on('aborted', () => {
+            screenStream.abort();
+        });
 
-            await uiStream.waitForDone();
-        }
+        await screenStream.waitForDone();
+
+        // screenfiles
+        const screenTemplates = screenEvents
+            .map((screenEvent) => ({
+                ...uiTemplates.find((template) => template.filename.endsWith(screenEvent.payload.template)),
+                filename: screenEvent.payload.filename,
+            }))
+            .filter((tpl): tpl is StormFileInfo => !!tpl.content);
+
+        await Promise.all(
+            screenTemplates.concat(webRouters).map(async (template) => {
+                const payload = {
+                    events: filteredEvents,
+                    blockName: block.aiName,
+                    filename: template.filename,
+                    template: template,
+                    context: relevantFiles.concat([
+                        {
+                            type: AIFileTypes.INSTRUCTIONS,
+                            mode: MODE_CREATE_ONLY,
+                            permissions: '0644',
+                            filename: '<screens>.md',
+                            content: `
+# Generated screens
+
+${JSON.stringify({ screenEvents })}
+
+`,
+                        },
+                    ]),
+                    prompt: this.userPrompt,
+                };
+
+                const uiStream = await stormClient.createUIImplementation(payload);
+
+                uiStream.on('data', (evt) => {
+                    const uiFile = this.handleUiOutput(blockUri, block.aiName, evt);
+                    if (uiFile != undefined) {
+                        screenFiles.push(uiFile);
+                    }
+                });
+
+                this.out.on('aborted', () => {
+                    uiStream.abort();
+                });
+
+                await uiStream.waitForDone();
+            })
+        );
 
         if (this.isAborted()) {
             return;
         }
+        const basePath = this.getBasePath(block.content.metadata.name);
+
+        const screenFilesConverted = screenFiles.map((screenFile) => {
+            return {
+                filename: screenFile.payload.filename,
+                content: screenFile.payload.content,
+                mode: MODE_CREATE_ONLY,
+                permissions: '0644',
+                type: AIFileTypes.WEB_SCREEN,
+            };
+        });
 
         // 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)
+            (file) => ![AIFileTypes.SERVICE, AIFileTypes.WEB_SCREEN, AIFileTypes.WEB_ROUTER].includes(file.type)
         );
 
         // Send the service and UI templates to the AI. These will be sent one-by-one in addition to the context files
@@ -321,12 +390,15 @@ export class StormCodegen {
             );
         }
 
-        const basePath = this.getBasePath(block.content.metadata.name);
-
         if (this.isAborted()) {
             return;
         }
 
+        for (const screenFile of screenFilesConverted) {
+            const filePath = join(basePath, screenFile.filename);
+            await writeFile(filePath, screenFile.content);
+        }
+
         for (const serviceFile of serviceFiles) {
             const filePath = join(basePath, serviceFile.filename);
             await writeFile(filePath, serviceFile.content);
@@ -345,16 +417,6 @@ export class StormCodegen {
             await writeFile(filePath, screenFile.payload.content);
         }
 
-        const screenFilesConverted = screenFiles.map((screenFile) => {
-            return {
-                filename: screenFile.payload.filename,
-                content: screenFile.payload.content,
-                mode: MODE_CREATE_ONLY,
-                permissions: '0644',
-                type: AIFileTypes.WEB_SCREEN,
-            };
-        });
-        allFiles.push(...screenFilesConverted);
         const blockRef = block.uri;
 
         this.emitBlockStatus(blockUri, block.aiName, StormEventBlockStatusType.QA);
@@ -594,7 +656,7 @@ export class StormCodegen {
         files.add(filename);
 
         const requestedFiles = Array.from(files).flatMap((file) => {
-            if (fs.existsSync(file)) {
+            if (existsSync(file)) {
                 return file;
             }
 
@@ -696,7 +758,7 @@ export class StormCodegen {
                 return;
             }
 
-            if (file.type === AIFileTypes.WEB_SCREEN) {
+            if ([AIFileTypes.WEB_ROUTER, AIFileTypes.WEB_SCREEN].includes(file.type)) {
                 // Don't send the web screen files to the stream yet
                 // They will need to be implemented by the AI
                 return;

package/src/storm/event-parser.ts

@@ -26,7 +26,7 @@ import {
     DSLAPIParser,
     DSLController,
     DSLConverters,
-    DSLDataTypeParser,
+    DSLDataTypeParser, DSLEntityType,
     DSLMethod,
     DSLParser,
     KAPLANG_ID,
@@ -325,13 +325,13 @@ export class StormEventParser {
                 this.connections.push(evt.payload);
                 break;
             case 'API_RETRY':
-                Object.values(this.blocks).forEach(block => {
+                Object.values(this.blocks).forEach((block) => {
                     block.types = [];
                     block.apis = [];
                 });
                 break;
             case 'MODEL_RETRY':
-                Object.values(this.blocks).forEach(block => {
+                Object.values(this.blocks).forEach((block) => {
                     block.models = [];
                 });
                 break;
@@ -537,7 +537,7 @@ export class StormEventParser {
 
             const blockSpec = blockDefinitionInfo.content.spec;
 
-            let apiResource: Resource | undefined = undefined;
+            const apiResources: { [key: string]: Resource | undefined } = {};
             let dbResource: Resource | undefined = undefined;
 
             blockInfo.resources.forEach((resource) => {
@@ -546,10 +546,7 @@ export class StormEventParser {
                 };
                 switch (resource.type) {
                     case 'API':
-                        if (apiResource) {
-                            break;
-                        }
-                        apiResource = {
+                        const apiResource = {
                             kind: this.toResourceKind(resource.type),
                             metadata: {
                                 name: resource.name,
@@ -565,6 +562,7 @@ export class StormEventParser {
                                 } satisfies SourceCode,
                             },
                         };
+                        apiResources[resource.name] = apiResource;
                         blockSpec.providers!.push(apiResource);
                         break;
                     case 'CLIENT':
@@ -646,11 +644,30 @@ export class StormEventParser {
                 }
             });
 
-            if (apiResource) {
-                blockInfo.apis.forEach((api) => {
-                    apiResource!.spec.source.value += api + '\n\n';
-                });
-            }
+            blockInfo.apis.forEach((api) => {
+                const dslApi = DSLAPIParser.parse(api, {
+                    ignoreSemantics: true,
+                }) as (DSLMethod | DSLController)[];
+
+                let exactMatch = false;
+                if (dslApi[0] && dslApi[0].type == DSLEntityType.CONTROLLER) {
+                    const name = dslApi[0].name.toLowerCase();
+                    const apiResourceName = Object.keys(apiResources).find((key) => key.indexOf(name) > -1);
+                    if (apiResourceName) {
+                        const exactResource = apiResources[apiResourceName];
+                        exactResource!.spec.source.value += api + '\n\n';
+                        exactMatch = true;
+                    }
+                }
+
+                if (!exactMatch) {
+                    // if we couldn't place the given api on the exact resource we just park it on the first
+                    // available rest resource
+                    const firstKey = Object.keys(apiResources)[0];
+                    const firstEntry = apiResources[firstKey];
+                    firstEntry!.spec.source.value += api + '\n\n';
+                }
+            });
 
             blockInfo.types.forEach((type) => {
                 blockSpec.entities!.source!.value += type + '\n';

package/src/storm/events.ts

@@ -193,6 +193,7 @@ export interface StormEventScreen {
         template: string;
         description: string;
         url: string;
+        filename: string;
     };
 }
 

package/src/storm/stormClient.ts

@@ -12,6 +12,7 @@ import {
     StormFileImplementationPrompt,
     StormStream,
     StormUIImplementationPrompt,
+    StormUIListPrompt,
 } from './stream';
 import { getRawAsset } from 'node:sea';
 
@@ -112,8 +113,15 @@ class StormClient {
         });
     }
 
+    public listScreens(prompt: StormUIListPrompt, conversationId?: string) {
+        return this.send('/v2/ui/list', {
+            prompt,
+            conversationId,
+        });
+    }
+
     public createUIImplementation(prompt: StormUIImplementationPrompt, conversationId?: string) {
-        return this.send<StormUIImplementationPrompt>('/v2/ui/merge', {
+        return this.send('/v2/ui/merge', {
             prompt,
             conversationId,
         });

package/src/storm/stream.ts

@@ -117,6 +117,15 @@ export interface StormFileImplementationPrompt {
 }
 
 export interface StormUIImplementationPrompt {
+    events: StormEvent[];
+    template: StormFileInfo;
+    filename: string;
+    context: StormFileInfo[];
+    blockName: string;
+    prompt: string;
+}
+
+export interface StormUIListPrompt {
     events: StormEvent[];
     templates: StormFileInfo[];
     context: StormFileInfo[];

package/test/storm/event-parser.test.ts

@@ -5,6 +5,7 @@
 
 import { StormEventParser } from '../../src/storm/event-parser';
 import { StormEvent } from '../../src/storm/events';
+import simpleBlogEvents from './simple-blog-events.json';
 
 const parserOptions = {
     serviceKind: 'kapeta/block-service:local',
@@ -179,4 +180,22 @@ describe('event-parser', () => {
         expect(result.plan.spec.connections[0].provider.blockId).toBe(serviceBlockInstance.id);
         expect(result.plan.spec.connections[0].provider.resourceName).toBe(apiResource?.metadata.name);
     });
+
+    it('it will split api into correct provider', () => {
+        const events = simpleBlogEvents as StormEvent[];
+        const parser = new StormEventParser(parserOptions);
+        events.forEach((event) => parser.processEvent('kapeta', event));
+
+        const result = parser.toResult('kapeta');
+
+        const blogService = result.blocks.find((block) => block.aiName === 'blog-service');
+        expect(blogService).toBeDefined();
+        expect(blogService?.content).toBeDefined();
+
+        const apiProviders = blogService?.content?.spec?.providers?.filter((provider) => provider.kind === 'kapeta/block-type-api:local');
+        expect(apiProviders).toBeDefined();
+        expect(apiProviders!.length).toBe(2);
+        expect(apiProviders!["0"].spec.source.value).not.toBe('');
+        expect(apiProviders!["1"].spec.source.value).not.toBe('');
+    });
 });