@kapeta/local-cluster-service 0.48.4 → 0.48.5

package/.vscode/launch.json

@@ -6,7 +6,7 @@
             "request": "launch",
             "name": "Debug Node.js (npm run dev)",
             "runtimeExecutable": "npm",
-            "runtimeArgs": ["run-script", "dev"],
+            "runtimeArgs": ["run", "start:dev"],
             "restart": true,
             "console": "integratedTerminal",
             "internalConsoleOptions": "neverOpen",

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.48.5](https://github.com/kapetacom/local-cluster-service/compare/v0.48.4...v0.48.5) (2024-06-04)
+
+
+### Bug Fixes
+
+* we should read the file previously written ([fe0b78e](https://github.com/kapetacom/local-cluster-service/commit/fe0b78efd5018be28308170a0c76b2619425a158))
+
 ## [0.48.4](https://github.com/kapetacom/local-cluster-service/compare/v0.48.3...v0.48.4) (2024-06-03)
 
 

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

@@ -22,6 +22,13 @@ export declare class StormCodegen {
      * Generates the code for a block and sends it to the AI
      */
     private processBlockCode;
+    private verifyAndFixCode;
+    removePrefix(prefix: string, str: string): string;
+    writeToFile(fileName: string, code: Promise<string>): Promise<void>;
+    /**
+     * Sends the code to the AI for a fix
+     */
+    private codeFix;
     /**
      * Emits the text-based files to the stream
      */

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

@@ -39,6 +39,7 @@ const stream_1 = require("./stream");
 const promises_1 = require("fs/promises");
 const path_1 = __importStar(require("path"));
 const node_os_1 = __importDefault(require("node:os"));
+const fs_1 = require("fs");
 class StormCodegen {
     userPrompt;
     blocks;
@@ -154,6 +155,89 @@ class StormCodegen {
             const filePath = (0, path_1.join)(basePath, uiFile.filename);
             await (0, promises_1.writeFile)(filePath, uiFile.content);
         }
+        const filesToBeFixed = serviceFiles.concat(contextFiles);
+        const codeGenerator = new codegen_1.BlockCodeGenerator(block.content);
+        await this.verifyAndFixCode(codeGenerator, basePath, filesToBeFixed, allFiles);
+    }
+    async verifyAndFixCode(codeGenerator, basePath, filesToBeFixed, knownFiles) {
+        let attempts = 0;
+        let validCode = false;
+        for (let i = 0; i <= 3; i++) {
+            attempts++;
+            try {
+                console.log(`Validating the code in ${basePath} attempt #${attempts}`);
+                const result = await codeGenerator.validateForTarget(basePath);
+                if (result && result.valid) {
+                    validCode = true;
+                    break;
+                }
+                if (result && !result.valid) {
+                    console.debug('Validation error:', result);
+                    const errorStream = await stormClient_1.stormClient.createErrorClassification(result.error, []);
+                    const fixes = new Map();
+                    errorStream.on('data', (evt) => {
+                        if (evt.type === 'ERROR_CLASSIFIER') {
+                            // find the file that caused the error
+                            // strip base path from event file name, if it exists sometimes the AI sends the full path
+                            const eventFileName = this.removePrefix(basePath + '/', evt.payload.filename);
+                            const file = filesToBeFixed.find((f) => f.filename === eventFileName);
+                            if (!file) {
+                                console.log(`Could not find the file ${eventFileName} in the list of files to be fixed, Henrik might wanna create a new file for this fix`);
+                            }
+                            // read the content of the file
+                            const content = (0, fs_1.readFileSync)((0, path_1.join)(basePath, eventFileName), 'utf8');
+                            const fix = `${evt.payload.potentialFix}\n---\n${knownFiles.map(e => e.filename).join("\n")}\n---\n${content}`;
+                            console.log(`trying to fix the code in ${eventFileName}`);
+                            console.debug(`with the fix:\n${fix}`);
+                            const code = this.codeFix(fix);
+                            fixes.set((0, path_1.join)(basePath, eventFileName), code);
+                        }
+                    });
+                    await errorStream.waitForDone();
+                    for (const [filename, codePromise] of fixes) {
+                        const code = await codePromise;
+                        (0, fs_1.writeFileSync)(filename, code);
+                    }
+                }
+            }
+            catch (e) {
+                console.error('Error:', e);
+            }
+        }
+        if (validCode) {
+            console.log(`Validation successful after ${attempts} attempts`);
+        }
+        else {
+            console.error(`Validation failed for ${basePath} after ${attempts} attempts`);
+        }
+    }
+    removePrefix(prefix, str) {
+        if (str.startsWith(prefix)) {
+            return str.slice(prefix.length);
+        }
+        return str;
+    }
+    async writeToFile(fileName, code) {
+        console.log(`writing the fixed code to ${fileName}`);
+        const resolvedCode = await code;
+        (0, fs_1.writeFileSync)(fileName, resolvedCode);
+    }
+    /**
+     * Sends the code to the AI for a fix
+     */
+    async codeFix(fix) {
+        return new Promise(async (resolve, reject) => {
+            const fixStream = await stormClient_1.stormClient.createCodeFix(fix, []);
+            fixStream.on('data', (evt) => {
+                if (evt.type === 'CODE_FIX') {
+                    resolve(evt.payload.content);
+                }
+            });
+            fixStream.on('error', (err) => {
+                reject(err);
+            });
+            await fixStream.waitForDone();
+        });
     }
     /**
      * Emits the text-based files to the stream

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

@@ -100,6 +100,26 @@ export interface StormEventError {
         error: string;
     };
 }
+export interface StormEventErrorClassifier {
+    type: 'ERROR_CLASSIFIER';
+    reason: string;
+    created: number;
+    payload: StormEventErrorClassifierInfo;
+}
+export interface StormEventCodeFix {
+    type: 'CODE_FIX';
+    reason: string;
+    created: number;
+    payload: {
+        filename: string;
+        content: string;
+    };
+}
+export interface StormEventErrorClassifierInfo {
+    error: string;
+    filename: string;
+    potentialFix: string;
+}
 export interface ScreenTemplate {
     name: string;
     template: string;
@@ -153,4 +173,4 @@ export interface StormEventDefinitionChange {
     created: number;
     payload: StormDefinitions;
 }
-export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventCreateDSLResource | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFile | StormEventDone | StormEventDefinitionChange;
+export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventCreateDSLResource | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFile | StormEventDone | StormEventDefinitionChange | StormEventErrorClassifier | StormEventCodeFix;

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

@@ -1,4 +1,4 @@
-import { StormFileImplementationPrompt, StormStream, StormUIImplementationPrompt } from './stream';
+import { ConversationItem, StormFileImplementationPrompt, StormStream, StormUIImplementationPrompt } from './stream';
 export declare const STORM_ID = "storm";
 export declare const ConversationIdHeader = "Conversation-Id";
 declare class StormClient {
@@ -9,6 +9,8 @@ declare class StormClient {
     createMetadata(prompt: string, 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>;
+    createCodeFix(prompt: string, history?: ConversationItem[], conversationId?: string): Promise<StormStream>;
 }
 export declare const stormClient: StormClient;
 export {};

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

@@ -83,5 +83,17 @@ class StormClient {
             conversationId,
         });
     }
+    createErrorClassification(prompt, history, conversationId) {
+        return this.send('/v2/code/errorclassifier', {
+            conversationId: conversationId,
+            prompt,
+        });
+    }
+    createCodeFix(prompt, history, conversationId) {
+        return this.send('/v2/code/fix', {
+            conversationId: conversationId,
+            prompt,
+        });
+    }
 }
 exports.stormClient = new StormClient();

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

@@ -22,6 +22,13 @@ export declare class StormCodegen {
      * Generates the code for a block and sends it to the AI
      */
     private processBlockCode;
+    private verifyAndFixCode;
+    removePrefix(prefix: string, str: string): string;
+    writeToFile(fileName: string, code: Promise<string>): Promise<void>;
+    /**
+     * Sends the code to the AI for a fix
+     */
+    private codeFix;
     /**
      * Emits the text-based files to the stream
      */

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

@@ -39,6 +39,7 @@ const stream_1 = require("./stream");
 const promises_1 = require("fs/promises");
 const path_1 = __importStar(require("path"));
 const node_os_1 = __importDefault(require("node:os"));
+const fs_1 = require("fs");
 class StormCodegen {
     userPrompt;
     blocks;
@@ -154,6 +155,89 @@ class StormCodegen {
             const filePath = (0, path_1.join)(basePath, uiFile.filename);
             await (0, promises_1.writeFile)(filePath, uiFile.content);
         }
+        const filesToBeFixed = serviceFiles.concat(contextFiles);
+        const codeGenerator = new codegen_1.BlockCodeGenerator(block.content);
+        await this.verifyAndFixCode(codeGenerator, basePath, filesToBeFixed, allFiles);
+    }
+    async verifyAndFixCode(codeGenerator, basePath, filesToBeFixed, knownFiles) {
+        let attempts = 0;
+        let validCode = false;
+        for (let i = 0; i <= 3; i++) {
+            attempts++;
+            try {
+                console.log(`Validating the code in ${basePath} attempt #${attempts}`);
+                const result = await codeGenerator.validateForTarget(basePath);
+                if (result && result.valid) {
+                    validCode = true;
+                    break;
+                }
+                if (result && !result.valid) {
+                    console.debug('Validation error:', result);
+                    const errorStream = await stormClient_1.stormClient.createErrorClassification(result.error, []);
+                    const fixes = new Map();
+                    errorStream.on('data', (evt) => {
+                        if (evt.type === 'ERROR_CLASSIFIER') {
+                            // find the file that caused the error
+                            // strip base path from event file name, if it exists sometimes the AI sends the full path
+                            const eventFileName = this.removePrefix(basePath + '/', evt.payload.filename);
+                            const file = filesToBeFixed.find((f) => f.filename === eventFileName);
+                            if (!file) {
+                                console.log(`Could not find the file ${eventFileName} in the list of files to be fixed, Henrik might wanna create a new file for this fix`);
+                            }
+                            // read the content of the file
+                            const content = (0, fs_1.readFileSync)((0, path_1.join)(basePath, eventFileName), 'utf8');
+                            const fix = `${evt.payload.potentialFix}\n---\n${knownFiles.map(e => e.filename).join("\n")}\n---\n${content}`;
+                            console.log(`trying to fix the code in ${eventFileName}`);
+                            console.debug(`with the fix:\n${fix}`);
+                            const code = this.codeFix(fix);
+                            fixes.set((0, path_1.join)(basePath, eventFileName), code);
+                        }
+                    });
+                    await errorStream.waitForDone();
+                    for (const [filename, codePromise] of fixes) {
+                        const code = await codePromise;
+                        (0, fs_1.writeFileSync)(filename, code);
+                    }
+                }
+            }
+            catch (e) {
+                console.error('Error:', e);
+            }
+        }
+        if (validCode) {
+            console.log(`Validation successful after ${attempts} attempts`);
+        }
+        else {
+            console.error(`Validation failed for ${basePath} after ${attempts} attempts`);
+        }
+    }
+    removePrefix(prefix, str) {
+        if (str.startsWith(prefix)) {
+            return str.slice(prefix.length);
+        }
+        return str;
+    }
+    async writeToFile(fileName, code) {
+        console.log(`writing the fixed code to ${fileName}`);
+        const resolvedCode = await code;
+        (0, fs_1.writeFileSync)(fileName, resolvedCode);
+    }
+    /**
+     * Sends the code to the AI for a fix
+     */
+    async codeFix(fix) {
+        return new Promise(async (resolve, reject) => {
+            const fixStream = await stormClient_1.stormClient.createCodeFix(fix, []);
+            fixStream.on('data', (evt) => {
+                if (evt.type === 'CODE_FIX') {
+                    resolve(evt.payload.content);
+                }
+            });
+            fixStream.on('error', (err) => {
+                reject(err);
+            });
+            await fixStream.waitForDone();
+        });
     }
     /**
      * Emits the text-based files to the stream

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

@@ -100,6 +100,26 @@ export interface StormEventError {
         error: string;
     };
 }
+export interface StormEventErrorClassifier {
+    type: 'ERROR_CLASSIFIER';
+    reason: string;
+    created: number;
+    payload: StormEventErrorClassifierInfo;
+}
+export interface StormEventCodeFix {
+    type: 'CODE_FIX';
+    reason: string;
+    created: number;
+    payload: {
+        filename: string;
+        content: string;
+    };
+}
+export interface StormEventErrorClassifierInfo {
+    error: string;
+    filename: string;
+    potentialFix: string;
+}
 export interface ScreenTemplate {
     name: string;
     template: string;
@@ -153,4 +173,4 @@ export interface StormEventDefinitionChange {
     created: number;
     payload: StormDefinitions;
 }
-export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventCreateDSLResource | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFile | StormEventDone | StormEventDefinitionChange;
+export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventCreateDSLResource | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFile | StormEventDone | StormEventDefinitionChange | StormEventErrorClassifier | StormEventCodeFix;

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

@@ -1,4 +1,4 @@
-import { StormFileImplementationPrompt, StormStream, StormUIImplementationPrompt } from './stream';
+import { ConversationItem, StormFileImplementationPrompt, StormStream, StormUIImplementationPrompt } from './stream';
 export declare const STORM_ID = "storm";
 export declare const ConversationIdHeader = "Conversation-Id";
 declare class StormClient {
@@ -9,6 +9,8 @@ declare class StormClient {
     createMetadata(prompt: string, 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>;
+    createCodeFix(prompt: string, history?: ConversationItem[], conversationId?: string): Promise<StormStream>;
 }
 export declare const stormClient: StormClient;
 export {};

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

@@ -83,5 +83,17 @@ class StormClient {
             conversationId,
         });
     }
+    createErrorClassification(prompt, history, conversationId) {
+        return this.send('/v2/code/errorclassifier', {
+            conversationId: conversationId,
+            prompt,
+        });
+    }
+    createCodeFix(prompt, history, conversationId) {
+        return this.send('/v2/code/fix', {
+            conversationId: conversationId,
+            prompt,
+        });
+    }
 }
 exports.stormClient = new StormClient();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.48.4",
+    "version": "0.48.5",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {

package/src/storm/codegen.ts

@@ -4,7 +4,7 @@
  */
 
 import { Definition } from '@kapeta/local-cluster-config';
-import { AIFileTypes, BlockCodeGenerator, CodeWriter, GeneratedFile, GeneratedResult } from '@kapeta/codegen';
+import { AIFileTypes, BlockCodeGenerator, CodeGenerator, CodeWriter, GeneratedFile, GeneratedResult } from '@kapeta/codegen';
 import { BlockDefinition } from '@kapeta/schemas';
 import { codeGeneratorManager } from '../codeGeneratorManager';
 import { STORM_ID, stormClient } from './stormClient';
@@ -15,6 +15,7 @@ import { KapetaURI } from '@kapeta/nodejs-utils';
 import { writeFile } from 'fs/promises';
 import path, { join } from 'path';
 import os from 'node:os';
+import { readFile, readFileSync, writeFileSync } from 'fs';
 
 type ImplementationGenerator = (prompt: StormFileImplementationPrompt, conversationId?: string) => Promise<StormStream>;
 
@@ -163,6 +164,93 @@ export class StormCodegen {
             const filePath = join(basePath, uiFile.filename);
             await writeFile(filePath, uiFile.content);
         }
+
+        const filesToBeFixed = serviceFiles.concat(contextFiles);
+        const codeGenerator = new BlockCodeGenerator(block.content as BlockDefinition);
+        await this.verifyAndFixCode(codeGenerator, basePath, filesToBeFixed, allFiles);
+    }
+
+    private async verifyAndFixCode(codeGenerator: CodeGenerator, basePath: string, filesToBeFixed: StormFileInfo[], knownFiles: StormFileInfo[]) {
+        let attempts = 0;
+        let validCode = false;
+        for (let i = 0; i <= 3; i++) {
+            attempts++;
+            try {
+                console.log(`Validating the code in ${basePath} attempt #${attempts}`)
+                const result = await codeGenerator.validateForTarget(basePath);
+                if (result && result.valid) {
+                     validCode = true;
+                    break;
+                }
+
+                if (result && !result.valid) {
+                    console.debug('Validation error:', result);
+                    const errorStream = await stormClient.createErrorClassification(result.error, []);
+                    const fixes = new Map<string, Promise<string>>();
+
+                    errorStream.on('data', (evt) => {
+                        if (evt.type === 'ERROR_CLASSIFIER') {
+                            // find the file that caused the error
+                            // strip base path from event file name, if it exists sometimes the AI sends the full path
+                            const eventFileName = this.removePrefix(basePath+'/', evt.payload.filename);
+                            const file = filesToBeFixed.find((f) => f.filename === eventFileName);
+                            if(!file) {
+                                console.log(`Could not find the file ${eventFileName} in the list of files to be fixed, Henrik might wanna create a new file for this fix`);
+                            }
+                            // read the content of the file
+                            const content = readFileSync(join(basePath, eventFileName), 'utf8');
+                            const fix = `${evt.payload.potentialFix}\n---\n${knownFiles.map(e => e.filename).join("\n")}\n---\n${content}`;
+                            console.log(`trying to fix the code in ${eventFileName}`);
+                            console.debug(`with the fix:\n${fix}`)
+                            const code = this.codeFix(fix);
+                            fixes.set(join(basePath, eventFileName), code);
+                        }
+                    });
+
+                    await errorStream.waitForDone();
+                    for (const [filename, codePromise] of fixes) {
+                        const code = await codePromise;
+                        writeFileSync(filename, code);
+                    }
+                }
+            } catch (e) {
+                console.error('Error:', e);
+            }
+        }
+        if (validCode) {
+            console.log(`Validation successful after ${attempts} attempts`);
+        } else {
+            console.error(`Validation failed for ${basePath} after ${attempts} attempts`);
+        }
+    }
+
+    removePrefix(prefix: string, str: string): string {
+        if (str.startsWith(prefix)) {
+          return str.slice(prefix.length);
+        }
+        return str;
+    }
+    async writeToFile(fileName: string, code: Promise<string>) {
+        console.log(`writing the fixed code to ${fileName}`);
+        const resolvedCode = await code;
+        writeFileSync(fileName, resolvedCode);
+    }
+    /**
+     * Sends the code to the AI for a fix
+     */
+    private async codeFix(fix: string): Promise<string> {
+        return new Promise<string>(async (resolve, reject) => {
+            const fixStream = await stormClient.createCodeFix(fix, []);
+            fixStream.on('data', (evt) => {
+                if (evt.type === 'CODE_FIX') {
+                    resolve(evt.payload.content);
+                }
+            });
+            fixStream.on('error', (err) => {
+                reject(err);
+            });
+            await fixStream.waitForDone();
+        });
     }
 
     /**

package/src/storm/events.ts

@@ -127,6 +127,28 @@ export interface StormEventError {
     };
 }
 
+export interface StormEventErrorClassifier {
+    type: 'ERROR_CLASSIFIER';
+    reason: string;
+    created: number;
+    payload: StormEventErrorClassifierInfo;
+}
+
+export interface StormEventCodeFix {
+    type: 'CODE_FIX';
+    reason: string;
+    created: number;
+    payload: {
+        filename: string;
+        content: string;
+    };
+}
+export interface StormEventErrorClassifierInfo {
+    error: string,
+    filename: string,
+    potentialFix: string
+}
+
 export interface ScreenTemplate {
     name: string;
     template: string;
@@ -199,4 +221,6 @@ export type StormEvent =
     | StormEventScreenCandidate
     | StormEventFile
     | StormEventDone
-    | StormEventDefinitionChange;
+    | StormEventDefinitionChange
+    | StormEventErrorClassifier
+    | StormEventCodeFix;

package/src/storm/stormClient.ts

@@ -10,7 +10,6 @@ import {
     ConversationItem,
     StormContextRequest,
     StormFileImplementationPrompt,
-    StormFileInfo,
     StormStream,
     StormUIImplementationPrompt,
 } from './stream';
@@ -111,6 +110,19 @@ class StormClient {
             conversationId,
         });
     }
+
+    public createErrorClassification(prompt: string, history?: ConversationItem[], conversationId?: string) {
+        return this.send('/v2/code/errorclassifier', {
+            conversationId: conversationId,
+            prompt,
+        });
+    }
+    public createCodeFix(prompt: string, history?: ConversationItem[], conversationId?: string) {
+        return this.send('/v2/code/fix', {
+            conversationId: conversationId,
+            prompt,
+        });
+    }
 }
 
 export const stormClient = new StormClient();