@kapeta/local-cluster-service 0.43.3 → 0.45.0

package/src/proxy/types/web.ts

@@ -7,12 +7,10 @@ import request from 'request';
 import _ from 'lodash';
 import { networkManager } from '../../networkManager';
 import { socketManager } from '../../socketManager';
-import { Response } from 'express';
-import { ProxyRequestInfo, SimpleRequest, StringMap } from '../../types';
-import { StringBodyRequest } from '../../middleware/stringBody';
+import { ProxyRequestHandler, SimpleRequest, StringMap } from '../../types';
 import { stringify } from 'qs';
 
-export function proxyHttpRequest(req: StringBodyRequest, res: Response, opts: ProxyRequestInfo) {
+export const proxyHttpRequest: ProxyRequestHandler = (req, res, opts) => {
     const requestHeaders = _.clone(req.headers);
 
     delete requestHeaders['content-length'];
@@ -67,4 +65,4 @@ export function proxyHttpRequest(req: StringBodyRequest, res: Response, opts: Pr
 
     //We need to pipe the proxy response to the client response to handle sockets and event streams
     proxyReq.pipe(res);
-}
+};

package/src/storm/codegen.ts

@@ -0,0 +1,210 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import { Definition } from '@kapeta/local-cluster-config';
+import { AIFileTypes, BlockCodeGenerator, GeneratedFile, GeneratedResult } from '@kapeta/codegen';
+import { BlockDefinition } from '@kapeta/schemas';
+import { codeGeneratorManager } from '../codeGeneratorManager';
+import { STORM_ID, stormClient } from './stormClient';
+import { ScreenTemplate, StormEvent, StormEventFile } from './events';
+import { BlockDefinitionInfo } from './event-parser';
+import { ConversationItem, StormFileImplementationPrompt, StormFileInfo, StormStream } from './stream';
+import { KapetaURI } from '@kapeta/nodejs-utils';
+
+type ImplementationGenerator = (
+    prompt: StormFileImplementationPrompt,
+    history?: ConversationItem[]
+) => Promise<StormStream>;
+
+export class StormCodegen {
+    private readonly userPrompt: string;
+    private readonly blocks: BlockDefinitionInfo[];
+    private readonly out = new StormStream();
+
+    constructor(userPrompt: string, blocks: BlockDefinitionInfo[]) {
+        this.userPrompt = userPrompt;
+        this.blocks = blocks;
+    }
+
+    public async process() {
+        console.log('Processing blocks', this.blocks.length);
+
+        for (const block of this.blocks) {
+            await this.processBlockCode(block);
+        }
+
+        this.out.end();
+    }
+
+    public getStream() {
+        return this.out;
+    }
+
+    private handleFileOutput(blockUri: KapetaURI, template: StormFileInfo, data: StormEvent) {
+        switch (data.type) {
+            case 'FILE':
+                template.filename = data.payload.filename;
+                template.content = data.payload.content;
+                this.emitFile(blockUri, data.payload.filename, data.payload.content, data.reason);
+                break;
+        }
+    }
+
+    /**
+     * Generates the code for a block and sends it to the AI
+     */
+    private async processBlockCode(block: BlockDefinitionInfo) {
+        // Generate the code for the block using the standard codegen templates
+        const generatedResult = await this.generateBlock(block.content, block.screens);
+        if (!generatedResult) {
+            console.warn('No generated result for block', block.uri);
+            return;
+        }
+
+        const allFiles = this.toStormFiles(generatedResult);
+
+        // Send all the non-ai files to the stream
+        this.emitFiles(block.uri, allFiles);
+
+        const implementFiles = [AIFileTypes.SERVICE, AIFileTypes.WEB_SCREEN];
+
+        // Gather the context files. These will be all be passed to the AI
+        const contextFiles: StormFileInfo[] = allFiles.filter(
+            (file) => file.type !== AIFileTypes.IGNORE && !implementFiles.includes(file.type)
+        );
+
+        // Send the service and UI templates to the AI. These will be send one-by-one in addition to the context files
+        const serviceFiles: StormFileInfo[] = allFiles.filter((file) => file.type === AIFileTypes.SERVICE);
+        await this.processTemplates(
+            block.uri,
+            stormClient.createServiceImplementation.bind(stormClient),
+            serviceFiles,
+            contextFiles
+        );
+
+        //const uiTemplates: StormFileInfo[] = allFiles.filter((file) => file.type === 'ui');
+        //await this.processTemplates(stormClient.createUIImplementation, uiTemplates, contextFiles);
+    }
+
+    /**
+     * Emits the text-based files to the stream
+     */
+    private emitFiles(uri: KapetaURI, files: StormFileInfo[]) {
+        files.forEach((file) => {
+            if (!file.content || typeof file.content !== 'string') {
+                return;
+            }
+
+            if (file.type === AIFileTypes.SERVICE) {
+                // Don't send the service files to the stream yet
+                // They will need to be implemented by the AI
+                return;
+            }
+
+            if (file.type === AIFileTypes.WEB_SCREEN) {
+                // Don't send the web screen files to the stream yet
+                // They will need to be implemented by the AI
+                return;
+            }
+
+            this.emitFile(uri, file.filename, file.content);
+        });
+    }
+
+    private emitFile(uri: KapetaURI, filename: string, content: string, reason: string = 'File generated') {
+        this.out.emit('data', {
+            type: 'FILE',
+            reason,
+            created: Date.now(),
+            payload: {
+                filename: filename,
+                content: content,
+                blockRef: uri.toNormalizedString(),
+            },
+        } satisfies StormEventFile);
+    }
+
+    /**
+     * Sends the template to the AI and processes the response
+     */
+    private processTemplates(
+        blockUri: KapetaURI,
+        generator: ImplementationGenerator,
+        templates: StormFileInfo[],
+        contextFiles: StormFileInfo[]
+    ) {
+        const promises = templates.map(async (templateFile) => {
+            const stream = await generator({
+                context: contextFiles,
+                template: templateFile,
+                prompt: this.userPrompt,
+            });
+
+            stream.on('data', (evt) => this.handleFileOutput(blockUri, templateFile, evt));
+
+            return stream.waitForDone();
+        });
+
+        return Promise.all(promises);
+    }
+
+    /**
+     * Converts the generated files to a format that can be sent to the AI
+     */
+    private toStormFiles(generatedResult: GeneratedResult) {
+        const allFiles: StormFileInfo[] = generatedResult.files.map((file: GeneratedFile) => {
+            if (!file.content) {
+                return {
+                    ...file,
+                    type: AIFileTypes.IGNORE,
+                };
+            }
+            if (typeof file.content !== 'string') {
+                return {
+                    ...file,
+                    type: AIFileTypes.IGNORE,
+                };
+            }
+
+            const rx = /\/\/AI-TYPE:([a-z0-9- _]+)\n/gi;
+
+            const match = rx.exec(file.content);
+            if (!match) {
+                return {
+                    ...file,
+                    type: AIFileTypes.IGNORE,
+                };
+            }
+            const type = match[1].trim() as AIFileTypes;
+            file.content = file.content.replace(rx, '');
+
+            return {
+                ...file,
+                type,
+            };
+        });
+        return allFiles;
+    }
+
+    /**
+     * Generates the code using codegen for a given block.
+     */
+    private async generateBlock(yamlContent: Definition, screens: ScreenTemplate[] | undefined) {
+        if (!yamlContent.spec.target?.kind) {
+            //Not all block types have targets
+            return;
+        }
+
+        if (!(await codeGeneratorManager.ensureTarget(yamlContent.spec.target?.kind))) {
+            return;
+        }
+
+        const codeGenerator = new BlockCodeGenerator(yamlContent as BlockDefinition);
+        codeGenerator.withOption('AIContext', STORM_ID);
+        codeGenerator.withOption('AIScreens', screens ?? []);
+
+        return codeGenerator.generate();
+    }
+}