@kapeta/local-cluster-service 0.44.0 → 0.46.0

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

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * 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 express_promise_router_1 = __importDefault(require("express-promise-router"));
+const cors_1 = require("../middleware/cors");
+const stringBody_1 = require("../middleware/stringBody");
+const stormClient_1 = require("./stormClient");
+const event_parser_1 = require("./event-parser");
+const codegen_1 = require("./codegen");
+const router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
+router.use('/', stringBody_1.stringBody);
+router.post('/:handle/all', async (req, res) => {
+    const handle = req.params.handle;
+    try {
+        const stormOptions = await (0, event_parser_1.resolveOptions)();
+        const eventParser = new event_parser_1.StormEventParser(stormOptions);
+        const aiRequest = JSON.parse(req.stringBody ?? '{}');
+        const metaStream = await stormClient_1.stormClient.createMetadata(aiRequest.prompt, aiRequest.history);
+        res.set('Content-Type', 'application/x-ndjson');
+        metaStream.on('data', (data) => {
+            eventParser.addEvent(data);
+        });
+        await streamStormPartialResponse(metaStream, res);
+        if (!eventParser.isValid()) {
+            // We can't continue if the meta stream is invalid
+            res.write({
+                type: 'ERROR_INTERNAL',
+                payload: { error: eventParser.getError() },
+                reason: 'Failed to generate system',
+                created: Date.now(),
+            });
+            res.end();
+            return;
+        }
+        const result = eventParser.toResult(handle);
+        const stormCodegen = new codegen_1.StormCodegen(aiRequest.prompt, result.blocks, eventParser.getEvents());
+        const codegenStream = streamStormPartialResponse(stormCodegen.getStream(), res);
+        await stormCodegen.process();
+        await codegenStream;
+        sendDone(res);
+    }
+    catch (err) {
+        sendError(err, res);
+    }
+});
+function sendDone(res) {
+    res.write(JSON.stringify({
+        type: 'DONE',
+        created: Date.now(),
+    }) + '\n');
+    res.end();
+}
+function sendError(err, res) {
+    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',
+        }) + '\n');
+    }
+    else {
+        res.status(400).send({ error: err.message });
+    }
+}
+function streamStormPartialResponse(result, res) {
+    return new Promise((resolve, reject) => {
+        result.on('data', (data) => {
+            res.write(JSON.stringify(data) + '\n');
+        });
+        result.on('error', (err) => {
+            reject(err);
+        });
+        result.on('end', () => {
+            resolve();
+        });
+    });
+}
+exports.default = router;

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

@@ -0,0 +1,13 @@
+import { ConversationItem, StormFileImplementationPrompt, StormStream, StormUIImplementationPrompt } from './stream';
+export declare const STORM_ID = "storm";
+declare class StormClient {
+    private readonly _baseUrl;
+    constructor();
+    private createOptions;
+    private send;
+    createMetadata(prompt: string, history?: ConversationItem[]): Promise<StormStream>;
+    createUIImplementation(prompt: StormUIImplementationPrompt, history?: ConversationItem[]): Promise<StormStream>;
+    createServiceImplementation(prompt: StormFileImplementationPrompt, history?: ConversationItem[]): Promise<StormStream>;
+}
+export declare const stormClient: StormClient;
+export {};

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

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stormClient = exports.STORM_ID = void 0;
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const utils_1 = require("../utils/utils");
+const promises_1 = __importDefault(require("node:readline/promises"));
+const node_stream_1 = require("node:stream");
+const stream_1 = require("./stream");
+exports.STORM_ID = 'storm';
+class StormClient {
+    _baseUrl;
+    constructor() {
+        this._baseUrl = (0, utils_1.getRemoteUrl)('ai-service', 'https://ai.kapeta.com');
+    }
+    createOptions(path, method, body) {
+        const url = `${this._baseUrl}${path}`;
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        const api = new nodejs_api_client_1.KapetaAPI();
+        if (api.hasToken()) {
+            //headers['Authorization'] = `Bearer ${api.getAccessToken()}`; //TODO: Enable authentication
+        }
+        return {
+            url,
+            method: method,
+            body: JSON.stringify(body),
+            headers,
+        };
+    }
+    async send(path, body, method = 'POST') {
+        const stringPrompt = typeof body.prompt === 'string' ? body.prompt : JSON.stringify(body.prompt);
+        const options = this.createOptions(path, method, {
+            prompt: stringPrompt,
+            history: body.history,
+        });
+        const out = new stream_1.StormStream(stringPrompt, body.history);
+        const response = await fetch(options.url, options);
+        if (response.status !== 200) {
+            throw new Error(`Got error response from ${options.url}: ${response.status}\nContent: ${await response.text()}`);
+        }
+        const jsonLStream = promises_1.default.createInterface(node_stream_1.Readable.fromWeb(response.body));
+        jsonLStream.on('line', (line) => {
+            out.addJSONLine(line);
+        });
+        jsonLStream.on('error', (error) => {
+            out.emit('error', error);
+        });
+        jsonLStream.on('close', () => {
+            out.end();
+        });
+        return out;
+    }
+    createMetadata(prompt, history) {
+        return this.send('/v2/all', {
+            history: history ?? [],
+            prompt: prompt,
+        });
+    }
+    createUIImplementation(prompt, history) {
+        return this.send('/v2/ui/merge', {
+            history: history ?? [],
+            prompt,
+        });
+    }
+    createServiceImplementation(prompt, history) {
+        return this.send('/v2/services/merge', {
+            history: history ?? [],
+            prompt,
+        });
+    }
+}
+exports.stormClient = new StormClient();

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

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { EventEmitter } from 'node:events';
+import { StormEvent } from './events';
+import { AIFileTypes, GeneratedFile } from '@kapeta/codegen';
+export declare class StormStream extends EventEmitter {
+    private history;
+    private lines;
+    constructor(prompt?: string, history?: ConversationItem[]);
+    addJSONLine(line: string): void;
+    end(): void;
+    on(event: 'end', listener: () => void): this;
+    on(event: 'error', listener: (e: Error) => void): this;
+    on(event: 'data', listener: (data: StormEvent) => void): this;
+    emit(event: 'end'): boolean;
+    emit(event: 'error', e: Error): boolean;
+    emit(event: 'data', data: StormEvent): boolean;
+    waitForDone(): Promise<void>;
+}
+export interface ConversationItem {
+    role: 'user' | 'model';
+    content: string;
+}
+export interface StormContextRequest<T = string> {
+    history?: ConversationItem[];
+    prompt: T;
+}
+export interface StormFileInfo extends GeneratedFile {
+    type: AIFileTypes;
+}
+export interface StormFileImplementationPrompt {
+    context: StormFileInfo[];
+    template: StormFileInfo;
+    prompt: string;
+}
+export interface StormUIImplementationPrompt {
+    events: StormEvent[];
+    templates: StormFileInfo[];
+    context: StormFileInfo[];
+    blockName: string;
+    prompt: string;
+}

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StormStream = void 0;
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+const node_events_1 = require("node:events");
+class StormStream extends node_events_1.EventEmitter {
+    history;
+    lines = [];
+    constructor(prompt = '', history) {
+        super();
+        this.history = history ?? [];
+        this.history.push({
+            role: 'user',
+            content: prompt,
+        });
+    }
+    addJSONLine(line) {
+        try {
+            this.lines.push(line);
+            const event = JSON.parse(line);
+            if (!event.created) {
+                event.created = Date.now();
+            }
+            this.emit('data', event);
+        }
+        catch (e) {
+            this.emit('error', e);
+        }
+    }
+    end() {
+        this.history.push({
+            role: 'model',
+            content: this.lines.join('\n'),
+        });
+        this.emit('end');
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    emit(eventName, ...args) {
+        return super.emit(eventName, ...args);
+    }
+    waitForDone() {
+        return new Promise((resolve, reject) => {
+            this.on('error', (err) => {
+                reject(err);
+            });
+            this.on('end', () => {
+                resolve();
+            });
+        });
+    }
+}
+exports.StormStream = StormStream;

package/dist/esm/index.js

@@ -50,6 +50,7 @@ const routes_9 = __importDefault(require("./src/attachments/routes"));
 const routes_10 = __importDefault(require("./src/tasks/routes"));
 const api_1 = __importDefault(require("./src/api"));
 const routes_11 = __importDefault(require("./src/ai/routes"));
+const routes_12 = __importDefault(require("./src/storm/routes"));
 const utils_1 = require("./src/utils/utils");
 const request_1 = __importDefault(require("request"));
 const repositoryManager_1 = require("./src/repositoryManager");
@@ -89,6 +90,7 @@ function createServer() {
     app.use('/tasks', routes_10.default);
     app.use('/api', api_1.default);
     app.use('/ai', routes_11.default);
+    app.use('/storm', routes_12.default);
     app.get('/status', async (req, res) => {
         res.send({
             ok: true,

package/dist/esm/src/codeGeneratorManager.d.ts

@@ -4,6 +4,7 @@
  */
 import { Definition } from '@kapeta/local-cluster-config';
 declare class CodeGeneratorManager {
+    ensureTarget(targetKind: string): Promise<boolean>;
     private ensureLanguageTargetInRegistry;
     reload(): Promise<void>;
     initialize(): Promise<void>;

package/dist/esm/src/codeGeneratorManager.js

@@ -17,6 +17,17 @@ const repositoryManager_1 = require("./repositoryManager");
 const TARGET_KIND = 'core/language-target';
 const BLOCK_TYPE_REGEX = /^core\/block-type.*/;
 class CodeGeneratorManager {
+    async ensureTarget(targetKind) {
+        const targetRef = (0, nodejs_utils_1.normalizeKapetaUri)(targetKind);
+        // Automatically downloads target if not available
+        const targetAsset = await assetManager_1.assetManager.getAsset(targetRef);
+        if (!targetAsset) {
+            console.error('Language target not found: %s', targetKind);
+            return false;
+        }
+        await this.ensureLanguageTargetInRegistry(targetAsset?.path, targetAsset?.version, targetAsset?.data);
+        return true;
+    }
     async ensureLanguageTargetInRegistry(path, version, definition) {
         const key = `${definition.metadata.name}:${version}`;
         try {
@@ -72,14 +83,9 @@ class CodeGeneratorManager {
             //Not all block types have targets
             return;
         }
-        const targetRef = (0, nodejs_utils_1.normalizeKapetaUri)(yamlContent.spec.target?.kind);
-        // Automatically downloads target if not available
-        const targetAsset = await assetManager_1.assetManager.getAsset(targetRef);
-        if (!targetAsset) {
-            console.error('Language target not found: %s', yamlContent.spec.target?.kind);
+        if (!(await this.ensureTarget(yamlContent.spec.target?.kind))) {
             return;
         }
-        await this.ensureLanguageTargetInRegistry(targetAsset?.path, targetAsset?.version, targetAsset?.data);
         const baseDir = path_1.default.dirname(yamlFile);
         console.log('Generating code for path: %s', baseDir);
         const codeGenerator = new codegen_1.BlockCodeGenerator(yamlContent);

package/dist/esm/src/middleware/cors.d.ts

@@ -2,5 +2,6 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+/// <reference types="cookie-parser" />
 import { NextFunction, Request, Response } from 'express';
 export declare function corsHandler(req: Request, res: Response, next: NextFunction): void;

package/dist/esm/src/middleware/kapeta.d.ts

@@ -2,6 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+/// <reference types="cookie-parser" />
 import { NextFunction, Request, Response } from 'express';
 import { EnvironmentType } from '../types';
 export interface KapetaRequest extends Request {

package/dist/esm/src/middleware/stringBody.d.ts

@@ -2,6 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+/// <reference types="cookie-parser" />
 import { NextFunction, Request, Response } from 'express';
 export type StringBodyRequest = Request<any> & {
     stringBody?: string;

package/dist/esm/src/storm/codegen.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { StormEvent } from './events';
+import { BlockDefinitionInfo } from './event-parser';
+import { StormStream } from './stream';
+export declare class StormCodegen {
+    private readonly userPrompt;
+    private readonly blocks;
+    private readonly out;
+    private readonly events;
+    constructor(userPrompt: string, blocks: BlockDefinitionInfo[], events: StormEvent[]);
+    process(): Promise<void>;
+    getStream(): StormStream;
+    private handleTemplateFileOutput;
+    private handleUiOutput;
+    private handleFileOutput;
+    /**
+     * Generates the code for a block and sends it to the AI
+     */
+    private processBlockCode;
+    /**
+     * Emits the text-based files to the stream
+     */
+    private emitFiles;
+    private emitFile;
+    /**
+     * Sends the template to the AI and processes the response
+     */
+    private processTemplates;
+    /**
+     * Converts the generated files to a format that can be sent to the AI
+     */
+    private toStormFiles;
+    /**
+     * Generates the code using codegen for a given block.
+     */
+    private generateBlock;
+}

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

@@ -0,0 +1,210 @@
+"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();
+    events;
+    constructor(userPrompt, blocks, events) {
+        this.userPrompt = userPrompt;
+        this.blocks = blocks;
+        this.events = events;
+    }
+    async process() {
+        for (const block of this.blocks) {
+            await this.processBlockCode(block);
+        }
+        this.out.end();
+    }
+    getStream() {
+        return this.out;
+    }
+    handleTemplateFileOutput(blockUri, template, data) {
+        switch (data.type) {
+            case 'FILE':
+                template.filename = data.payload.filename;
+                template.content = data.payload.content;
+                return this.handleFileOutput(blockUri, data);
+        }
+    }
+    handleUiOutput(blockUri, data) {
+        switch (data.type) {
+            case 'SCREEN':
+                this.out.emit('data', {
+                    type: 'SCREEN',
+                    reason: data.reason,
+                    created: Date.now(),
+                    payload: {
+                        ...data.payload,
+                        blockName: blockUri.toNormalizedString(),
+                    },
+                });
+            case 'FILE':
+                return this.handleFileOutput(blockUri, data);
+        }
+    }
+    handleFileOutput(blockUri, data) {
+        switch (data.type) {
+            case 'FILE':
+                this.emitFile(blockUri, data.payload.filename, data.payload.content, data.reason);
+                return {
+                    type: 'FILE',
+                    created: Date.now(),
+                    payload: {
+                        filename: data.payload.filename,
+                        content: data.payload.content,
+                    },
+                };
+        }
+    }
+    /**
+     * 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);
+        if (!generatedResult) {
+            return;
+        }
+        const allFiles = this.toStormFiles(generatedResult);
+        // Send all the non-ai files to the stream
+        this.emitFiles(block.uri, allFiles);
+        const relevantFiles = allFiles.filter((file) => file.type !== codegen_1.AIFileTypes.IGNORE && file.type !== codegen_1.AIFileTypes.WEB_SCREEN);
+        const uiTemplates = allFiles.filter((file) => file.type === codegen_1.AIFileTypes.WEB_SCREEN);
+        if (uiTemplates.length > 0) {
+            const uiStream = await stormClient_1.stormClient.createUIImplementation({
+                events: this.events,
+                templates: uiTemplates,
+                context: relevantFiles,
+                blockName: block.aiName,
+                prompt: this.userPrompt,
+            });
+            uiStream.on('data', (evt) => {
+                this.handleUiOutput(block.uri, evt);
+            });
+            await uiStream.waitForDone();
+        }
+        // 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));
+        // 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);
+        if (serviceFiles.length > 0) {
+            await this.processTemplates(block.uri, stormClient_1.stormClient.createServiceImplementation.bind(stormClient_1.stormClient), serviceFiles, 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
+     */
+    async processTemplates(blockUri, generator, templates, contextFiles) {
+        const promises = templates.map(async (templateFile) => {
+            const stream = await generator({
+                context: contextFiles,
+                template: templateFile,
+                prompt: this.userPrompt,
+            });
+            const files = [];
+            stream.on('data', (evt) => {
+                const file = this.handleTemplateFileOutput(blockUri, templateFile, evt);
+                if (file) {
+                    files.push(file);
+                }
+            });
+            await stream.waitForDone();
+            return files;
+        });
+        const fileChunks = await Promise.all(promises);
+        return fileChunks.flat();
+    }
+    /**
+     * 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) {
+        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);
+        return codeGenerator.generate();
+    }
+}
+exports.StormCodegen = StormCodegen;