@kapeta/local-cluster-service 0.43.3 → 0.45.0

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

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StormCodegen = void 0;
+const codegen_1 = require("@kapeta/codegen");
+const codeGeneratorManager_1 = require("../codeGeneratorManager");
+const stormClient_1 = require("./stormClient");
+const stream_1 = require("./stream");
+class StormCodegen {
+    userPrompt;
+    blocks;
+    out = new stream_1.StormStream();
+    constructor(userPrompt, blocks) {
+        this.userPrompt = userPrompt;
+        this.blocks = blocks;
+    }
+    async process() {
+        console.log('Processing blocks', this.blocks.length);
+        for (const block of this.blocks) {
+            await this.processBlockCode(block);
+        }
+        this.out.end();
+    }
+    getStream() {
+        return this.out;
+    }
+    handleFileOutput(blockUri, template, data) {
+        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
+     */
+    async processBlockCode(block) {
+        // 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 = [codegen_1.AIFileTypes.SERVICE, codegen_1.AIFileTypes.WEB_SCREEN];
+        // Gather the context files. These will be all be passed to the AI
+        const contextFiles = allFiles.filter((file) => file.type !== codegen_1.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 = allFiles.filter((file) => file.type === codegen_1.AIFileTypes.SERVICE);
+        await this.processTemplates(block.uri, stormClient_1.stormClient.createServiceImplementation.bind(stormClient_1.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
+     */
+    emitFiles(uri, files) {
+        files.forEach((file) => {
+            if (!file.content || typeof file.content !== 'string') {
+                return;
+            }
+            if (file.type === codegen_1.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 === codegen_1.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);
+        });
+    }
+    emitFile(uri, filename, content, reason = 'File generated') {
+        this.out.emit('data', {
+            type: 'FILE',
+            reason,
+            created: Date.now(),
+            payload: {
+                filename: filename,
+                content: content,
+                blockRef: uri.toNormalizedString(),
+            },
+        });
+    }
+    /**
+     * Sends the template to the AI and processes the response
+     */
+    processTemplates(blockUri, generator, templates, contextFiles) {
+        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
+     */
+    toStormFiles(generatedResult) {
+        const allFiles = generatedResult.files.map((file) => {
+            if (!file.content) {
+                return {
+                    ...file,
+                    type: codegen_1.AIFileTypes.IGNORE,
+                };
+            }
+            if (typeof file.content !== 'string') {
+                return {
+                    ...file,
+                    type: codegen_1.AIFileTypes.IGNORE,
+                };
+            }
+            const rx = /\/\/AI-TYPE:([a-z0-9- _]+)\n/gi;
+            const match = rx.exec(file.content);
+            if (!match) {
+                return {
+                    ...file,
+                    type: codegen_1.AIFileTypes.IGNORE,
+                };
+            }
+            const type = match[1].trim();
+            file.content = file.content.replace(rx, '');
+            return {
+                ...file,
+                type,
+            };
+        });
+        return allFiles;
+    }
+    /**
+     * Generates the code using codegen for a given block.
+     */
+    async generateBlock(yamlContent, screens) {
+        if (!yamlContent.spec.target?.kind) {
+            //Not all block types have targets
+            return;
+        }
+        if (!(await codeGeneratorManager_1.codeGeneratorManager.ensureTarget(yamlContent.spec.target?.kind))) {
+            return;
+        }
+        const codeGenerator = new codegen_1.BlockCodeGenerator(yamlContent);
+        codeGenerator.withOption('AIContext', stormClient_1.STORM_ID);
+        codeGenerator.withOption('AIScreens', screens ?? []);
+        return codeGenerator.generate();
+    }
+}
+exports.StormCodegen = StormCodegen;

package/dist/esm/src/storm/event-parser.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { ScreenTemplate, StormEvent } from './events';
+import { BlockDefinition, Plan } from '@kapeta/schemas';
+import { KapetaURI } from '@kapeta/nodejs-utils';
+export interface BlockDefinitionInfo {
+    uri: KapetaURI;
+    content: BlockDefinition;
+    screens: ScreenTemplate[];
+}
+export interface ParsedResult {
+    plan: Plan;
+    blocks: BlockDefinitionInfo[];
+}
+export interface StormOptions {
+    databaseKind: string;
+    apiKind: string;
+    clientKind: string;
+    webPageKind: string;
+    webFragmentKind: string;
+    mqKind: string;
+    serviceKind: string;
+    serviceLanguage: string;
+    frontendKind: string;
+    frontendLanguage: string;
+    exchangeKind: string;
+    queueKind: string;
+    publisherKind: string;
+    subscriberKind: string;
+    jwtProviderKind: string;
+    jwtConsumerKind: string;
+    smtpKind: string;
+    externalApiKind: string;
+    cliKind: string;
+    cliLanguage: string;
+    desktopKind: string;
+    desktopLanguage: string;
+    gatewayKind: string;
+}
+export declare function resolveOptions(): Promise<StormOptions>;
+export declare class StormEventParser {
+    private events;
+    private planName;
+    private planDescription;
+    private blocks;
+    private connections;
+    private failed;
+    private error;
+    private options;
+    constructor(options: StormOptions);
+    private reset;
+    addEvent(evt: StormEvent): void;
+    getEvents(): StormEvent[];
+    isValid(): boolean;
+    getError(): string;
+    private applyLayoutToBlocks;
+    toResult(handle: string): ParsedResult;
+    private toSafeName;
+    private toRef;
+    toBlockDefinitions(handle: string): {
+        [key: string]: BlockDefinitionInfo;
+    };
+    private toResourceKind;
+    private toBlockKind;
+    private toPortType;
+    private toBlockTarget;
+    private toBlockTargetKind;
+}