@kapeta/local-cluster-service 0.46.0 → 0.47.1

package/src/storm/codegen.ts

@@ -8,7 +8,7 @@ import { AIFileTypes, BlockCodeGenerator, GeneratedFile, GeneratedResult } from
 import { BlockDefinition } from '@kapeta/schemas';
 import { codeGeneratorManager } from '../codeGeneratorManager';
 import { STORM_ID, stormClient } from './stormClient';
-import { ScreenTemplate, StormEvent, StormEventFile, StormEventScreen } from './events';
+import { StormEvent, StormEventFile } from './events';
 import { BlockDefinitionInfo } from './event-parser';
 import { ConversationItem, StormFileImplementationPrompt, StormFileInfo, StormStream } from './stream';
 import { KapetaURI } from '@kapeta/nodejs-utils';
@@ -42,16 +42,16 @@ export class StormCodegen {
         return this.out;
     }
 
-    private handleTemplateFileOutput(blockUri: KapetaURI, template: StormFileInfo, data: StormEvent) {
+    private handleTemplateFileOutput(blockUri: KapetaURI, aiName: string, template: StormFileInfo, data: StormEvent) {
         switch (data.type) {
             case 'FILE':
                 template.filename = data.payload.filename;
                 template.content = data.payload.content;
-                return this.handleFileOutput(blockUri, data);
+                return this.handleFileOutput(blockUri, aiName, data);
         }
     }
 
-    private handleUiOutput(blockUri: KapetaURI, data: StormEvent) {
+    private handleUiOutput(blockUri: KapetaURI, aiName: string, data: StormEvent) {
         switch (data.type) {
             case 'SCREEN':
                 this.out.emit('data', {
@@ -60,18 +60,18 @@ export class StormCodegen {
                     created: Date.now(),
                     payload: {
                         ...data.payload,
-                        blockName: blockUri.toNormalizedString(),
+                        blockName: aiName,
                     },
                 });
             case 'FILE':
-                return this.handleFileOutput(blockUri, data);
+                return this.handleFileOutput(blockUri, aiName, data);
         }
     }
 
-    private handleFileOutput(blockUri: KapetaURI, data: StormEvent) {
+    private handleFileOutput(blockUri: KapetaURI, aiName: string, data: StormEvent) {
         switch (data.type) {
             case 'FILE':
-                this.emitFile(blockUri, data.payload.filename, data.payload.content, data.reason);
+                this.emitFile(blockUri, aiName, data.payload.filename, data.payload.content, data.reason);
                 return {
                     type: 'FILE',
                     created: Date.now(),
@@ -96,7 +96,7 @@ export class StormCodegen {
         const allFiles = this.toStormFiles(generatedResult);
 
         // Send all the non-ai files to the stream
-        this.emitFiles(block.uri, allFiles);
+        this.emitFiles(block.uri, block.aiName, allFiles);
 
         const relevantFiles: StormFileInfo[] = allFiles.filter(
             (file) => file.type !== AIFileTypes.IGNORE && file.type !== AIFileTypes.WEB_SCREEN
@@ -112,7 +112,7 @@ export class StormCodegen {
             });
 
             uiStream.on('data', (evt) => {
-                this.handleUiOutput(block.uri, evt);
+                this.handleUiOutput(block.uri, block.aiName, evt);
             });
 
             await uiStream.waitForDone();
@@ -128,6 +128,7 @@ export class StormCodegen {
         if (serviceFiles.length > 0) {
             await this.processTemplates(
                 block.uri,
+                block.aiName,
                 stormClient.createServiceImplementation.bind(stormClient),
                 serviceFiles,
                 contextFiles
@@ -138,7 +139,7 @@ export class StormCodegen {
     /**
      * Emits the text-based files to the stream
      */
-    private emitFiles(uri: KapetaURI, files: StormFileInfo[]) {
+    private emitFiles(uri: KapetaURI, aiName: string, files: StormFileInfo[]) {
         files.forEach((file) => {
             if (!file.content || typeof file.content !== 'string') {
                 return;
@@ -156,11 +157,17 @@ export class StormCodegen {
                 return;
             }
 
-            this.emitFile(uri, file.filename, file.content);
+            this.emitFile(uri, aiName, file.filename, file.content);
         });
     }
 
-    private emitFile(uri: KapetaURI, filename: string, content: string, reason: string = 'File generated') {
+    private emitFile(
+        uri: KapetaURI,
+        blockName: string,
+        filename: string,
+        content: string,
+        reason: string = 'File generated'
+    ) {
         this.out.emit('data', {
             type: 'FILE',
             reason,
@@ -168,6 +175,7 @@ export class StormCodegen {
             payload: {
                 filename: filename,
                 content: content,
+                blockName,
                 blockRef: uri.toNormalizedString(),
             },
         } satisfies StormEventFile);
@@ -178,6 +186,7 @@ export class StormCodegen {
      */
     private async processTemplates(
         blockUri: KapetaURI,
+        aiName: string,
         generator: ImplementationGenerator,
         templates: StormFileInfo[],
         contextFiles: StormFileInfo[]
@@ -192,7 +201,7 @@ export class StormCodegen {
             const files: StormEventFile[] = [];
 
             stream.on('data', (evt) => {
-                const file = this.handleTemplateFileOutput(blockUri, templateFile, evt);
+                const file = this.handleTemplateFileOutput(blockUri, aiName, templateFile, evt);
                 if (file) {
                     files.push(file);
                 }

package/src/storm/event-parser.ts

@@ -3,14 +3,7 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import {
-    ScreenTemplate,
-    StormBlockInfoFilled,
-    StormBlockType,
-    StormConnection,
-    StormEvent,
-    StormResourceType,
-} from './events';
+import { StormBlockInfoFilled, StormBlockType, StormConnection, StormEvent, StormResourceType } from './events';
 import {
     BlockDefinition,
     BlockInstance,
@@ -21,8 +14,17 @@ import {
     SourceCode,
 } from '@kapeta/schemas';
 import { KapetaURI, normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
-import { KAPLANG_ID, KAPLANG_VERSION, RESTMethod } from '@kapeta/kaplang-core';
-import uuid from 'node-uuid';
+import {
+    DSLAPIParser,
+    DSLController,
+    DSLConverters,
+    DSLDataTypeParser,
+    DSLMethod,
+    KAPLANG_ID,
+    KAPLANG_VERSION,
+    KaplangWriter,
+} from '@kapeta/kaplang-core';
+import { v5 as uuid } from 'uuid';
 import { definitionsManager } from '../definitionsManager';
 
 export interface BlockDefinitionInfo {
@@ -31,7 +33,7 @@ export interface BlockDefinitionInfo {
     aiName: string;
 }
 
-export interface ParsedResult {
+export interface StormDefinitions {
     plan: Plan;
     blocks: BlockDefinitionInfo[];
 }
@@ -196,8 +198,9 @@ export class StormEventParser {
         this.connections = [];
     }
 
-    public addEvent(evt: StormEvent): void {
+    public addEvent(handle: string, evt: StormEvent): StormDefinitions {
         this.events.push(evt);
+        console.log('evt', evt);
         switch (evt.type) {
             case 'CREATE_PLAN_PROPERTIES':
                 this.planName = evt.payload.name;
@@ -236,6 +239,8 @@ export class StormEventParser {
             case 'FILE':
                 break;
         }
+
+        return this.toResult(handle);
     }
 
     public getEvents(): StormEvent[] {
@@ -243,6 +248,9 @@ export class StormEventParser {
     }
 
     public isValid(): boolean {
+        if (!this.planName) {
+            return false;
+        }
         return !this.failed;
     }
 
@@ -250,17 +258,13 @@ export class StormEventParser {
         return this.error;
     }
 
-    private applyLayoutToBlocks(result: ParsedResult): ParsedResult {
-        return result;
-    }
-
-    public toResult(handle: string): ParsedResult {
-        const planRef = this.toRef(handle, this.planName);
+    public toResult(handle: string): StormDefinitions {
+        const planRef = this.toRef(handle, this.planName ?? 'undefined');
         const blockDefinitions = this.toBlockDefinitions(handle);
         const refIdMap: { [key: string]: string } = {};
-        const screens: { [key: string]: ScreenTemplate[] } = {};
         const blocks = Object.entries(blockDefinitions).map(([ref, block]) => {
-            const id = uuid.v4();
+            // Create a deterministic uuid
+            const id = uuid(ref, uuid.URL);
             refIdMap[ref] = id;
             return {
                 id,
@@ -271,7 +275,7 @@ export class StormEventParser {
                 dimensions: {
                     left: 0,
                     top: 0,
-                    width: 200,
+                    width: 150,
                     height: 200,
                 },
             } satisfies BlockInstance;
@@ -327,13 +331,41 @@ export class StormEventParser {
                     return;
                 }
 
+                if (apiProviderBlock.content.spec.entities?.source?.value) {
+                    if (!clientConsumerBlock.content.spec.entities) {
+                        clientConsumerBlock.content.spec.entities = {
+                            types: [],
+                            source: {
+                                type: KAPLANG_ID,
+                                version: KAPLANG_VERSION,
+                                value: '',
+                            },
+                        };
+                    }
+
+                    const clientTypes = DSLDataTypeParser.parse(
+                        clientConsumerBlock.content.spec.entities.source!.value
+                    );
+                    const apiTypes = DSLDataTypeParser.parse(apiProviderBlock.content.spec.entities?.source?.value);
+
+                    apiTypes.forEach((apiType) => {
+                        if (clientTypes.some((clientType) => clientType.name === apiType.name)) {
+                            // Already exists
+                            return;
+                        }
+                        clientTypes.push(apiType);
+                    });
+
+                    clientConsumerBlock.content.spec.entities.source!.value = KaplangWriter.write(clientTypes);
+                }
                 clientResource.spec.methods = apiResource.spec.methods;
                 clientResource.spec.source = apiResource.spec.source;
             });
 
-        const connections = this.connections.map((connection) => {
+        const connections: Connection[] = this.connections.map((connection) => {
             const fromRef = this.toRef(handle, connection.fromComponent);
             const toRef = this.toRef(handle, connection.toComponent);
+
             return {
                 port: {
                     type: this.toPortType(connection.fromResourceType),
@@ -346,9 +378,7 @@ export class StormEventParser {
                     blockId: refIdMap[fromRef.toNormalizedString()],
                     resourceName: connection.fromResource,
                 },
-                mapping: {
-                    //TODO: Add mapping
-                },
+                mapping: this.toConnectionMapping(handle, connection, blockDefinitions),
             } satisfies Connection;
         });
 
@@ -365,10 +395,10 @@ export class StormEventParser {
             },
         };
 
-        return this.applyLayoutToBlocks({
+        return {
             plan,
             blocks: Object.values(blockDefinitions),
-        });
+        };
     }
 
     private toSafeName(name: string): string {
@@ -504,7 +534,7 @@ export class StormEventParser {
                                 } satisfies SourceCode,
                             },
                         };
-                        blockSpec.providers!.push(dbResource);
+                        blockSpec.consumers!.push(dbResource);
                         break;
                     case 'JWTCONSUMER':
                     case 'WEBFRAGMENT':
@@ -596,6 +626,55 @@ export class StormEventParser {
         return '';
     }
 
+    private toConnectionMapping(
+        handle: string,
+        connection: StormConnection,
+        blockDefinitions: { [key: string]: BlockDefinitionInfo }
+    ): any {
+        if (connection.fromResourceType !== 'API') {
+            return;
+        }
+
+        const fromRef = this.toRef(handle, connection.fromComponent);
+
+        const apiProviderBlock = blockDefinitions[fromRef.toNormalizedString()];
+        if (!apiProviderBlock) {
+            console.warn('Provider block not found: %s', connection.fromComponent, connection);
+            return;
+        }
+
+        const apiResource = apiProviderBlock.content.spec.providers?.find(
+            (p) => p.kind === this.options.apiKind && p.metadata.name === connection.fromResource
+        );
+
+        if (!apiResource) {
+            console.warn(
+                'API resource not found: %s on %s',
+                connection.fromResource,
+                fromRef.toNormalizedString(),
+                connection
+            );
+            return;
+        }
+
+        const apiMethods = DSLConverters.toSchemaMethods(
+            DSLAPIParser.parse(apiResource.spec?.source?.value ?? '', {
+                ignoreSemantics: true,
+            }) as (DSLMethod | DSLController)[]
+        );
+
+        const mapping: any = {};
+
+        Object.entries(apiMethods).forEach(([methodId, method]) => {
+            mapping[methodId] = {
+                targetId: methodId,
+                type: 'EXACT',
+            };
+        });
+
+        return mapping;
+    }
+
     private toPortType(type: StormResourceType) {
         switch (type) {
             case 'API':

package/src/storm/events.ts

@@ -2,6 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+import { StormDefinitions } from './event-parser';
 
 export type StormResourceType =
     | 'API'
@@ -145,6 +146,7 @@ export interface StormEventFile {
     payload: {
         filename: string;
         content: string;
+        blockName: string;
         blockRef: string;
     };
 }
@@ -154,6 +156,13 @@ export interface StormEventDone {
     created: number;
 }
 
+export interface StormEventDefinitionChange {
+    type: 'DEFINITION_CHANGE';
+    reason: string;
+    created: number;
+    payload: StormDefinitions;
+}
+
 export type StormEvent =
     | StormEventCreateBlock
     | StormEventCreateConnection
@@ -165,4 +174,5 @@ export type StormEvent =
     | StormEventScreen
     | StormEventScreenCandidate
     | StormEventFile
-    | StormEventDone;
+    | StormEventDone
+    | StormEventDefinitionChange;

package/src/storm/routes.ts

@@ -11,7 +11,7 @@ import { KapetaBodyRequest } from '../types';
 import { StormContextRequest, StormFileImplementationPrompt, StormFileInfo, StormStream } from './stream';
 import { stormClient } from './stormClient';
 import { StormEvent } from './events';
-import { resolveOptions, StormEventParser } from './event-parser';
+import { resolveOptions, StormDefinitions, StormEventParser } from './event-parser';
 import { StormCodegen } from './codegen';
 
 const router = Router();
@@ -33,24 +33,29 @@ router.post('/:handle/all', async (req: KapetaBodyRequest, res: Response) => {
         res.set('Content-Type', 'application/x-ndjson');
 
         metaStream.on('data', (data: StormEvent) => {
-            eventParser.addEvent(data);
+            const result = eventParser.addEvent(req.params.handle, data);
+
+            sendDefinitions(res, result);
         });
 
         await streamStormPartialResponse(metaStream, res);
 
         if (!eventParser.isValid()) {
             // We can't continue if the meta stream is invalid
-            res.write({
+            sendEvent(res, {
                 type: 'ERROR_INTERNAL',
                 payload: { error: eventParser.getError() },
                 reason: 'Failed to generate system',
                 created: Date.now(),
-            } satisfies StormEvent);
+            });
             res.end();
             return;
         }
+
         const result = eventParser.toResult(handle);
 
+        sendDefinitions(res, result);
+
         const stormCodegen = new StormCodegen(aiRequest.prompt, result.blocks, eventParser.getEvents());
 
         const codegenStream = streamStormPartialResponse(stormCodegen.getStream(), res);
@@ -65,13 +70,20 @@ router.post('/:handle/all', async (req: KapetaBodyRequest, res: Response) => {
     }
 });
 
+function sendDefinitions(res: Response, result: StormDefinitions) {
+    sendEvent(res, {
+        type: 'DEFINITION_CHANGE',
+        payload: result,
+        reason: 'Updates to definition',
+        created: Date.now(),
+    });
+}
+
 function sendDone(res: Response) {
-    res.write(
-        JSON.stringify({
-            type: 'DONE',
-            created: Date.now(),
-        } satisfies StormEvent) + '\n'
-    );
+    sendEvent(res, {
+        type: 'DONE',
+        created: Date.now(),
+    });
 
     res.end();
 }
@@ -79,14 +91,12 @@ function sendDone(res: Response) {
 function sendError(err: Error, res: Response) {
     console.error('Failed to send prompt', err);
     if (res.headersSent) {
-        res.write(
-            JSON.stringify({
-                type: 'ERROR_INTERNAL',
-                created: Date.now(),
-                payload: { error: err.message },
-                reason: 'Failed while sending prompt',
-            } satisfies StormEvent) + '\n'
-        );
+        sendEvent(res, {
+            type: 'ERROR_INTERNAL',
+            created: Date.now(),
+            payload: { error: err.message },
+            reason: 'Failed while sending prompt',
+        });
     } else {
         res.status(400).send({ error: err.message });
     }
@@ -95,7 +105,7 @@ function sendError(err: Error, res: Response) {
 function streamStormPartialResponse(result: StormStream, res: Response) {
     return new Promise<void>((resolve, reject) => {
         result.on('data', (data) => {
-            res.write(JSON.stringify(data) + '\n');
+            sendEvent(res, data);
         });
 
         result.on('error', (err) => {
@@ -108,4 +118,8 @@ function streamStormPartialResponse(result: StormStream, res: Response) {
     });
 }
 
+function sendEvent(res: Response, evt: StormEvent) {
+    res.write(JSON.stringify(evt) + '\n');
+}
+
 export default router;

package/src/storm/stormClient.ts

@@ -34,6 +34,10 @@ class StormClient {
             //headers['Authorization'] = `Bearer ${api.getAccessToken()}`; //TODO: Enable authentication
         }
 
+        if (body.conversationId) {
+            headers['conversationId'] = body.conversationId;
+        }
+
         return {
             url,
             method: method,

package/src/storm/stream.ts

@@ -74,6 +74,7 @@ export interface ConversationItem {
 
 export interface StormContextRequest<T = string> {
     history?: ConversationItem[];
+    conversationId?: string;
     prompt: T;
 }