@kapeta/local-cluster-service 0.48.5 → 0.49.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [0.49.0](https://github.com/kapetacom/local-cluster-service/compare/v0.48.5...v0.49.0) (2024-06-05)
+
+
+### Features
+
+* Implement ability to save ai generated plan ([#161](https://github.com/kapetacom/local-cluster-service/issues/161)) ([8223757](https://github.com/kapetacom/local-cluster-service/commit/8223757ff90ee6b5e1b7f171fc724d9877051df2))
+
 ## [0.48.5](https://github.com/kapetacom/local-cluster-service/compare/v0.48.4...v0.48.5) (2024-06-04)
 
 

package/dist/cjs/src/assetManager.d.ts

@@ -28,7 +28,7 @@ declare class AssetManager {
     getPlan(ref: string, noCache?: boolean): Promise<Plan>;
     getBlockInstance(systemId: string, instanceId: string): Promise<BlockInstance>;
     getAsset(ref: string, noCache?: boolean, autoFetch?: boolean): Promise<EnrichedAsset | undefined>;
-    createAsset(path: string, yaml: BlockDefinition, sourceOfChange?: SourceOfChange): Promise<EnrichedAsset[]>;
+    createAsset(path: string, yaml: BlockDefinition, sourceOfChange?: SourceOfChange, codegen?: boolean): Promise<EnrichedAsset[]>;
     updateAsset(ref: string, yaml: Definition, sourceOfChange?: SourceOfChange): Promise<void>;
     importFile(filePath: string): Promise<EnrichedAsset[]>;
     unregisterAsset(ref: string): Promise<void>;

package/dist/cjs/src/assetManager.js

@@ -142,7 +142,7 @@ class AssetManager {
         }
         return undefined;
     }
-    async createAsset(path, yaml, sourceOfChange = 'filesystem') {
+    async createAsset(path, yaml, sourceOfChange = 'filesystem', codegen = true) {
         if (await fs_extra_1.default.pathExists(path)) {
             throw new Error('File already exists: ' + path);
         }
@@ -159,9 +159,11 @@ class AssetManager {
             cacheManager_1.cacheManager.set(key, a, CACHE_TTL);
         });
         definitionsManager_1.definitionsManager.clearCache();
-        console.log(`Created asset at: ${path}`);
         const ref = `kapeta://${yaml.metadata.name}:local`;
-        await this.maybeGenerateCode(ref, path, yaml);
+        console.log(`Created asset ${ref} at: ${path}`);
+        if (codegen) {
+            await this.maybeGenerateCode(ref, path, yaml);
+        }
         return asset;
     }
     async updateAsset(ref, yaml, sourceOfChange = 'filesystem') {

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

@@ -11,6 +11,7 @@ const express_promise_router_1 = __importDefault(require("express-promise-router
 const stringBody_1 = require("../middleware/stringBody");
 const filesystemManager_1 = require("../filesystemManager");
 const cors_1 = require("../middleware/cors");
+const fs_extra_1 = __importDefault(require("fs-extra"));
 let router = (0, express_promise_router_1.default)();
 router.use('/', cors_1.corsHandler);
 router.get('/root', (req, res) => {
@@ -81,6 +82,15 @@ router.get('/readfile', async (req, res) => {
         res.status(400).send({ error: '' + err });
     }
 });
+router.get('/exists', async (req, res) => {
+    let pathArg = req.query.path;
+    try {
+        res.send(await fs_extra_1.default.pathExists(pathArg));
+    }
+    catch (err) {
+        res.status(400).send({ error: '' + err });
+    }
+});
 router.put('/mkdir', async (req, res) => {
     let pathArg = req.query.path;
     try {

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

@@ -11,7 +11,8 @@ export declare class StormCodegen {
     private readonly out;
     private readonly events;
     private readonly tmpDir;
-    constructor(userPrompt: string, blocks: BlockDefinitionInfo[], events: StormEvent[]);
+    private readonly conversationId;
+    constructor(conversationId: string, userPrompt: string, blocks: BlockDefinitionInfo[], events: StormEvent[]);
     process(): Promise<void>;
     getStream(): StormStream;
     private handleTemplateFileOutput;

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

@@ -36,26 +36,31 @@ const codeGeneratorManager_1 = require("../codeGeneratorManager");
 const stormClient_1 = require("./stormClient");
 const event_parser_1 = require("./event-parser");
 const stream_1 = require("./stream");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 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");
+const path_2 = __importDefault(require("path"));
 class StormCodegen {
     userPrompt;
     blocks;
     out = new stream_1.StormStream();
     events;
     tmpDir;
-    constructor(userPrompt, blocks, events) {
+    conversationId;
+    constructor(conversationId, userPrompt, blocks, events) {
         this.userPrompt = userPrompt;
         this.blocks = blocks;
         this.events = events;
-        this.tmpDir = node_os_1.default.tmpdir();
+        this.tmpDir = path_2.default.join(node_os_1.default.tmpdir(), conversationId);
+        this.conversationId = conversationId;
     }
     async process() {
-        for (const block of this.blocks) {
-            await this.processBlockCode(block);
-        }
+        const promises = this.blocks.map((block) => {
+            return this.processBlockCode(block);
+        });
+        await Promise.all(promises);
         this.out.end();
     }
     getStream() {
@@ -119,7 +124,7 @@ class StormCodegen {
         }
         const allFiles = this.toStormFiles(generatedResult);
         // Send all the non-ai files to the stream
-        this.emitFiles(block.uri, block.aiName, allFiles);
+        this.emitFiles((0, nodejs_utils_1.parseKapetaUri)(block.uri), block.aiName, 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) {
@@ -131,7 +136,7 @@ class StormCodegen {
                 prompt: this.userPrompt,
             });
             uiStream.on('data', (evt) => {
-                this.handleUiOutput(block.uri, block.aiName, evt);
+                this.handleUiOutput((0, nodejs_utils_1.parseKapetaUri)(block.uri), block.aiName, evt);
             });
             await uiStream.waitForDone();
         }
@@ -140,7 +145,7 @@ class StormCodegen {
         // 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, block.aiName, stormClient_1.stormClient.createServiceImplementation.bind(stormClient_1.stormClient), serviceFiles, contextFiles);
+            await this.processTemplates((0, nodejs_utils_1.parseKapetaUri)(block.uri), block.aiName, stormClient_1.stormClient.createServiceImplementation.bind(stormClient_1.stormClient), serviceFiles, contextFiles);
         }
         const basePath = this.getBasePath(block.content.metadata.name);
         for (const serviceFile of serviceFiles) {
@@ -158,6 +163,18 @@ class StormCodegen {
         const filesToBeFixed = serviceFiles.concat(contextFiles);
         const codeGenerator = new codegen_1.BlockCodeGenerator(block.content);
         await this.verifyAndFixCode(codeGenerator, basePath, filesToBeFixed, allFiles);
+        const blockRef = block.uri;
+        this.out.emit('data', {
+            type: 'BLOCK_READY',
+            reason: 'Block ready',
+            created: Date.now(),
+            payload: {
+                path: basePath,
+                blockName: block.aiName,
+                blockRef,
+                instanceId: event_parser_1.StormEventParser.toInstanceIdFromRef(blockRef),
+            },
+        });
     }
     async verifyAndFixCode(codeGenerator, basePath, filesToBeFixed, knownFiles) {
         let attempts = 0;
@@ -186,7 +203,9 @@ class StormCodegen {
                             }
                             // 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}`;
+                            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);

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

@@ -6,7 +6,7 @@ import { StormEvent } from './events';
 import { BlockDefinition, Plan } from '@kapeta/schemas';
 import { KapetaURI } from '@kapeta/nodejs-utils';
 export interface BlockDefinitionInfo {
-    uri: KapetaURI;
+    uri: string;
     content: BlockDefinition;
     aiName: string;
 }

package/dist/cjs/src/storm/event-parser.js

@@ -315,6 +315,8 @@ class StormEventParser {
                 name: planRef.fullName,
                 title: this.planName,
                 description: this.planDescription,
+                structure: 'mono',
+                visibility: 'private',
             },
             spec: {
                 blocks,
@@ -331,7 +333,7 @@ class StormEventParser {
         Object.entries(this.blocks).forEach(([, blockInfo]) => {
             const blockRef = StormEventParser.toRef(handle, blockInfo.name);
             const blockDefinitionInfo = {
-                uri: blockRef,
+                uri: blockRef.toNormalizedString(),
                 aiName: blockInfo.name,
                 content: {
                     kind: this.toBlockKind(blockInfo.type),

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

@@ -163,6 +163,17 @@ export interface StormEventFile {
         instanceId: string;
     };
 }
+export interface StormEventBlockReady {
+    type: 'BLOCK_READY';
+    reason: string;
+    created: number;
+    payload: {
+        path: string;
+        blockName: string;
+        blockRef: string;
+        instanceId: string;
+    };
+}
 export interface StormEventDone {
     type: 'DONE';
     created: number;
@@ -173,4 +184,4 @@ export interface StormEventDefinitionChange {
     created: number;
     payload: StormDefinitions;
 }
-export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventCreateDSLResource | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFile | StormEventDone | StormEventDefinitionChange | StormEventErrorClassifier | StormEventCodeFix;
+export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventCreateDSLResource | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFile | StormEventDone | StormEventDefinitionChange | StormEventErrorClassifier | StormEventCodeFix | StormEventBlockReady;

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

@@ -8,11 +8,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
 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 assetManager_1 = require("../assetManager");
+const path_1 = __importDefault(require("path"));
 const router = (0, express_promise_router_1.default)();
 router.use('/', cors_1.corsHandler);
 router.use('/', stringBody_1.stringBody);
@@ -47,7 +50,7 @@ router.post('/:handle/all', async (req, res) => {
         const result = eventParser.toResult(handle);
         sendDefinitions(res, result);
         if (!req.query.skipCodegen) {
-            const stormCodegen = new codegen_1.StormCodegen(aiRequest.prompt, result.blocks, eventParser.getEvents());
+            const stormCodegen = new codegen_1.StormCodegen(metaStream.getConversationId(), aiRequest.prompt, result.blocks, eventParser.getEvents());
             const codegenPromise = streamStormPartialResponse(stormCodegen.getStream(), res);
             await stormCodegen.process();
             await codegenPromise;
@@ -59,6 +62,28 @@ router.post('/:handle/all', async (req, res) => {
         res.end();
     }
 });
+router.post('/block/create', async (req, res) => {
+    const createRequest = JSON.parse(req.stringBody ?? '{}');
+    try {
+        const ymlPath = path_1.default.join(createRequest.newPath, 'kapeta.yml');
+        console.log('Creating block at', ymlPath);
+        const [asset] = await assetManager_1.assetManager.createAsset(ymlPath, createRequest.definition);
+        if (await fs_extra_1.default.pathExists(createRequest.tmpPath)) {
+            console.log('Moving block from', createRequest.tmpPath, 'to', createRequest.newPath);
+            await fs_extra_1.default.move(createRequest.tmpPath, createRequest.newPath, {
+                overwrite: true,
+            });
+            console.log('Updating asset', asset.ref);
+            res.send(await assetManager_1.assetManager.updateAsset(asset.ref, createRequest.definition));
+        }
+        else {
+            res.send(asset);
+        }
+    }
+    catch (err) {
+        res.status(500).send({ error: err.message });
+    }
+});
 function sendDefinitions(res, result) {
     sendEvent(res, {
         type: 'DEFINITION_CHANGE',

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

@@ -6,6 +6,7 @@
 import { EventEmitter } from 'node:events';
 import { StormEvent } from './events';
 import { AIFileTypes, GeneratedFile } from '@kapeta/codegen';
+import { BlockDefinition } from '@kapeta/schemas';
 export declare class StormStream extends EventEmitter {
     private conversationId;
     private lines;
@@ -29,6 +30,11 @@ export interface StormContextRequest<T = string> {
     conversationId?: string;
     prompt: T;
 }
+export interface StormCreateBlockRequest {
+    definition: BlockDefinition;
+    tmpPath: string;
+    newPath: string;
+}
 export interface StormFileInfo extends GeneratedFile {
     type: AIFileTypes;
 }

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

@@ -28,7 +28,7 @@ declare class AssetManager {
     getPlan(ref: string, noCache?: boolean): Promise<Plan>;
     getBlockInstance(systemId: string, instanceId: string): Promise<BlockInstance>;
     getAsset(ref: string, noCache?: boolean, autoFetch?: boolean): Promise<EnrichedAsset | undefined>;
-    createAsset(path: string, yaml: BlockDefinition, sourceOfChange?: SourceOfChange): Promise<EnrichedAsset[]>;
+    createAsset(path: string, yaml: BlockDefinition, sourceOfChange?: SourceOfChange, codegen?: boolean): Promise<EnrichedAsset[]>;
     updateAsset(ref: string, yaml: Definition, sourceOfChange?: SourceOfChange): Promise<void>;
     importFile(filePath: string): Promise<EnrichedAsset[]>;
     unregisterAsset(ref: string): Promise<void>;

package/dist/esm/src/assetManager.js

@@ -142,7 +142,7 @@ class AssetManager {
         }
         return undefined;
     }
-    async createAsset(path, yaml, sourceOfChange = 'filesystem') {
+    async createAsset(path, yaml, sourceOfChange = 'filesystem', codegen = true) {
         if (await fs_extra_1.default.pathExists(path)) {
             throw new Error('File already exists: ' + path);
         }
@@ -159,9 +159,11 @@ class AssetManager {
             cacheManager_1.cacheManager.set(key, a, CACHE_TTL);
         });
         definitionsManager_1.definitionsManager.clearCache();
-        console.log(`Created asset at: ${path}`);
         const ref = `kapeta://${yaml.metadata.name}:local`;
-        await this.maybeGenerateCode(ref, path, yaml);
+        console.log(`Created asset ${ref} at: ${path}`);
+        if (codegen) {
+            await this.maybeGenerateCode(ref, path, yaml);
+        }
         return asset;
     }
     async updateAsset(ref, yaml, sourceOfChange = 'filesystem') {

package/dist/esm/src/filesystem/routes.js

@@ -11,6 +11,7 @@ const express_promise_router_1 = __importDefault(require("express-promise-router
 const stringBody_1 = require("../middleware/stringBody");
 const filesystemManager_1 = require("../filesystemManager");
 const cors_1 = require("../middleware/cors");
+const fs_extra_1 = __importDefault(require("fs-extra"));
 let router = (0, express_promise_router_1.default)();
 router.use('/', cors_1.corsHandler);
 router.get('/root', (req, res) => {
@@ -81,6 +82,15 @@ router.get('/readfile', async (req, res) => {
         res.status(400).send({ error: '' + err });
     }
 });
+router.get('/exists', async (req, res) => {
+    let pathArg = req.query.path;
+    try {
+        res.send(await fs_extra_1.default.pathExists(pathArg));
+    }
+    catch (err) {
+        res.status(400).send({ error: '' + err });
+    }
+});
 router.put('/mkdir', async (req, res) => {
     let pathArg = req.query.path;
     try {

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

@@ -11,7 +11,8 @@ export declare class StormCodegen {
     private readonly out;
     private readonly events;
     private readonly tmpDir;
-    constructor(userPrompt: string, blocks: BlockDefinitionInfo[], events: StormEvent[]);
+    private readonly conversationId;
+    constructor(conversationId: string, userPrompt: string, blocks: BlockDefinitionInfo[], events: StormEvent[]);
     process(): Promise<void>;
     getStream(): StormStream;
     private handleTemplateFileOutput;

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

@@ -36,26 +36,31 @@ const codeGeneratorManager_1 = require("../codeGeneratorManager");
 const stormClient_1 = require("./stormClient");
 const event_parser_1 = require("./event-parser");
 const stream_1 = require("./stream");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 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");
+const path_2 = __importDefault(require("path"));
 class StormCodegen {
     userPrompt;
     blocks;
     out = new stream_1.StormStream();
     events;
     tmpDir;
-    constructor(userPrompt, blocks, events) {
+    conversationId;
+    constructor(conversationId, userPrompt, blocks, events) {
         this.userPrompt = userPrompt;
         this.blocks = blocks;
         this.events = events;
-        this.tmpDir = node_os_1.default.tmpdir();
+        this.tmpDir = path_2.default.join(node_os_1.default.tmpdir(), conversationId);
+        this.conversationId = conversationId;
     }
     async process() {
-        for (const block of this.blocks) {
-            await this.processBlockCode(block);
-        }
+        const promises = this.blocks.map((block) => {
+            return this.processBlockCode(block);
+        });
+        await Promise.all(promises);
         this.out.end();
     }
     getStream() {
@@ -119,7 +124,7 @@ class StormCodegen {
         }
         const allFiles = this.toStormFiles(generatedResult);
         // Send all the non-ai files to the stream
-        this.emitFiles(block.uri, block.aiName, allFiles);
+        this.emitFiles((0, nodejs_utils_1.parseKapetaUri)(block.uri), block.aiName, 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) {
@@ -131,7 +136,7 @@ class StormCodegen {
                 prompt: this.userPrompt,
             });
             uiStream.on('data', (evt) => {
-                this.handleUiOutput(block.uri, block.aiName, evt);
+                this.handleUiOutput((0, nodejs_utils_1.parseKapetaUri)(block.uri), block.aiName, evt);
             });
             await uiStream.waitForDone();
         }
@@ -140,7 +145,7 @@ class StormCodegen {
         // 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, block.aiName, stormClient_1.stormClient.createServiceImplementation.bind(stormClient_1.stormClient), serviceFiles, contextFiles);
+            await this.processTemplates((0, nodejs_utils_1.parseKapetaUri)(block.uri), block.aiName, stormClient_1.stormClient.createServiceImplementation.bind(stormClient_1.stormClient), serviceFiles, contextFiles);
         }
         const basePath = this.getBasePath(block.content.metadata.name);
         for (const serviceFile of serviceFiles) {
@@ -158,6 +163,18 @@ class StormCodegen {
         const filesToBeFixed = serviceFiles.concat(contextFiles);
         const codeGenerator = new codegen_1.BlockCodeGenerator(block.content);
         await this.verifyAndFixCode(codeGenerator, basePath, filesToBeFixed, allFiles);
+        const blockRef = block.uri;
+        this.out.emit('data', {
+            type: 'BLOCK_READY',
+            reason: 'Block ready',
+            created: Date.now(),
+            payload: {
+                path: basePath,
+                blockName: block.aiName,
+                blockRef,
+                instanceId: event_parser_1.StormEventParser.toInstanceIdFromRef(blockRef),
+            },
+        });
     }
     async verifyAndFixCode(codeGenerator, basePath, filesToBeFixed, knownFiles) {
         let attempts = 0;
@@ -186,7 +203,9 @@ class StormCodegen {
                             }
                             // 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}`;
+                            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);

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

@@ -6,7 +6,7 @@ import { StormEvent } from './events';
 import { BlockDefinition, Plan } from '@kapeta/schemas';
 import { KapetaURI } from '@kapeta/nodejs-utils';
 export interface BlockDefinitionInfo {
-    uri: KapetaURI;
+    uri: string;
     content: BlockDefinition;
     aiName: string;
 }

package/dist/esm/src/storm/event-parser.js

@@ -315,6 +315,8 @@ class StormEventParser {
                 name: planRef.fullName,
                 title: this.planName,
                 description: this.planDescription,
+                structure: 'mono',
+                visibility: 'private',
             },
             spec: {
                 blocks,
@@ -331,7 +333,7 @@ class StormEventParser {
         Object.entries(this.blocks).forEach(([, blockInfo]) => {
             const blockRef = StormEventParser.toRef(handle, blockInfo.name);
             const blockDefinitionInfo = {
-                uri: blockRef,
+                uri: blockRef.toNormalizedString(),
                 aiName: blockInfo.name,
                 content: {
                     kind: this.toBlockKind(blockInfo.type),

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

@@ -163,6 +163,17 @@ export interface StormEventFile {
         instanceId: string;
     };
 }
+export interface StormEventBlockReady {
+    type: 'BLOCK_READY';
+    reason: string;
+    created: number;
+    payload: {
+        path: string;
+        blockName: string;
+        blockRef: string;
+        instanceId: string;
+    };
+}
 export interface StormEventDone {
     type: 'DONE';
     created: number;
@@ -173,4 +184,4 @@ export interface StormEventDefinitionChange {
     created: number;
     payload: StormDefinitions;
 }
-export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventCreateDSLResource | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFile | StormEventDone | StormEventDefinitionChange | StormEventErrorClassifier | StormEventCodeFix;
+export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventCreateDSLResource | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFile | StormEventDone | StormEventDefinitionChange | StormEventErrorClassifier | StormEventCodeFix | StormEventBlockReady;

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

@@ -8,11 +8,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
 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 assetManager_1 = require("../assetManager");
+const path_1 = __importDefault(require("path"));
 const router = (0, express_promise_router_1.default)();
 router.use('/', cors_1.corsHandler);
 router.use('/', stringBody_1.stringBody);
@@ -47,7 +50,7 @@ router.post('/:handle/all', async (req, res) => {
         const result = eventParser.toResult(handle);
         sendDefinitions(res, result);
         if (!req.query.skipCodegen) {
-            const stormCodegen = new codegen_1.StormCodegen(aiRequest.prompt, result.blocks, eventParser.getEvents());
+            const stormCodegen = new codegen_1.StormCodegen(metaStream.getConversationId(), aiRequest.prompt, result.blocks, eventParser.getEvents());
             const codegenPromise = streamStormPartialResponse(stormCodegen.getStream(), res);
             await stormCodegen.process();
             await codegenPromise;
@@ -59,6 +62,28 @@ router.post('/:handle/all', async (req, res) => {
         res.end();
     }
 });
+router.post('/block/create', async (req, res) => {
+    const createRequest = JSON.parse(req.stringBody ?? '{}');
+    try {
+        const ymlPath = path_1.default.join(createRequest.newPath, 'kapeta.yml');
+        console.log('Creating block at', ymlPath);
+        const [asset] = await assetManager_1.assetManager.createAsset(ymlPath, createRequest.definition);
+        if (await fs_extra_1.default.pathExists(createRequest.tmpPath)) {
+            console.log('Moving block from', createRequest.tmpPath, 'to', createRequest.newPath);
+            await fs_extra_1.default.move(createRequest.tmpPath, createRequest.newPath, {
+                overwrite: true,
+            });
+            console.log('Updating asset', asset.ref);
+            res.send(await assetManager_1.assetManager.updateAsset(asset.ref, createRequest.definition));
+        }
+        else {
+            res.send(asset);
+        }
+    }
+    catch (err) {
+        res.status(500).send({ error: err.message });
+    }
+});
 function sendDefinitions(res, result) {
     sendEvent(res, {
         type: 'DEFINITION_CHANGE',

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

@@ -6,6 +6,7 @@
 import { EventEmitter } from 'node:events';
 import { StormEvent } from './events';
 import { AIFileTypes, GeneratedFile } from '@kapeta/codegen';
+import { BlockDefinition } from '@kapeta/schemas';
 export declare class StormStream extends EventEmitter {
     private conversationId;
     private lines;
@@ -29,6 +30,11 @@ export interface StormContextRequest<T = string> {
     conversationId?: string;
     prompt: T;
 }
+export interface StormCreateBlockRequest {
+    definition: BlockDefinition;
+    tmpPath: string;
+    newPath: string;
+}
 export interface StormFileInfo extends GeneratedFile {
     type: AIFileTypes;
 }

package/package.json

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

package/src/assetManager.ts

@@ -179,7 +179,8 @@ class AssetManager {
     async createAsset(
         path: string,
         yaml: BlockDefinition,
-        sourceOfChange: SourceOfChange = 'filesystem'
+        sourceOfChange: SourceOfChange = 'filesystem',
+        codegen: boolean = true
     ): Promise<EnrichedAsset[]> {
         if (await FS.pathExists(path)) {
             throw new Error('File already exists: ' + path);
@@ -199,11 +200,12 @@ class AssetManager {
         });
 
         definitionsManager.clearCache();
-        console.log(`Created asset at: ${path}`);
-
         const ref = `kapeta://${yaml.metadata.name}:local`;
+        console.log(`Created asset ${ref} at: ${path}`);
 
-        await this.maybeGenerateCode(ref, path, yaml);
+        if (codegen) {
+            await this.maybeGenerateCode(ref, path, yaml);
+        }
 
         return asset;
     }

package/src/filesystem/routes.ts

@@ -8,6 +8,7 @@ import { stringBody, StringBodyRequest } from '../middleware/stringBody';
 import { filesystemManager } from '../filesystemManager';
 import { corsHandler } from '../middleware/cors';
 import { NextFunction, Request, Response } from 'express';
+import FS from 'fs-extra';
 
 let router = Router();
 
@@ -99,6 +100,15 @@ router.get('/readfile', async (req: Request, res: Response) => {
     }
 });
 
+router.get('/exists', async (req: Request, res: Response) => {
+    let pathArg = req.query.path as string;
+    try {
+        res.send(await FS.pathExists(pathArg));
+    } catch (err) {
+        res.status(400).send({ error: '' + err });
+    }
+});
+
 router.put('/mkdir', async (req: Request, res: Response) => {
     let pathArg = req.query.path as string;
     try {

package/src/storm/codegen.ts

@@ -4,18 +4,26 @@
  */
 
 import { Definition } from '@kapeta/local-cluster-config';
-import { AIFileTypes, BlockCodeGenerator, CodeGenerator, 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';
 import { StormEvent, StormEventFile } from './events';
 import { BlockDefinitionInfo, StormEventParser } from './event-parser';
-import { ConversationItem, StormFileImplementationPrompt, StormFileInfo, StormStream } from './stream';
-import { KapetaURI } from '@kapeta/nodejs-utils';
+import { StormFileImplementationPrompt, StormFileInfo, StormStream } from './stream';
+import { KapetaURI, parseKapetaUri } 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';
+import Path from 'path';
 
 type ImplementationGenerator = (prompt: StormFileImplementationPrompt, conversationId?: string) => Promise<StormStream>;
 
@@ -25,19 +33,21 @@ export class StormCodegen {
     private readonly out = new StormStream();
     private readonly events: StormEvent[];
     private readonly tmpDir: string;
+    private readonly conversationId: string;
 
-    constructor(userPrompt: string, blocks: BlockDefinitionInfo[], events: StormEvent[]) {
+    constructor(conversationId: string, userPrompt: string, blocks: BlockDefinitionInfo[], events: StormEvent[]) {
         this.userPrompt = userPrompt;
         this.blocks = blocks;
         this.events = events;
-        this.tmpDir = os.tmpdir();
+        this.tmpDir = Path.join(os.tmpdir(), conversationId);
+        this.conversationId = conversationId;
     }
 
     public async process() {
-        for (const block of this.blocks) {
-            await this.processBlockCode(block);
-        }
-
+        const promises = this.blocks.map((block) => {
+            return this.processBlockCode(block);
+        });
+        await Promise.all(promises);
         this.out.end();
     }
 
@@ -109,7 +119,7 @@ export class StormCodegen {
         const allFiles = this.toStormFiles(generatedResult);
 
         // Send all the non-ai files to the stream
-        this.emitFiles(block.uri, block.aiName, allFiles);
+        this.emitFiles(parseKapetaUri(block.uri), block.aiName, allFiles);
 
         const relevantFiles: StormFileInfo[] = allFiles.filter(
             (file) => file.type !== AIFileTypes.IGNORE && file.type !== AIFileTypes.WEB_SCREEN
@@ -125,7 +135,7 @@ export class StormCodegen {
             });
 
             uiStream.on('data', (evt) => {
-                this.handleUiOutput(block.uri, block.aiName, evt);
+                this.handleUiOutput(parseKapetaUri(block.uri), block.aiName, evt);
             });
 
             await uiStream.waitForDone();
@@ -140,7 +150,7 @@ export class StormCodegen {
         const serviceFiles: StormFileInfo[] = allFiles.filter((file) => file.type === AIFileTypes.SERVICE);
         if (serviceFiles.length > 0) {
             await this.processTemplates(
-                block.uri,
+                parseKapetaUri(block.uri),
                 block.aiName,
                 stormClient.createServiceImplementation.bind(stormClient),
                 serviceFiles,
@@ -168,18 +178,36 @@ export class StormCodegen {
         const filesToBeFixed = serviceFiles.concat(contextFiles);
         const codeGenerator = new BlockCodeGenerator(block.content as BlockDefinition);
         await this.verifyAndFixCode(codeGenerator, basePath, filesToBeFixed, allFiles);
+
+        const blockRef = block.uri;
+        this.out.emit('data', {
+            type: 'BLOCK_READY',
+            reason: 'Block ready',
+            created: Date.now(),
+            payload: {
+                path: basePath,
+                blockName: block.aiName,
+                blockRef,
+                instanceId: StormEventParser.toInstanceIdFromRef(blockRef),
+            },
+        } satisfies StormEvent);
     }
 
-    private async verifyAndFixCode(codeGenerator: CodeGenerator, basePath: string, filesToBeFixed: StormFileInfo[], knownFiles: StormFileInfo[]) {
+    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}`)
+                console.log(`Validating the code in ${basePath} attempt #${attempts}`);
                 const result = await codeGenerator.validateForTarget(basePath);
                 if (result && result.valid) {
-                     validCode = true;
+                    validCode = true;
                     break;
                 }
 
@@ -192,16 +220,20 @@ export class StormCodegen {
                         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 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`);
+                            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}`;
+                            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}`)
+                            console.debug(`with the fix:\n${fix}`);
                             const code = this.codeFix(fix);
                             fixes.set(join(basePath, eventFileName), code);
                         }
@@ -226,7 +258,7 @@ export class StormCodegen {
 
     removePrefix(prefix: string, str: string): string {
         if (str.startsWith(prefix)) {
-          return str.slice(prefix.length);
+            return str.slice(prefix.length);
         }
         return str;
     }

package/src/storm/event-parser.ts

@@ -29,7 +29,7 @@ import { v5 as uuid } from 'uuid';
 import { definitionsManager } from '../definitionsManager';
 
 export interface BlockDefinitionInfo {
-    uri: KapetaURI;
+    uri: string;
     content: BlockDefinition;
     aiName: string;
 }
@@ -454,6 +454,8 @@ export class StormEventParser {
                 name: planRef.fullName,
                 title: this.planName,
                 description: this.planDescription,
+                structure: 'mono',
+                visibility: 'private',
             },
             spec: {
                 blocks,
@@ -474,7 +476,7 @@ export class StormEventParser {
             const blockRef = StormEventParser.toRef(handle, blockInfo.name);
 
             const blockDefinitionInfo: BlockDefinitionInfo = {
-                uri: blockRef,
+                uri: blockRef.toNormalizedString(),
                 aiName: blockInfo.name,
                 content: {
                     kind: this.toBlockKind(blockInfo.type),

package/src/storm/events.ts

@@ -144,9 +144,9 @@ export interface StormEventCodeFix {
     };
 }
 export interface StormEventErrorClassifierInfo {
-    error: string,
-    filename: string,
-    potentialFix: string
+    error: string;
+    filename: string;
+    potentialFix: string;
 }
 
 export interface ScreenTemplate {
@@ -196,6 +196,18 @@ export interface StormEventFile {
     };
 }
 
+export interface StormEventBlockReady {
+    type: 'BLOCK_READY';
+    reason: string;
+    created: number;
+    payload: {
+        path: string;
+        blockName: string;
+        blockRef: string;
+        instanceId: string;
+    };
+}
+
 export interface StormEventDone {
     type: 'DONE';
     created: number;
@@ -223,4 +235,5 @@ export type StormEvent =
     | StormEventDone
     | StormEventDefinitionChange
     | StormEventErrorClassifier
-    | StormEventCodeFix;
+    | StormEventCodeFix
+    | StormEventBlockReady;

package/src/storm/routes.ts

@@ -4,15 +4,19 @@
  */
 
 import Router from 'express-promise-router';
+import FS from 'fs-extra';
 import { Response } from 'express';
 import { corsHandler } from '../middleware/cors';
 import { stringBody } from '../middleware/stringBody';
 import { KapetaBodyRequest } from '../types';
-import { StormContextRequest, StormFileImplementationPrompt, StormFileInfo, StormStream } from './stream';
+import { StormContextRequest, StormCreateBlockRequest, StormStream } from './stream';
 import { ConversationIdHeader, stormClient } from './stormClient';
 import { StormEvent } from './events';
 import { resolveOptions, StormDefinitions, StormEventParser } from './event-parser';
 import { StormCodegen } from './codegen';
+import { assetManager } from '../assetManager';
+import Path from 'path';
+import { normalizeKapetaUri } from '@kapeta/nodejs-utils';
 
 const router = Router();
 
@@ -62,7 +66,12 @@ router.post('/:handle/all', async (req: KapetaBodyRequest, res: Response) => {
         sendDefinitions(res, result);
 
         if (!req.query.skipCodegen) {
-            const stormCodegen = new StormCodegen(aiRequest.prompt, result.blocks, eventParser.getEvents());
+            const stormCodegen = new StormCodegen(
+                metaStream.getConversationId(),
+                aiRequest.prompt,
+                result.blocks,
+                eventParser.getEvents()
+            );
 
             const codegenPromise = streamStormPartialResponse(stormCodegen.getStream(), res);
 
@@ -78,6 +87,34 @@ router.post('/:handle/all', async (req: KapetaBodyRequest, res: Response) => {
     }
 });
 
+router.post('/block/create', async (req: KapetaBodyRequest, res: Response) => {
+    const createRequest: StormCreateBlockRequest = JSON.parse(req.stringBody ?? '{}');
+
+    try {
+        const ymlPath = Path.join(createRequest.newPath, 'kapeta.yml');
+
+        console.log('Creating block at', ymlPath);
+
+        const [asset] = await assetManager.createAsset(ymlPath, createRequest.definition);
+
+        if (await FS.pathExists(createRequest.tmpPath)) {
+            console.log('Moving block from', createRequest.tmpPath, 'to', createRequest.newPath);
+
+            await FS.move(createRequest.tmpPath, createRequest.newPath, {
+                overwrite: true,
+            });
+
+            console.log('Updating asset', asset.ref);
+
+            res.send(await assetManager.updateAsset(asset.ref, createRequest.definition));
+        } else {
+            res.send(asset);
+        }
+    } catch (err: any) {
+        res.status(500).send({ error: err.message });
+    }
+});
+
 function sendDefinitions(res: Response, result: StormDefinitions) {
     sendEvent(res, {
         type: 'DEFINITION_CHANGE',

package/src/storm/stream.ts

@@ -5,6 +5,7 @@
 import { EventEmitter } from 'node:events';
 import { StormEvent } from './events';
 import { AIFileTypes, GeneratedFile } from '@kapeta/codegen';
+import { BlockDefinition } from '@kapeta/schemas';
 
 export class StormStream extends EventEmitter {
     private conversationId: string = '';
@@ -73,6 +74,12 @@ export interface StormContextRequest<T = string> {
     prompt: T;
 }
 
+export interface StormCreateBlockRequest {
+    definition: BlockDefinition;
+    tmpPath: string;
+    newPath: string;
+}
+
 export interface StormFileInfo extends GeneratedFile {
     type: AIFileTypes;
 }