@kapeta/local-cluster-service 0.53.4 → 0.54.0

package/.eslintrc.cjs

@@ -6,6 +6,7 @@ module.exports = {
     rules: {
         '@typescript-eslint/no-explicit-any': 'off',
         '@typescript-eslint/no-non-null-assertion': 'off',
+        '@typescript-eslint/no-use-before-define': 'off',
         '@typescript-eslint/no-unsafe-assignment': 'off',
         '@typescript-eslint/no-unsafe-member-access': 'off',
         '@typescript-eslint/no-unsafe-return': 'off',

package/CHANGELOG.md

@@ -1,3 +1,20 @@
+# [0.54.0](https://github.com/kapetacom/local-cluster-service/compare/v0.53.5...v0.54.0) (2024-06-17)
+
+
+### Features
+
+* add support for split UI routes + screen context in AI service ([#178](https://github.com/kapetacom/local-cluster-service/issues/178)) ([4330a72](https://github.com/kapetacom/local-cluster-service/commit/4330a72eddb5fe82f9e7a9c2af412d47091cf9b0))
+
+## [0.53.5](https://github.com/kapetacom/local-cluster-service/compare/v0.53.4...v0.53.5) (2024-06-17)
+
+
+### Bug Fixes
+
+* actually map to correct api ([dc88af0](https://github.com/kapetacom/local-cluster-service/commit/dc88af0f7a76867ed9f96e5653a1ceb7f9002f6d))
+* pretty ([9efc6ed](https://github.com/kapetacom/local-cluster-service/commit/9efc6edd9bb7717889d37a2d1c0c227b10e57d47))
+* split apis into multiple named resources ([da3b59f](https://github.com/kapetacom/local-cluster-service/commit/da3b59fb238f2035235b452491f3b170768e49d9))
+* use type to determine controller or not ([bb88e9f](https://github.com/kapetacom/local-cluster-service/commit/bb88e9f0d349bc23fc7973e8525578e6dcb1d663))
+
 ## [0.53.4](https://github.com/kapetacom/local-cluster-service/compare/v0.53.3...v0.53.4) (2024-06-13)
 
 

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

@@ -44,7 +44,6 @@ const path_2 = __importStar(require("path"));
 const node_os_1 = __importDefault(require("node:os"));
 const fs_1 = require("fs");
 const yaml_1 = __importDefault(require("yaml"));
-const fs = __importStar(require("node:fs"));
 const SIMULATED_DELAY = 1000;
 const ENABLE_SIMULATED_DELAY = false;
 class SimulatedFileDelay {
@@ -239,8 +238,11 @@ class StormCodegen {
             return;
         }
         const blockUri = (0, nodejs_utils_1.parseKapetaUri)(block.uri);
-        const relevantFiles = allFiles.filter((file) => file.type !== codegen_1.AIFileTypes.IGNORE && file.type !== codegen_1.AIFileTypes.WEB_SCREEN);
+        const relevantFiles = allFiles.filter((file) => file.type !== codegen_1.AIFileTypes.IGNORE &&
+            file.type !== codegen_1.AIFileTypes.WEB_SCREEN &&
+            file.type !== codegen_1.AIFileTypes.WEB_ROUTER);
         const uiTemplates = allFiles.filter((file) => file.type === codegen_1.AIFileTypes.WEB_SCREEN);
+        const webRouters = allFiles.filter((file) => file.type === codegen_1.AIFileTypes.WEB_ROUTER);
         const screenFiles = [];
         let filteredEvents = [];
         for (const event of this.events) {
@@ -249,14 +251,55 @@ class StormCodegen {
                 filteredEvents = [];
             }
         }
-        if (uiTemplates.length > 0) {
-            const uiStream = await stormClient_1.stormClient.createUIImplementation({
+        const screenEvents = [];
+        // generate screens
+        const screenStream = await stormClient_1.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', () => {
+            screenStream.abort();
+        });
+        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.content);
+        await Promise.all(screenTemplates.concat(webRouters).map(async (template) => {
+            const payload = {
                 events: filteredEvents,
-                templates: uiTemplates,
-                context: relevantFiles,
                 blockName: block.aiName,
+                filename: template.filename,
+                template: template,
+                context: relevantFiles.concat([
+                    {
+                        type: codegen_1.AIFileTypes.INSTRUCTIONS,
+                        mode: codegen_1.MODE_CREATE_ONLY,
+                        permissions: '0644',
+                        filename: '<screens>.md',
+                        content: `
+# Generated screens
+
+${JSON.stringify({ screenEvents })}
+
+`,
+                    },
+                ]),
                 prompt: this.userPrompt,
-            });
+            };
+            const uiStream = await stormClient_1.stormClient.createUIImplementation(payload);
             uiStream.on('data', (evt) => {
                 const uiFile = this.handleUiOutput(blockUri, block.aiName, evt);
                 if (uiFile != undefined) {
@@ -267,21 +310,34 @@ class StormCodegen {
                 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: codegen_1.MODE_CREATE_ONLY,
+                permissions: '0644',
+                type: codegen_1.AIFileTypes.WEB_SCREEN,
+            };
+        });
         // Gather the context files for implementation. These will be all be passed to the AI
-        const contextFiles = relevantFiles.filter((file) => ![codegen_1.AIFileTypes.SERVICE, codegen_1.AIFileTypes.WEB_SCREEN].includes(file.type));
+        const contextFiles = relevantFiles.filter((file) => ![codegen_1.AIFileTypes.SERVICE, codegen_1.AIFileTypes.WEB_SCREEN, codegen_1.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
         const serviceFiles = allFiles.filter((file) => file.type === codegen_1.AIFileTypes.SERVICE);
         if (serviceFiles.length > 0) {
             await this.processTemplates(blockUri, block.aiName, stormClient_1.stormClient.createServiceImplementation.bind(stormClient_1.stormClient), serviceFiles, contextFiles);
         }
-        const basePath = this.getBasePath(block.content.metadata.name);
         if (this.isAborted()) {
             return;
         }
+        for (const screenFile of screenFilesConverted) {
+            const filePath = (0, path_2.join)(basePath, screenFile.filename);
+            await (0, promises_1.writeFile)(filePath, screenFile.content);
+        }
         for (const serviceFile of serviceFiles) {
             const filePath = (0, path_2.join)(basePath, serviceFile.filename);
             await (0, promises_1.writeFile)(filePath, serviceFile.content);
@@ -296,16 +352,6 @@ class StormCodegen {
             const filePath = (0, path_2.join)(basePath, screenFile.payload.filename);
             await (0, promises_1.writeFile)(filePath, screenFile.payload.content);
         }
-        const screenFilesConverted = screenFiles.map((screenFile) => {
-            return {
-                filename: screenFile.payload.filename,
-                content: screenFile.payload.content,
-                mode: codegen_1.MODE_CREATE_ONLY,
-                permissions: '0644',
-                type: codegen_1.AIFileTypes.WEB_SCREEN,
-            };
-        });
-        allFiles.push(...screenFilesConverted);
         const blockRef = block.uri;
         this.emitBlockStatus(blockUri, block.aiName, events_1.StormEventBlockStatusType.QA);
         const filesToBeFixed = serviceFiles.concat(contextFiles).concat(screenFilesConverted);
@@ -466,7 +512,7 @@ class StormCodegen {
         const files = new Set(filesForContext);
         files.add(filename);
         const requestedFiles = Array.from(files).flatMap((file) => {
-            if (fs.existsSync(file)) {
+            if ((0, fs_1.existsSync)(file)) {
                 return file;
             }
             // file does not exist - look for similar
@@ -551,7 +597,7 @@ class StormCodegen {
                 // They will need to be implemented by the AI
                 return;
             }
-            if (file.type === codegen_1.AIFileTypes.WEB_SCREEN) {
+            if ([codegen_1.AIFileTypes.WEB_ROUTER, codegen_1.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/dist/cjs/src/storm/event-parser.js

@@ -211,13 +211,13 @@ 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;
@@ -384,7 +384,7 @@ class StormEventParser {
                 },
             };
             const blockSpec = blockDefinitionInfo.content.spec;
-            let apiResource = undefined;
+            const apiResources = {};
             let dbResource = undefined;
             blockInfo.resources.forEach((resource) => {
                 const port = {
@@ -392,10 +392,7 @@ class StormEventParser {
                 };
                 switch (resource.type) {
                     case 'API':
-                        if (apiResource) {
-                            break;
-                        }
-                        apiResource = {
+                        const apiResource = {
                             kind: this.toResourceKind(resource.type),
                             metadata: {
                                 name: resource.name,
@@ -411,6 +408,7 @@ class StormEventParser {
                                 },
                             },
                         };
+                        apiResources[resource.name] = apiResource;
                         blockSpec.providers.push(apiResource);
                         break;
                     case 'CLIENT':
@@ -491,11 +489,28 @@ class StormEventParser {
                         });
                 }
             });
-            if (apiResource) {
-                blockInfo.apis.forEach((api) => {
-                    apiResource.spec.source.value += api + '\n\n';
+            blockInfo.apis.forEach((api) => {
+                const dslApi = kaplang_core_1.DSLAPIParser.parse(api, {
+                    ignoreSemantics: true,
                 });
-            }
+                let exactMatch = false;
+                if (dslApi[0] && dslApi[0].type == kaplang_core_1.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/dist/cjs/src/storm/events.d.ts

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

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

@@ -1,4 +1,4 @@
-import { ConversationItem, StormFileImplementationPrompt, StormStream, StormUIImplementationPrompt } from './stream';
+import { ConversationItem, StormFileImplementationPrompt, StormStream, StormUIImplementationPrompt, StormUIListPrompt } from './stream';
 export declare const STORM_ID = "storm";
 export declare const ConversationIdHeader = "Conversation-Id";
 declare class StormClient {
@@ -7,6 +7,7 @@ declare class StormClient {
     private createOptions;
     private send;
     createMetadata(prompt: string, conversationId?: string): Promise<StormStream>;
+    listScreens(prompt: StormUIListPrompt, conversationId?: string): Promise<StormStream>;
     createUIImplementation(prompt: StormUIImplementationPrompt, conversationId?: string): Promise<StormStream>;
     createServiceImplementation(prompt: StormFileImplementationPrompt, conversationId?: string): Promise<StormStream>;
     createErrorClassification(prompt: string, history?: ConversationItem[], conversationId?: string): Promise<StormStream>;

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

@@ -80,6 +80,12 @@ class StormClient {
             conversationId,
         });
     }
+    listScreens(prompt, conversationId) {
+        return this.send('/v2/ui/list', {
+            prompt,
+            conversationId,
+        });
+    }
     createUIImplementation(prompt, conversationId) {
         return this.send('/v2/ui/merge', {
             prompt,

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

@@ -50,6 +50,14 @@ export interface StormFileImplementationPrompt {
     prompt: string;
 }
 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/dist/cjs/test/storm/event-parser.test.js

@@ -3,8 +3,12 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const event_parser_1 = require("../../src/storm/event-parser");
+const simple_blog_events_json_1 = __importDefault(require("./simple-blog-events.json"));
 const parserOptions = {
     serviceKind: 'kapeta/block-service:local',
     serviceLanguage: 'kapeta/language-target-nodejs-ts:local',
@@ -158,4 +162,18 @@ 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 = simple_blog_events_json_1.default;
+        const parser = new event_parser_1.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('');
+    });
 });