@futurebrand/dev-tools 2.5.1 → 2.5.3

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/docs/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+declare const generateDOCSCommand: Command;
+export default generateDOCSCommand;

package/dist/commands/ai/docs/index.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const files_1 = require("../../../utils/files");
+const project_1 = require("../../../utils/project");
+const commander_1 = require("commander");
+const inquirer_1 = require("inquirer");
+const path = require("path");
+const generator_1 = require("./modules/generator");
+// import { Generator } from './modules/generator'
+// import AIState from './modules/state'
+const generateDOCSCommand = new commander_1.Command('docs')
+    .alias('doc')
+    .description('Ai Documentation Generate Command')
+    .action(async () => {
+    let projects = await (0, project_1.getProjects)();
+    if (!projects.length) {
+        console.error('No projects found');
+        return;
+    }
+    if (projects.length > 0) {
+        const projectQuery = await inquirer_1.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'projects',
+                message: 'Select the projects to generate documentation for',
+                choices: projects.map((project) => project.name),
+            },
+        ]);
+        projects = projects.filter((project) => projectQuery.projects.includes(project.name));
+    }
+    const generator = new generator_1.default();
+    const docs = [];
+    for (const project of projects) {
+        const categories = await (0, files_1.getDirectoriesInPath)(project.srcPath);
+        for (const category of categories) {
+            const categoryPath = path.join(project.srcPath, category);
+            const docsDirs = await (0, files_1.getDirectoriesInPath)(categoryPath);
+            if (!docsDirs.length) {
+                continue;
+            }
+            for (const doc of docsDirs) {
+                const docPath = path.join(categoryPath, doc);
+                const files = await (0, files_1.getFilesInPath)(docPath);
+                if (!files.length) {
+                    continue;
+                }
+                docs.push({
+                    project: project.name,
+                    name: doc,
+                    category,
+                    files,
+                    projectType: project.type,
+                });
+            }
+        }
+    }
+    console.log('Generating documentation...');
+    await generator.generate(docs);
+});
+exports.default = generateDOCSCommand;

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

@@ -0,0 +1,17 @@
+import type { IDocumentation } from '../../types';
+export interface IDocGeneratorResponse {
+    title: string;
+    description: string;
+    content: string;
+}
+declare class DocsGenerator {
+    private server;
+    constructor();
+    private generateDOCDocumentation;
+    private getDocTempDirectory;
+    private saveDocFile;
+    private verifyDocAlreadyExists;
+    private getDOCFileData;
+    generate(docs: IDocumentation[]): Promise<void>;
+}
+export default DocsGenerator;

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ai_server_module_1 = require("../../../../../modules/ai-server-module");
+const parallel_1 = require("../../../../../modules/parallel");
+const files_1 = require("../../../../../utils/files");
+const cliProgress = require("cli-progress");
+const fs = require("fs/promises");
+const path = require("path");
+const DOCS_TMP_FOLDER_NAME = 'docs';
+const NUM_OF_PARALLEL_REQUESTS = 5;
+class DocsGenerator {
+    server;
+    constructor() {
+        this.server = new ai_server_module_1.default();
+    }
+    async generateDOCDocumentation(doc, files) {
+        const { result } = await this.server.fetchApi('/generate/docs', {
+            method: 'POST',
+            body: JSON.stringify({
+                ...doc,
+                files,
+            }),
+        });
+        if (!result) {
+            throw new Error('Failed to generate documentation');
+        }
+        const fullContent = [
+            '---',
+            `title: "${result.title}"`,
+            `description: "${result.description}"`,
+            '---',
+            result.content,
+        ];
+        return fullContent.join('\n');
+    }
+    async getDocTempDirectory(doc) {
+        const projectFolder = doc.project.replace('@futurebrand/', '');
+        return (0, files_1.getTempFilePath)(DOCS_TMP_FOLDER_NAME, projectFolder, doc.category);
+    }
+    async saveDocFile(doc, content) {
+        const tempDir = await this.getDocTempDirectory(doc);
+        await (0, files_1.verifyAndCreateFolder)(tempDir);
+        const filePath = path.join(tempDir, `${doc.name}.md`);
+        await fs.writeFile(filePath, content, 'utf-8');
+    }
+    async verifyDocAlreadyExists(doc) {
+        const tempDir = await this.getDocTempDirectory(doc);
+        const filePath = path.join(tempDir, `${doc.name}.md`);
+        const fileExist = await (0, files_1.verifyPath)(filePath);
+        return fileExist;
+    }
+    async getDOCFileData(doc) {
+        const { files: filePaths } = doc;
+        const files = [];
+        for (const filePath of filePaths) {
+            const content = await fs.readFile(filePath, 'utf-8');
+            files.push({
+                path: filePath,
+                content,
+            });
+        }
+        return files;
+    }
+    async generate(docs) {
+        if (!this.server.isReady) {
+            await this.server.init();
+        }
+        const parallel = new parallel_1.default(NUM_OF_PARALLEL_REQUESTS);
+        const progressBar = new cliProgress.SingleBar({}, cliProgress.Presets.legacy);
+        progressBar.start(docs.length, 0);
+        for (const doc of docs) {
+            parallel.add(async () => {
+                const docExists = await this.verifyDocAlreadyExists(doc);
+                if (docExists) {
+                    progressBar.increment();
+                    return;
+                }
+                const files = await this.getDOCFileData(doc);
+                const content = await this.generateDOCDocumentation(doc, files);
+                await this.saveDocFile(doc, content);
+                progressBar.increment();
+            });
+        }
+        await parallel.execute();
+        progressBar.stop();
+    }
+}
+exports.default = DocsGenerator;

package/dist/commands/ai/docs/types.d.ts

@@ -0,0 +1,11 @@
+export interface IDocumentation {
+    name: string;
+    category: string;
+    files: string[];
+    project: string;
+    projectType: string;
+}
+export interface IFileData {
+    path: string;
+    content: string;
+}

package/dist/commands/ai/docs/types.js

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

package/dist/commands/ai/generate.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const inquirer_1 = require("inquirer");
+const docs_1 = require("./docs");
 const generator_1 = require("./modules/generator");
 const state_1 = require("./modules/state");
 const generateCommand = new commander_1.Command('generate')
@@ -17,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')
@@ -72,4 +95,5 @@ const generateChecklistCommand = new commander_1.Command('checklist')
 });
 generateCommand.addCommand(generateStyleCommand);
 generateCommand.addCommand(generateChecklistCommand);
+generateCommand.addCommand(docs_1.default);
 exports.default = generateCommand;

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

@@ -1,6 +1,5 @@
 "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");
@@ -25,24 +24,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;
+            const tempFolder = await (0, files_1.getTempFilePath)(generator_1.GENERATOR_FOLDER_NAME, block.name);
+            if (await (0, files_1.verifyPath)(tempFolder)) {
+                continue;
             }
-            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 blockFolder = path.join(nextProject.path, 'layouts', 'blocks', block.name);
-                    if (await (0, files_1.verifyPath)(blockFolder)) {
-                        block.hidden = true;
-                    }
+            if (nextProject) {
+                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>;
 }