@futurebrand/dev-tools 2.5.1 → 2.5.2

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')
@@ -72,4 +73,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/generator/index.js

@@ -24,48 +24,36 @@ class Generator {
             styles,
             strapiComponent,
         };
-        try {
-            const data = await this.state.fetchApi('/generate/nextjs/block', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(requestBody),
-            });
-            if (data.result?.block) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return data.result.block;
-            }
-            return null;
-        }
-        catch (error) {
-            console.error(error);
-            return null;
+        const data = await this.state.fetchApi('/generate/nextjs/block', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(requestBody),
+        });
+        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) {
         const requestBody = {
             name: blockName.replace('block-', ''),
             variants: blockVariants,
         };
-        try {
-            const data = await this.state.fetchApi('/generate/strapi/block', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(requestBody),
-            });
-            if (data.result) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return data.result;
-            }
-            return null;
-        }
-        catch (error) {
-            console.error(error);
-            return null;
+        const data = await this.state.fetchApi('/generate/strapi/block', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(requestBody),
+        });
+        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) {
@@ -93,18 +81,14 @@ class Generator {
             if (strapiProject) {
                 strapiResponse = await this.generateStrapiBlock(blockName, blockVariants);
                 onGenerateCallback();
-                if (strapiResponse) {
-                    const cachePath = path.join(tempFolder, exports.GENERATOR_STRAPI_FILE_NAME);
-                    await fs.writeFile(cachePath, JSON.stringify(strapiResponse, null, 2));
-                }
+                const cachePath = path.join(tempFolder, exports.GENERATOR_STRAPI_FILE_NAME);
+                await fs.writeFile(cachePath, JSON.stringify(strapiResponse, null, 2));
             }
             if (nextProject) {
                 const nextResponse = await this.generateNextBlock(blockName, blockVariants, this.data.variables, styles, strapiResponse);
                 onGenerateCallback();
-                if (nextResponse) {
-                    const cachePath = path.join(tempFolder, exports.GENERATOR_NEXTJS_FILE_NAME);
-                    await fs.writeFile(cachePath, nextResponse);
-                }
+                const cachePath = path.join(tempFolder, exports.GENERATOR_NEXTJS_FILE_NAME);
+                await fs.writeFile(cachePath, nextResponse);
             }
             this.state.setBlockGenerated(blockName);
         }

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

@@ -18,7 +18,8 @@ class ProjectAdder {
             throw new Error('Strapi project not found');
             // return
         }
-        const componentsFolder = path.join(strapiProject.path, 'src', 'components');
+        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);
@@ -43,7 +44,7 @@ class ProjectAdder {
             throw new Error('Nextjs project not found');
             // return
         }
-        const blockFolder = path.join(project.path, 'layouts', 'blocks', block.name);
+        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);

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

@@ -2,6 +2,7 @@ import type { IAIFileState, IAvailableFilters } from './types';
 declare class AIState {
     private filePath;
     private data;
+    private server;
     constructor();
     private createOptions;
     create(): Promise<void>;

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+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");
@@ -7,7 +8,10 @@ const FILE_NAME = 'ai-state.json';
 class AIState {
     filePath = '';
     data = null;
-    constructor() { }
+    server;
+    constructor() {
+        this.server = new ai_server_module_1.default();
+    }
     async createOptions() {
         const query = await inquirer_1.default.prompt([
             {
@@ -40,34 +44,23 @@ class AIState {
     }
     async create() {
         this.data = await this.createOptions();
+        this.server.setApiConfigs(this.data.configs);
     }
     async fetchApi(path, init) {
-        let apiUrl = this.getData().configs.api;
-        if (apiUrl.endsWith('/')) {
-            apiUrl = apiUrl.slice(0, -1);
-        }
-        const response = await fetch(`${apiUrl}${path}`, {
-            ...init,
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${this.getData().configs.token}`,
-                ...init?.headers,
-            },
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to fetch ${path}`);
-        }
-        const data = await response.json();
-        return data;
+        return this.server.fetchApi(path, init);
     }
     async init() {
         this.filePath = await (0, files_1.getTempFilePath)(FILE_NAME);
         if (await (0, files_1.verifyPath)(this.filePath)) {
             this.data = await (0, files_1.loadJSONFile)(this.filePath);
+            this.server.setApiConfigs(this.data.configs);
         }
     }
     async save() {
-        await (0, files_1.writeJSONFile)(this.filePath, this.data);
+        if (this.data) {
+            await (0, files_1.writeJSONFile)(this.filePath, this.data);
+            await this.server.save();
+        }
     }
     get isReady() {
         return this.data !== null;

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

@@ -1,8 +1,7 @@
+import type { IServerConfigs } from '../../../../modules/ai-server-module/types';
 import type { IProject } from '../../../../types/project';
 import type { IFigmaNode } from '../figma/types';
-export interface IStateConfigs {
-    api: string;
-    token: string;
+export interface IStateConfigs extends IServerConfigs {
     figma: string;
 }
 export interface IBlockData {

package/dist/modules/ai-server-module/index.d.ts

@@ -0,0 +1,15 @@
+import type { IServerConfigs } from './types';
+declare class AIServerModule implements IServerConfigs {
+    private filePath;
+    api: string;
+    token: string;
+    constructor();
+    private createConfigs;
+    create(): Promise<void>;
+    fetchApi<T = any>(path: string, init?: RequestInit): Promise<T>;
+    init(): Promise<void>;
+    setApiConfigs(configs: IServerConfigs): void;
+    save(): Promise<void>;
+    get isReady(): boolean;
+}
+export default AIServerModule;

package/dist/modules/ai-server-module/index.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const inquirer_1 = require("inquirer");
+const files_1 = require("../../utils/files");
+const FILE_NAME = 'ai-server.json';
+class AIServerModule {
+    filePath = '';
+    api = '';
+    token = '';
+    constructor() { }
+    async createConfigs() {
+        const query = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'apiUrl',
+                message: 'What is the AI API url?',
+            },
+            {
+                type: 'input',
+                name: 'apiToken',
+                message: 'What is the AI API token?',
+            },
+        ]);
+        return {
+            api: query.apiUrl,
+            token: query.apiToken,
+        };
+    }
+    async create() {
+        const configs = await this.createConfigs();
+        this.api = configs.api;
+        this.token = configs.token;
+    }
+    async fetchApi(path, init) {
+        if (!this.isReady) {
+            await this.init();
+        }
+        let apiUrl = this.api;
+        if (apiUrl.endsWith('/')) {
+            apiUrl = apiUrl.slice(0, -1);
+        }
+        const response = await fetch(`${apiUrl}${path}`, {
+            ...init,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.token}`,
+                ...init?.headers,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${path}`);
+        }
+        const data = await response.json();
+        return data;
+    }
+    async init() {
+        this.filePath = await (0, files_1.getTempFilePath)(FILE_NAME);
+        if (await (0, files_1.verifyPath)(this.filePath)) {
+            const configs = await (0, files_1.loadJSONFile)(this.filePath);
+            this.setApiConfigs(configs);
+        }
+        else {
+            const configs = await this.createConfigs();
+            this.setApiConfigs(configs);
+            await this.save();
+        }
+    }
+    setApiConfigs(configs) {
+        this.api = configs.api;
+        this.token = configs.token;
+    }
+    async save() {
+        if (!this.isReady) {
+            throw new Error('AIServerModule is not ready. Please initialize it first.');
+        }
+        const filePath = this.filePath || (await (0, files_1.getTempFilePath)(FILE_NAME));
+        await (0, files_1.writeJSONFile)(filePath, {
+            api: this.api,
+            token: this.token,
+        });
+    }
+    get isReady() {
+        return this.api !== '' && this.token !== '';
+    }
+}
+exports.default = AIServerModule;

package/dist/modules/ai-server-module/types.d.ts

@@ -0,0 +1,4 @@
+export interface IServerConfigs {
+    api: string;
+    token: string;
+}

package/dist/modules/ai-server-module/types.js

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

package/dist/modules/parallel/index.d.ts

@@ -1,16 +1,11 @@
 type ParallelCallback = () => Promise<void>;
-type CycleCallback = (index: number, total: number) => void;
 declare class ParallelModule {
     private readonly parallelCalls;
     private promises;
     private running;
-    private index;
     constructor(parallelCalls: number);
     add(callback: ParallelCallback): void;
-    private next;
-    private wait;
-    get total(): number;
-    execute(callback: CycleCallback): Promise<void>;
+    execute(): Promise<void>;
     reset(): void;
 }
 export default ParallelModule;

package/dist/modules/parallel/index.js

@@ -1,50 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const sleep_1 = require("../../utils/sleep");
 class ParallelModule {
     parallelCalls;
     promises;
     running;
-    index;
     constructor(parallelCalls) {
         this.parallelCalls = parallelCalls;
         this.promises = [];
-        this.running = 0;
-        this.index = 0;
+        this.running = new Set();
     }
     add(callback) {
         this.promises.push(callback);
     }
-    async next(callback) {
-        const promise = this.promises.shift();
-        if (promise) {
-            this.running++;
-            await promise();
-            this.running--;
-        }
-        this.index++;
-        callback(this.index, this.total);
-    }
-    async wait() {
-        while (this.running >= this.parallelCalls) {
-            await (0, sleep_1.sleep)(0);
-        }
-    }
-    get total() {
-        return this.promises.length;
-    }
-    async execute(callback) {
-        while (this.promises.length > 0) {
-            if (this.running >= this.parallelCalls) {
-                await this.wait();
+    async execute() {
+        for (const promise of this.promises) {
+            const task = promise().then(() => {
+                this.running.delete(task);
+            });
+            this.running.add(task);
+            if (this.running.size >= this.parallelCalls) {
+                await Promise.race(this.running);
             }
-            void this.next(callback);
         }
+        await Promise.all(this.running);
     }
     reset() {
         this.promises = [];
-        this.running = 0;
-        this.index = 0;
+        this.running = new Set();
     }
 }
 exports.default = ParallelModule;

package/dist/types/project.d.ts

@@ -2,6 +2,7 @@ export type ProjectType = 'next.js' | 'react' | 'strapi' | 'node';
 interface IDefaultProject {
     name: string;
     path: string;
+    srcPath: string;
     relativePath: string;
     type: ProjectType;
 }

package/dist/utils/files.d.ts

@@ -8,3 +8,5 @@ export declare function writeJSONFile(filePath: string, data: unknown): Promise<
 export declare function writeRootFile(fileName: string, content: string): Promise<void>;
 export declare function writeFile(filePath: string, content: string): Promise<void>;
 export declare function loadFile(filePath: string): Promise<string>;
+export declare function getDirectoriesInPath(rootPath: string): Promise<string[]>;
+export declare function getFilesInPath(rootPath: string): Promise<string[]>;

package/dist/utils/files.js

@@ -10,6 +10,8 @@ exports.writeJSONFile = writeJSONFile;
 exports.writeRootFile = writeRootFile;
 exports.writeFile = writeFile;
 exports.loadFile = loadFile;
+exports.getDirectoriesInPath = getDirectoriesInPath;
+exports.getFilesInPath = getFilesInPath;
 const fs = require("node:fs/promises");
 const path = require("path");
 async function verifyPath(filePath) {
@@ -82,3 +84,43 @@ async function loadFile(filePath) {
         throw error;
     }
 }
+async function getDirectoriesInPath(rootPath) {
+    const directories = [];
+    try {
+        const allContent = await fs.readdir(rootPath);
+        for (const content of allContent) {
+            const contentPath = path.join(rootPath, content);
+            const stats = await fs.stat(contentPath);
+            if (stats.isDirectory()) {
+                directories.push(content);
+            }
+        }
+        return directories;
+    }
+    catch (error) {
+        console.error(`Error reading directory ${rootPath}:`, error);
+        return directories;
+    }
+}
+async function getFilesInPath(rootPath) {
+    const files = [];
+    try {
+        const allContent = await fs.readdir(rootPath);
+        for (const content of allContent) {
+            const contentPath = path.join(rootPath, content);
+            const stats = await fs.stat(contentPath);
+            if (stats.isFile()) {
+                files.push(contentPath);
+            }
+            else if (stats.isDirectory()) {
+                const subFiles = await getFilesInPath(contentPath);
+                files.push(...subFiles);
+            }
+        }
+        return files;
+    }
+    catch (error) {
+        console.error(`Error reading directory ${rootPath}:`, error);
+        return files;
+    }
+}

package/dist/utils/project.js

@@ -5,35 +5,55 @@ const path = require("path");
 const files_1 = require("./files");
 const package_manager_1 = require("./package-manager");
 const project_type_1 = require("./project-type");
-const PROJECTS_DIRS = ['', 'backend', 'frontend', 'server', 'scripts'];
-async function verifyProjectPath(relativePath) {
+async function getProjectSRCPath(projectPath) {
+    const srcPath = path.join(projectPath, 'src');
+    if (await (0, files_1.verifyPath)(srcPath)) {
+        return srcPath;
+    }
+    const libPath = path.join(projectPath, 'lib');
+    if (await (0, files_1.verifyPath)(libPath)) {
+        return libPath;
+    }
+    return projectPath;
+}
+async function verifyProjectPath(relativePath = '') {
     const projectPath = (0, files_1.getRootPath)(relativePath);
     const packageJson = await (0, package_manager_1.loadPackageJson)(projectPath);
     if (!packageJson) {
         return null;
     }
     const projectType = await (0, project_type_1.getProjectType)(projectPath);
+    const srcPath = await getProjectSRCPath(projectPath);
+    const name = packageJson.name;
     if (projectType === 'next.js') {
         const projectAppFolder = path.join(projectPath, 'app');
         const isAppProject = await (0, files_1.verifyPath)(projectAppFolder);
         return {
-            name: packageJson.name,
+            name,
             relativePath: `./${relativePath}`,
+            srcPath,
             path: projectPath,
             type: projectType,
             appDir: isAppProject,
         };
     }
     return {
-        name: packageJson.name,
+        name,
+        srcPath,
         relativePath: `./${relativePath}`,
         path: projectPath,
         type: projectType,
     };
 }
 async function getProjects() {
+    const rootProject = await verifyProjectPath();
+    if (rootProject) {
+        return [rootProject];
+    }
+    const rootPath = (0, files_1.getRootPath)();
     const projects = [];
-    for (const relativePath of PROJECTS_DIRS) {
+    const folders = await (0, files_1.getDirectoriesInPath)(rootPath);
+    for (const relativePath of folders) {
         const project = await verifyProjectPath(relativePath);
         if (project) {
             projects.push(project);

package/package.json

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