@futurebrand/dev-tools 2.5.2 → 2.5.4

package/dist/commands/ai/add.js

@@ -19,28 +19,52 @@ const addCommand = new commander_1.Command('add')
         return;
     }
     const isAll = options.all === true;
-    const choices = state.getAvailableBlocksNames({
-        hidden: isAll ? undefined : false,
-        generated: true,
-    });
-    if (!choices.length) {
-        console.error('No blocks available to add');
-        return;
-    }
-    const blockQuery = await inquirer_1.default.prompt([
+    const projects = state
+        .getData()
+        .projects.filter((p) => p.type === 'strapi' || p.type === 'next.js');
+    const userQuery = await inquirer_1.default.prompt([
+        {
+            type: 'select',
+            name: 'project',
+            message: 'Select the project to generate',
+            choices: projects.map((p) => ({
+                name: `${p.name} (${p.type})`,
+                value: p.name,
+            })),
+        },
         {
             type: 'select',
             name: 'block',
             message: 'Select the block to add',
-            choices,
+            choices: async ({ project }) => {
+                const projectData = projects.find((p) => p.name === project);
+                if (!projectData) {
+                    return [];
+                }
+                const allBlocks = state.getAvailableBlocks({
+                    hidden: false,
+                });
+                const toGenerateBlocks = isAll
+                    ? allBlocks
+                    : await state.file.getAvailableBlocksToAdd(allBlocks, projectData);
+                if (!toGenerateBlocks.length) {
+                    throw new Error('No blocks available to generate');
+                }
+                return toGenerateBlocks.map((block) => block.name).sort();
+            },
         },
     ]);
-    const blocksToAdd = blockQuery.block;
+    const blocksToAdd = userQuery.block;
     if (!blocksToAdd) {
         console.error('No blocks selected');
         return;
     }
+    const project = projects.find((p) => p.name === userQuery.project);
+    if (!project) {
+        console.error('No project selected');
+        return;
+    }
     const projectAdder = new project_adder_1.default(state);
-    await projectAdder.addBlock(blocksToAdd);
+    await projectAdder.addBlock(blocksToAdd, project);
 });
 exports.default = addCommand;

package/dist/commands/ai/generate.js

@@ -18,31 +18,53 @@ const generateCommand = new commander_1.Command('generate')
         return;
     }
     const isAll = options.all === true;
-    const choices = state.getAvailableBlocksNames(isAll
-        ? {}
-        : {
-            hidden: false,
-            generated: false,
-        });
-    if (!choices.length) {
-        console.error('No blocks available to generate');
-        return;
-    }
-    const blockQuery = await inquirer_1.default.prompt([
+    const projects = state
+        .getData()
+        .projects.filter((p) => p.type === 'strapi' || p.type === 'next.js');
+    const userQuery = await inquirer_1.default.prompt([
+        {
+            type: 'select',
+            name: 'project',
+            message: 'Select the project to generate',
+            choices: projects.map((p) => ({
+                name: `${p.name} (${p.type})`,
+                value: p.name,
+            })),
+        },
         {
             type: 'checkbox',
             name: 'blocks',
             message: 'Select the blocks to generate',
-            choices,
+            choices: async ({ project }) => {
+                const projectData = projects.find((p) => p.name === project);
+                if (!projectData) {
+                    return [];
+                }
+                const allBlocks = state.getAvailableBlocks({
+                    hidden: false,
+                });
+                const toGenerateBlocks = isAll
+                    ? allBlocks
+                    : await state.file.getAvailableBlocksToGenerate(allBlocks, projectData);
+                if (!toGenerateBlocks.length) {
+                    throw new Error('No blocks available to generate');
+                }
+                return toGenerateBlocks.map((block) => block.name).sort();
+            },
         },
     ]);
-    const blocksToGenerate = blockQuery.blocks;
+    const blocksToGenerate = userQuery.blocks;
     if (!blocksToGenerate.length) {
         console.error('No blocks selected');
         return;
     }
+    const project = projects.find((p) => p.name === userQuery.project);
+    if (!project) {
+        console.error('No project selected');
+        return;
+    }
     const generator = new generator_1.Generator(state);
-    await generator.generateBlocks(blocksToGenerate);
+    await generator.generateBlocks(blocksToGenerate, project);
 });
 const generateStyleCommand = new commander_1.Command('styles')
     .alias('style')

package/dist/commands/ai/modules/figma/api.js

@@ -11,7 +11,7 @@ class FigmaAPI {
         return id;
     }
     async getVariables(pageId) {
-        const { variables } = await this.state.fetchApi(`/figma/${pageId}/blocks`);
+        const { variables } = await this.state.fetchApi(`/figma/${pageId}/variables`);
         return variables;
     }
     async getBlocks(pageId, canvasId) {

package/dist/commands/ai/modules/figma/index.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("node:path");
-const files_1 = require("../../../../utils/files");
 const inquirer_1 = require("inquirer");
-const generator_1 = require("../generator");
 const api_1 = require("./api");
 class FigmaModule {
     state;
@@ -25,24 +22,16 @@ class FigmaModule {
     async getDefaultCheckedBlocks(blocks) {
         const data = this.state.getData();
         const defaultBlocks = [];
-        const currentBlocks = data.blocks;
         const nextProject = data.projects.find((project) => project.type === 'next.js');
         for (const block of blocks) {
-            const inCurrentBlocks = currentBlocks.find((b) => b.name === block.name);
-            if (inCurrentBlocks) {
-                block.hidden = inCurrentBlocks.hidden;
-                block.generated = inCurrentBlocks.generated;
-            }
-            else {
-                const tempFolder = await (0, files_1.getTempFilePath)(generator_1.GENERATOR_FOLDER_NAME, block.name);
-                if (await (0, files_1.verifyPath)(tempFolder)) {
-                    block.generated = true;
+            if (nextProject) {
+                const alreadyGenerated = await this.state.file.verifyBlockAlreadyGenerated(block.name, nextProject);
+                if (alreadyGenerated) {
+                    continue;
                 }
-                if (nextProject) {
-                    const blockFolder = path.join(nextProject.path, 'layouts', 'blocks', block.name);
-                    if (await (0, files_1.verifyPath)(blockFolder)) {
-                        block.hidden = true;
-                    }
+                const alreadyExist = await this.state.file.verifyBlockAlreadyExists(nextProject, block.name);
+                if (alreadyExist) {
+                    continue;
                 }
             }
             if (!block.hidden) {

package/dist/commands/ai/modules/file-manager/index.d.ts

@@ -0,0 +1,22 @@
+import type { IProject } from '../../../../types/project';
+import type { IBlockData } from '../state/types';
+export declare const GENERATOR_FOLDER_NAME = "generated-blocks";
+export declare const GENERATOR_STRAPI_FILE_NAME = "strapi.json";
+export declare const GENERATOR_NEXTJS_FILE_NAME = "nextjs.tsx";
+declare class FileManager {
+    private getBlockTempPath;
+    private getBlockTempFilePath;
+    private getStrapiFolders;
+    private getNextjsBlockFolder;
+    private getBlockPath;
+    verifyBlockAlreadyGenerated(blockName: string, project: IProject): Promise<boolean>;
+    verifyBlockAlreadyExists(project: IProject, blockName: string): Promise<boolean>;
+    getAvailableBlocksToGenerate(blocks: IBlockData[], project: IProject): Promise<IBlockData[]>;
+    getAvailableBlocksToAdd(blocks: IBlockData[], project: IProject): Promise<IBlockData[]>;
+    createBlockTempFolder(blockName: string): Promise<void>;
+    saveGeneratedBlock(blockName: string, project: IProject, content: any): Promise<void>;
+    loadGeneratedBlock(blockName: string, project: IProject): Promise<string>;
+    addNextBlockToProject(blockName: string, project: IProject): Promise<void>;
+    addStrapiBlockToProject(blockName: string, project: IProject): Promise<void>;
+}
+export default FileManager;

package/dist/commands/ai/modules/file-manager/index.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GENERATOR_NEXTJS_FILE_NAME = exports.GENERATOR_STRAPI_FILE_NAME = exports.GENERATOR_FOLDER_NAME = void 0;
+const fs = require("node:fs/promises");
+const path = require("node:path");
+const files_1 = require("../../../../utils/files");
+exports.GENERATOR_FOLDER_NAME = 'generated-blocks';
+exports.GENERATOR_STRAPI_FILE_NAME = 'strapi.json';
+exports.GENERATOR_NEXTJS_FILE_NAME = 'nextjs.tsx';
+class FileManager {
+    async getBlockTempPath(blockName) {
+        const tempFolder = await (0, files_1.getTempFilePath)(exports.GENERATOR_FOLDER_NAME, blockName);
+        await (0, files_1.verifyAndCreateFolder)(tempFolder);
+        return tempFolder;
+    }
+    async getBlockTempFilePath(project, blockName) {
+        const tempFolder = await this.getBlockTempPath(blockName);
+        const projectType = typeof project === 'string' ? project : project.type;
+        if (projectType === 'strapi') {
+            return path.join(tempFolder, exports.GENERATOR_STRAPI_FILE_NAME);
+        }
+        if (projectType === 'next.js') {
+            return path.join(tempFolder, exports.GENERATOR_NEXTJS_FILE_NAME);
+        }
+        throw new Error(`Unsupported project type: ${projectType}`);
+    }
+    getStrapiFolders(project) {
+        if (project.type !== 'strapi') {
+            throw new Error('Project is not a Strapi project');
+        }
+        const srcPath = project.srcPath || path.join(project.path, 'src');
+        const componentsFolder = path.join(srcPath, 'components');
+        const blocksFolder = path.join(componentsFolder, 'blocks');
+        const blocksAssetsFolder = path.join(componentsFolder, 'blocks-assets');
+        return {
+            blocks: blocksFolder,
+            assets: blocksAssetsFolder,
+        };
+    }
+    getNextjsBlockFolder(project, blockName) {
+        if (project.type !== 'next.js') {
+            throw new Error('Project is not a Next.js project');
+        }
+        const blockFolder = path.join(project.srcPath || project.path, 'layouts', 'blocks', blockName);
+        return blockFolder;
+    }
+    getBlockPath(project, blockName) {
+        if (project.type === 'strapi') {
+            const folders = this.getStrapiFolders(project);
+            const jsonName = blockName.replace('block-', '');
+            return path.join(folders.blocks, `${jsonName}.json`);
+        }
+        if (project.type === 'next.js') {
+            const blockFolder = this.getNextjsBlockFolder(project, blockName);
+            return path.join(blockFolder, `${blockName}.tsx`);
+        }
+        throw new Error(`Unsupported project type: ${project.type}`);
+    }
+    async verifyBlockAlreadyGenerated(blockName, project) {
+        const blockPath = await this.getBlockTempFilePath(project, blockName);
+        return await (0, files_1.verifyPath)(blockPath);
+    }
+    async verifyBlockAlreadyExists(project, blockName) {
+        const blockPath = this.getBlockPath(project, blockName);
+        return await (0, files_1.verifyPath)(blockPath);
+    }
+    async getAvailableBlocksToGenerate(blocks, project) {
+        const toGenerateBlocks = [];
+        for (const block of blocks) {
+            const alreadyExists = await this.verifyBlockAlreadyExists(project, block.name);
+            if (alreadyExists) {
+                continue;
+            }
+            const alreadyGenerated = await this.verifyBlockAlreadyGenerated(block.name, project);
+            if (alreadyGenerated) {
+                continue;
+            }
+            toGenerateBlocks.push(block);
+        }
+        return toGenerateBlocks;
+    }
+    async getAvailableBlocksToAdd(blocks, project) {
+        const toAddBlocks = [];
+        for (const block of blocks) {
+            const alreadyExists = await this.verifyBlockAlreadyExists(project, block.name);
+            if (alreadyExists) {
+                continue;
+            }
+            const alreadyGenerated = await this.verifyBlockAlreadyGenerated(block.name, project);
+            if (alreadyGenerated) {
+                toAddBlocks.push(block);
+            }
+        }
+        return toAddBlocks;
+    }
+    async createBlockTempFolder(blockName) {
+        const tempFolder = await this.getBlockTempPath(blockName);
+        await (0, files_1.verifyAndCreateFolder)(tempFolder);
+    }
+    async saveGeneratedBlock(blockName, project, content) {
+        const blockPath = await this.getBlockTempFilePath(project, blockName);
+        const stringContent = typeof content === 'string' ? content : JSON.stringify(content, null, 2);
+        await fs.writeFile(blockPath, stringContent);
+    }
+    async loadGeneratedBlock(blockName, project) {
+        const blockPath = await this.getBlockTempFilePath(project, blockName);
+        if (!(await (0, files_1.verifyPath)(blockPath))) {
+            throw new Error(`Generated block not found: ${blockPath}`);
+        }
+        return (0, files_1.loadFile)(blockPath);
+    }
+    async addNextBlockToProject(blockName, project) {
+        if (project.type !== 'next.js') {
+            throw new Error('Project is not a Next.js project');
+        }
+        const generatedPath = await this.getBlockTempFilePath(project, blockName);
+        if (!(await (0, files_1.verifyPath)(generatedPath))) {
+            throw new Error(`Generated block not found: ${generatedPath}`);
+        }
+        const content = await (0, files_1.loadFile)(generatedPath);
+        const blockFolder = this.getNextjsBlockFolder(project, blockName);
+        await (0, files_1.verifyAndCreateFolder)(blockFolder);
+        const mainFilePath = path.join(blockFolder, `${blockName}.tsx`);
+        const indexFilePath = path.join(blockFolder, 'index.ts');
+        const indexContent = `export { default } from './${blockName}'
+`;
+        await fs.writeFile(mainFilePath, content);
+        await fs.writeFile(indexFilePath, indexContent);
+    }
+    async addStrapiBlockToProject(blockName, project) {
+        if (project.type !== 'strapi') {
+            throw new Error('Project is not a Strapi project');
+        }
+        const generatedPath = await this.getBlockTempFilePath(project, blockName);
+        if (!(await (0, files_1.verifyPath)(generatedPath))) {
+            throw new Error(`Generated block not found: ${generatedPath}`);
+        }
+        const content = await (0, files_1.loadFile)(generatedPath);
+        const blockData = JSON.parse(content);
+        const folders = this.getStrapiFolders(project);
+        await (0, files_1.verifyAndCreateFolder)(folders.blocks);
+        await (0, files_1.verifyAndCreateFolder)(folders.assets);
+        const blockNameClean = blockName.replace('block-', '');
+        const blockFilePath = path.join(folders.blocks, `${blockNameClean}.json`);
+        await fs.writeFile(blockFilePath, JSON.stringify(blockData.block, null, 2));
+        for (const asset of blockData.assets || []) {
+            const name = asset.info?.name;
+            if (!name) {
+                throw new Error(`Asset name is missing for block: ${blockName}`);
+            }
+            const assetFilePath = path.join(folders.assets, `${name}.json`);
+            await fs.writeFile(assetFilePath, JSON.stringify(asset, null, 2));
+        }
+    }
+}
+exports.default = FileManager;

package/dist/commands/ai/modules/file-manager/types.d.ts

@@ -0,0 +1,4 @@
+export interface IStrapiFolders {
+    blocks: string;
+    assets: string;
+}

package/dist/commands/ai/modules/file-manager/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/commands/ai/modules/generator/index.d.ts

@@ -1,5 +1,6 @@
 import type { IProject } from '../../../../types/project';
 import type AIState from '../state';
+import type { IStrapiGenerateResponse } from './types';
 export declare const GENERATOR_FOLDER_NAME = "generated-blocks";
 export declare const GENERATOR_STRAPI_FILE_NAME = "strapi.json";
 export declare const GENERATOR_NEXTJS_FILE_NAME = "nextjs.tsx";
@@ -7,11 +8,13 @@ export declare class Generator {
     private state;
     constructor(state: AIState);
     private get data();
-    private generateNextBlock;
-    private generateStrapiBlock;
+    private fetchNextBlock;
+    private fetchStrapiBlock;
     loadProjectCSS(nextProject?: IProject): Promise<string | null>;
-    generateBlock(blockName: string, strapiProject: IProject | null | undefined, nextProject: IProject | null | undefined, styles: string | null | undefined, onGenerateCallback: () => void): Promise<void>;
-    generateBlocks(blockNames: string[]): Promise<void>;
+    private generateStrapiBlock;
+    private generateNextBlock;
+    generateBlock(blockName: string, project: IProject): Promise<IStrapiGenerateResponse | undefined>;
+    generateBlocks(blockNames: string[], project: IProject): Promise<void>;
     generateStyles(): Promise<void>;
     generateChecklist(): Promise<void>;
 }

package/dist/commands/ai/modules/generator/index.js

@@ -16,7 +16,7 @@ class Generator {
     get data() {
         return this.state.getData();
     }
-    async generateNextBlock(blockName, blockVariants, variables, styles, strapiComponent) {
+    async fetchNextBlock(blockName, blockVariants, variables, styles, strapiComponent) {
         const requestBody = {
             name: blockName.replace('block-', ''),
             variants: blockVariants,
@@ -34,10 +34,9 @@ class Generator {
         if (!data.result?.block) {
             throw new Error('Next.js block generation failed');
         }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return data.result.block;
     }
-    async generateStrapiBlock(blockName, blockVariants) {
+    async fetchStrapiBlock(blockName, blockVariants) {
         const requestBody = {
             name: blockName.replace('block-', ''),
             variants: blockVariants,
@@ -52,14 +51,13 @@ class Generator {
         if (!data.result) {
             throw new Error('Strapi block generation failed');
         }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return data.result;
     }
     async loadProjectCSS(nextProject) {
         if (!nextProject) {
             return null;
         }
-        const cssFile = path.join(nextProject.path, 'styles', 'index.css');
+        const cssFile = path.join(nextProject.srcPath, 'styles', 'index.css');
         try {
             const css = await fs.readFile(cssFile, 'utf-8');
             if (!css) {
@@ -72,52 +70,53 @@ class Generator {
             return null;
         }
     }
-    async generateBlock(blockName, strapiProject, nextProject, styles, onGenerateCallback) {
+    async generateStrapiBlock(blockName, project, blockVariants) {
+        const isAlreadyGenerated = await this.state.file.verifyBlockAlreadyGenerated(blockName, project);
+        if (isAlreadyGenerated) {
+            const content = await this.state.file.loadGeneratedBlock(blockName, project);
+            return JSON.parse(content);
+        }
+        const response = await this.fetchStrapiBlock(blockName, blockVariants);
+        await this.state.file.saveGeneratedBlock(blockName, project, response);
+        return response;
+    }
+    async generateNextBlock(blockName, project, blockVariants) {
+        const strapiProject = this.data.projects.find((p) => p.type === 'strapi');
+        const strapiBlock = strapiProject
+            ? await this.generateStrapiBlock(blockName, strapiProject, blockVariants)
+            : undefined;
+        const styles = await this.loadProjectCSS(project);
+        const nextResponse = await this.fetchNextBlock(blockName, blockVariants, this.data.variables, styles, strapiBlock);
+        await this.state.file.saveGeneratedBlock(blockName, project, nextResponse);
+    }
+    async generateBlock(blockName, project) {
         try {
             const blockVariants = this.state.getBlockVariants(blockName);
-            const tempFolder = await (0, files_1.getTempFilePath)(exports.GENERATOR_FOLDER_NAME, blockName);
-            await (0, files_1.verifyAndCreateFolder)(tempFolder);
-            let strapiResponse = null;
-            if (strapiProject) {
-                strapiResponse = await this.generateStrapiBlock(blockName, blockVariants);
-                onGenerateCallback();
-                const cachePath = path.join(tempFolder, exports.GENERATOR_STRAPI_FILE_NAME);
-                await fs.writeFile(cachePath, JSON.stringify(strapiResponse, null, 2));
+            await this.state.file.createBlockTempFolder(blockName);
+            if (project.type === 'strapi') {
+                return this.generateStrapiBlock(blockName, project, blockVariants);
             }
-            if (nextProject) {
-                const nextResponse = await this.generateNextBlock(blockName, blockVariants, this.data.variables, styles, strapiResponse);
-                onGenerateCallback();
-                const cachePath = path.join(tempFolder, exports.GENERATOR_NEXTJS_FILE_NAME);
-                await fs.writeFile(cachePath, nextResponse);
+            if (project.type === 'next.js') {
+                await this.generateNextBlock(blockName, project, blockVariants);
             }
-            this.state.setBlockGenerated(blockName);
         }
         catch (error) {
             console.error(error);
         }
     }
-    async generateBlocks(blockNames) {
+    async generateBlocks(blockNames, project) {
         if (!blockNames.length) {
-            console.error('No blocks selected');
-            return;
+            throw new Error('No blocks to generate');
+        }
+        if (project.type !== 'strapi' && project.type !== 'next.js') {
+            throw new Error('Project type not supported');
         }
         console.log('- Generating Blocks... Please wait');
-        const strapiProject = this.data.projects.find((project) => project.type === 'strapi');
-        const nextProject = this.data.projects.find((project) => project.type === 'next.js');
-        const styles = await this.loadProjectCSS(nextProject);
         const progressBar = new cliProgress.SingleBar({}, cliProgress.Presets.legacy);
-        let length = 0;
-        if (strapiProject) {
-            length += blockNames.length;
-        }
-        if (nextProject) {
-            length += blockNames.length;
-        }
-        progressBar.start(length, 0);
+        progressBar.start(blockNames.length, 0);
         for (const block of blockNames) {
-            await this.generateBlock(block, strapiProject, nextProject, styles, () => {
-                progressBar.increment();
-            });
+            await this.generateBlock(block, project);
+            progressBar.increment();
         }
         progressBar.stop();
         await this.state.save();

package/dist/commands/ai/modules/generator/types.d.ts

@@ -0,0 +1,17 @@
+export interface IStrapiComponent {
+    collectionName: string;
+    info: {
+        name: string;
+        displayName: string;
+        description: string;
+    };
+    options: Record<string, unknown>;
+    attributes: Record<string, unknown>;
+}
+export interface IStrapiGenerateResponse {
+    block: IStrapiComponent;
+    assets: IStrapiComponent[];
+}
+export interface INextjsGenerateResponse {
+    block: string;
+}

package/dist/commands/ai/modules/generator/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/commands/ai/modules/project-adder/index.d.ts

@@ -1,10 +1,9 @@
+import type { IProject } from '../../../../types/project';
 import type AIState from '../state';
 declare class ProjectAdder {
     private state;
     constructor(state: AIState);
     private get data();
-    private createStrapiFiles;
-    private createNextjsFiles;
-    addBlock(blockName: string): Promise<void>;
+    addBlock(blockName: string, project: IProject): Promise<void>;
 }
 export default ProjectAdder;

package/dist/commands/ai/modules/project-adder/index.js

@@ -1,9 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const fs = require("node:fs/promises");
-const path = require("node:path");
-const files_1 = require("../../../../utils/files");
-const generator_1 = require("../generator");
 class ProjectAdder {
     state;
     constructor(state) {
@@ -12,67 +8,18 @@ class ProjectAdder {
     get data() {
         return this.state.getData();
     }
-    async createStrapiFiles(filePath, block) {
-        const strapiProject = this.data.projects.find((project) => project.type === 'strapi');
-        if (!strapiProject) {
-            throw new Error('Strapi project not found');
-            // return
-        }
-        const srcPath = strapiProject.srcPath || path.join(strapiProject.path, 'src');
-        const componentsFolder = path.join(srcPath, 'components');
-        const blocksFolder = path.join(componentsFolder, 'blocks');
-        const blocksAssetsFolder = path.join(componentsFolder, 'blocks-assets');
-        const strapiResult = await (0, files_1.loadJSONFile)(filePath);
-        const blockData = strapiResult.block;
-        const assets = strapiResult.assets;
-        await (0, files_1.verifyAndCreateFolder)(blocksFolder);
-        await (0, files_1.verifyAndCreateFolder)(blocksAssetsFolder);
-        for (const asset of assets) {
-            const name = asset.info?.name;
-            if (!name) {
-                console.warn('Asset name is missing, skipping asset creation');
-                continue;
-            }
-            await fs.writeFile(path.join(blocksAssetsFolder, `${name}.json`), JSON.stringify(asset, null, 2));
-        }
-        const blockName = block.name.replace('block-', '');
-        await fs.writeFile(path.join(blocksFolder, `${blockName}.json`), JSON.stringify(blockData, null, 2));
-    }
-    async createNextjsFiles(filePath, block) {
-        const project = this.data.projects.find((project) => project.type === 'next.js');
-        if (!project) {
-            throw new Error('Nextjs project not found');
-            // return
-        }
-        const blockFolder = path.join(project.srcPath || project.path, 'layouts', 'blocks', block.name);
-        await (0, files_1.verifyAndCreateFolder)(blockFolder);
-        const nextjsResult = await (0, files_1.loadFile)(filePath);
-        await fs.writeFile(path.join(blockFolder, `${block.name}.tsx`), nextjsResult);
-        const indexContent = `export { default } from './${block.name}'`;
-        await fs.writeFile(path.join(blockFolder, 'index.ts'), indexContent);
-    }
-    async addBlock(blockName) {
+    async addBlock(blockName, project) {
         const block = this.data.blocks.find((block) => block.name === blockName);
-        if (!block || !block.generated) {
+        if (!block) {
             console.error(`Block ${blockName} not found`);
             return;
         }
-        const strapiTempFilePath = await (0, files_1.getTempFilePath)(generator_1.GENERATOR_FOLDER_NAME, blockName, generator_1.GENERATOR_STRAPI_FILE_NAME);
-        const nextTempFilePath = await (0, files_1.getTempFilePath)(generator_1.GENERATOR_FOLDER_NAME, blockName, generator_1.GENERATOR_NEXTJS_FILE_NAME);
-        if (await (0, files_1.verifyPath)(strapiTempFilePath)) {
-            await this.createStrapiFiles(strapiTempFilePath, block);
-        }
-        else {
-            console.warn(`Strapi file for block ${blockName} not found in ${strapiTempFilePath}`);
-        }
-        if (await (0, files_1.verifyPath)(nextTempFilePath)) {
-            await this.createNextjsFiles(nextTempFilePath, block);
+        if (project.type === 'strapi') {
+            await this.state.file.addStrapiBlockToProject(block.name, project);
         }
-        else {
-            console.warn(`Next.js file for block ${blockName} not found in ${nextTempFilePath}`);
+        else if (project.type === 'next.js') {
+            await this.state.file.addNextBlockToProject(block.name, project);
         }
-        this.state.setBlockHidden(blockName, true);
-        await this.state.save();
         console.log(`Block ${blockName} added successfully`);
     }
 }

package/dist/commands/ai/modules/state/index.d.ts

@@ -1,8 +1,10 @@
+import FileManager from '../file-manager';
 import type { IAIFileState, IAvailableFilters } from './types';
 declare class AIState {
     private filePath;
     private data;
     private server;
+    file: FileManager;
     constructor();
     private createOptions;
     create(): Promise<void>;

package/dist/commands/ai/modules/state/index.js

@@ -4,13 +4,16 @@ const ai_server_module_1 = require("../../../../modules/ai-server-module");
 const project_1 = require("../../../../utils/project");
 const inquirer_1 = require("inquirer");
 const files_1 = require("../../../../utils/files");
+const file_manager_1 = require("../file-manager");
 const FILE_NAME = 'ai-state.json';
 class AIState {
     filePath = '';
     data = null;
     server;
+    file;
     constructor() {
         this.server = new ai_server_module_1.default();
+        this.file = new file_manager_1.default();
     }
     async createOptions() {
         const query = await inquirer_1.default.prompt([
@@ -94,9 +97,15 @@ class AIState {
         this.data.blocks = blocks;
     }
     setVariables(variables) {
+        if (!this.data) {
+            throw new Error('AI State not initialized');
+        }
         this.data.variables = variables;
     }
     setColors(colors) {
+        if (!this.data) {
+            throw new Error('AI State not initialized');
+        }
         this.data.colors = colors;
     }
     setBlockGenerated(blockName, generated = true) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@futurebrand/dev-tools",
-  "version": "2.5.2",
+  "version": "2.5.4",
   "description": "FutureBrand Dev Tools",
   "scripts": {
     "build": "tsc && tsc-alias",