@futurebrand/dev-tools 2.5.4 → 2.7.0

package/dist/commands/ai/modules/figma/api.d.ts

@@ -3,6 +3,5 @@ export declare class FigmaAPI {
     private state;
     constructor(state: AIState);
     getBlockCanvas(pageId: string): Promise<string>;
-    getVariables(pageId: string): Promise<Record<string, any>>;
     getBlocks(pageId: string, canvasId: string): Promise<Record<string, import("./types").IFigmaNode[]>>;
 }

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

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

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

@@ -47,10 +47,7 @@ class FigmaModule {
         const canvas = await this.api.getBlockCanvas(figmaPageID);
         console.log('- Loading pages blocks');
         const blocksData = [];
-        const [blocks, variables] = await Promise.all([
-            this.api.getBlocks(figmaPageID, canvas),
-            this.api.getVariables(figmaPageID),
-        ]);
+        const blocks = await this.api.getBlocks(figmaPageID, canvas);
         Object.keys(blocks).forEach((blockName) => {
             let block = blocksData.find((block) => block.name === blockName);
             if (!block) {
@@ -86,7 +83,6 @@ class FigmaModule {
             }
         }
         this.state.setBlocks(blocksData);
-        this.state.setVariables(variables);
         console.log('- Figma blocks loaded successfully');
     }
 }

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

@@ -1,9 +1,6 @@
 export interface IDocumentResponse {
     id: string;
 }
-export interface IVariablesResponse {
-    variables: Record<string, any>;
-}
 interface IFigmaProperties {
     value: string;
     type: string;

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

@@ -1,8 +1,11 @@
 import type { IProject } from '../../../../types/project';
+import type { INextjsGenerateResponse, IStrapiGenerateResponse } from '../generator/types';
 import type { IBlockData } from '../state/types';
+import type { IProjectFile, IProjectFileSegment } 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";
+export declare const GENERATOR_NEXTJS_EXTRA_FILES = "nextjs-extra-files.json";
 declare class FileManager {
     private getBlockTempPath;
     private getBlockTempFilePath;
@@ -14,9 +17,13 @@ declare class FileManager {
     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>;
+    saveGeneratedBlock(blockName: string, project: IProject, content: IStrapiGenerateResponse | INextjsGenerateResponse): Promise<void>;
     loadGeneratedBlock(blockName: string, project: IProject): Promise<string>;
     addNextBlockToProject(blockName: string, project: IProject): Promise<void>;
     addStrapiBlockToProject(blockName: string, project: IProject): Promise<void>;
+    loadFilesInPath(rootPath: string, relativeTo?: string, includeSubFolders?: boolean): Promise<IProjectFile[]>;
+    loadProjectFiles(project: IProject | null, subDir: string): Promise<IProjectFileSegment[]>;
+    loadCustomPrompts(blockName: string): Promise<string>;
+    loadProjectCSS(nextProject?: IProject): Promise<string | null>;
 }
 export default FileManager;

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

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GENERATOR_NEXTJS_FILE_NAME = exports.GENERATOR_STRAPI_FILE_NAME = exports.GENERATOR_FOLDER_NAME = void 0;
+exports.GENERATOR_NEXTJS_EXTRA_FILES = 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';
+exports.GENERATOR_NEXTJS_EXTRA_FILES = 'nextjs-extra-files.json';
 class FileManager {
     async getBlockTempPath(blockName) {
         const tempFolder = await (0, files_1.getTempFilePath)(exports.GENERATOR_FOLDER_NAME, blockName);
@@ -98,9 +99,23 @@ class FileManager {
         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);
+        if (project.type === 'next.js') {
+            const blockPath = await this.getBlockTempFilePath(project, blockName);
+            await fs.writeFile(blockPath, content.block);
+            const blockDir = path.dirname(blockPath);
+            const definitionPath = path.join(blockDir, 'nextjs-definition.json');
+            await fs.writeFile(definitionPath, JSON.stringify(content.definition, null, 2));
+            const extraFiles = content.extraFiles || [];
+            if (extraFiles.length > 0) {
+                const extraFilesPath = path.join(blockDir, exports.GENERATOR_NEXTJS_EXTRA_FILES);
+                await fs.writeFile(extraFilesPath, JSON.stringify(extraFiles, null, 2));
+            }
+        }
+        if (project.type === 'strapi') {
+            const blockPath = await this.getBlockTempFilePath(project, blockName);
+            const stringContent = JSON.stringify(content, null, 2);
+            await fs.writeFile(blockPath, stringContent);
+        }
     }
     async loadGeneratedBlock(blockName, project) {
         const blockPath = await this.getBlockTempFilePath(project, blockName);
@@ -113,13 +128,34 @@ class FileManager {
         if (project.type !== 'next.js') {
             throw new Error('Project is not a Next.js project');
         }
+        const tempFolder = await this.getBlockTempPath(blockName);
+        // Verify generated block
         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);
+        // Create block folder
         const blockFolder = this.getNextjsBlockFolder(project, blockName);
         await (0, files_1.verifyAndCreateFolder)(blockFolder);
+        // Add Extra files
+        try {
+            const extraFilesPath = path.join(tempFolder, exports.GENERATOR_NEXTJS_EXTRA_FILES);
+            const hasExtraFiles = await (0, files_1.verifyPath)(extraFilesPath);
+            if (hasExtraFiles) {
+                const extraFilesContent = await (0, files_1.loadFile)(extraFilesPath);
+                const extraFiles = JSON.parse(extraFilesContent);
+                if (extraFiles && extraFiles.length > 0) {
+                    for (const extraFile of extraFiles) {
+                        const extraFilePath = path.join(blockFolder, extraFile.name);
+                        await fs.writeFile(extraFilePath, extraFile.content);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Failed to add extra files to Next.js block:', error);
+        }
+        const content = await (0, files_1.loadFile)(generatedPath);
         const mainFilePath = path.join(blockFolder, `${blockName}.tsx`);
         const indexFilePath = path.join(blockFolder, 'index.ts');
         const indexContent = `export { default } from './${blockName}'
@@ -152,5 +188,109 @@ class FileManager {
             await fs.writeFile(assetFilePath, JSON.stringify(asset, null, 2));
         }
     }
+    async loadFilesInPath(rootPath, relativeTo, includeSubFolders = true) {
+        const allFilesPath = await (0, files_1.getFilesInPath)(rootPath, includeSubFolders);
+        const files = [];
+        for (const filePath of allFilesPath) {
+            const content = await (0, files_1.loadFile)(filePath);
+            const relativePath = relativeTo
+                ? path.relative(relativeTo, filePath)
+                : filePath;
+            files.push({ path: relativePath, content });
+        }
+        return files;
+    }
+    async loadProjectFiles(project, subDir) {
+        if (!project) {
+            return [];
+        }
+        const rootFolder = path.join(project.srcPath, subDir);
+        const segments = [];
+        try {
+            if (!(await (0, files_1.verifyPath)(rootFolder))) {
+                throw new Error('Components folder does not exist');
+            }
+            const files = await this.loadFilesInPath(rootFolder, project.srcPath, false);
+            if (files.length > 0) {
+                for (const file of files) {
+                    const name = path.basename(file.path, path.extname(file.path));
+                    const segment = {
+                        name,
+                        files: [
+                            {
+                                ...file,
+                                path: `@/${file.path}`.replace(/\/index.ts|\/index.tsx/g, ''),
+                            },
+                        ],
+                    };
+                    segments.push(segment);
+                }
+            }
+            const dirs = await (0, files_1.getDirectoriesInPath)(rootFolder);
+            for (const dir of dirs) {
+                const dirPath = path.join(rootFolder, dir);
+                const dirFiles = (await this.loadFilesInPath(dirPath, project.srcPath)).map((file) => ({
+                    ...file,
+                    path: `@/${file.path}`.replace(/\/index.ts|\/index.tsx/g, ''),
+                }));
+                const dirName = path.basename(dir);
+                const segment = {
+                    name: dirName,
+                    files: dirFiles,
+                };
+                segments.push(segment);
+            }
+            return segments;
+        }
+        catch (error) {
+            console.error(error);
+            return [];
+        }
+    }
+    async loadCustomPrompts(blockName) {
+        try {
+            const prompts = [];
+            const globalPromptPath = await (0, files_1.getTempFilePath)('prompts.md');
+            if (await (0, files_1.verifyPath)(globalPromptPath)) {
+                const globalPrompt = await (0, files_1.loadFile)(globalPromptPath);
+                if (globalPrompt) {
+                    prompts.push(globalPrompt);
+                }
+            }
+            else {
+                await (0, files_1.writeFile)(globalPromptPath, '');
+            }
+            const blockFolder = await this.getBlockTempPath(blockName);
+            const blockPromptsPath = path.join(blockFolder, 'prompts.md');
+            if (await (0, files_1.verifyPath)(blockPromptsPath)) {
+                const blockPrompt = await (0, files_1.loadFile)(blockPromptsPath);
+                if (blockPrompt) {
+                    prompts.push(blockPrompt);
+                }
+            }
+            return prompts.join('\n\n');
+        }
+        catch (error) {
+            console.error(error);
+            return '';
+        }
+    }
+    async loadProjectCSS(nextProject) {
+        if (!nextProject) {
+            return null;
+        }
+        const cssFile = path.join(nextProject.srcPath, 'styles', 'index.css');
+        try {
+            const css = await fs.readFile(cssFile, 'utf-8');
+            if (!css) {
+                return null;
+            }
+            return css;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    }
 }
 exports.default = FileManager;

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

@@ -2,3 +2,11 @@ export interface IStrapiFolders {
     blocks: string;
     assets: string;
 }
+export interface IProjectFileSegment {
+    name: string;
+    files: IProjectFile[];
+}
+export interface IProjectFile {
+    path: string;
+    content: string;
+}

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

@@ -10,8 +10,8 @@ export declare class Generator {
     private get data();
     private fetchNextBlock;
     private fetchStrapiBlock;
-    loadProjectCSS(nextProject?: IProject): Promise<string | null>;
     private generateStrapiBlock;
+    private getNextjsProjectFiles;
     private generateNextBlock;
     generateBlock(blockName: string, project: IProject): Promise<IStrapiGenerateResponse | undefined>;
     generateBlocks(blockNames: string[], project: IProject): Promise<void>;

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Generator = 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");
 const cliProgress = require("cli-progress");
 exports.GENERATOR_FOLDER_NAME = 'generated-blocks';
@@ -16,13 +15,14 @@ class Generator {
     get data() {
         return this.state.getData();
     }
-    async fetchNextBlock(blockName, blockVariants, variables, styles, strapiComponent) {
+    async fetchNextBlock(blockName, blockVariants, files, strapiComponent, customPrompt) {
         const requestBody = {
             name: blockName.replace('block-', ''),
             variants: blockVariants,
-            variables,
-            styles,
+            files,
             strapiComponent,
+            customPrompt,
+            figma: this.data.configs.figma,
         };
         const data = await this.state.fetchApi('/generate/nextjs/block', {
             method: 'POST',
@@ -34,12 +34,13 @@ class Generator {
         if (!data.result?.block) {
             throw new Error('Next.js block generation failed');
         }
-        return data.result.block;
+        return data.result;
     }
     async fetchStrapiBlock(blockName, blockVariants) {
         const requestBody = {
             name: blockName.replace('block-', ''),
             variants: blockVariants,
+            figma: this.data.configs.figma,
         };
         const data = await this.state.fetchApi('/generate/strapi/block', {
             method: 'POST',
@@ -53,23 +54,6 @@ class Generator {
         }
         return data.result;
     }
-    async loadProjectCSS(nextProject) {
-        if (!nextProject) {
-            return null;
-        }
-        const cssFile = path.join(nextProject.srcPath, 'styles', 'index.css');
-        try {
-            const css = await fs.readFile(cssFile, 'utf-8');
-            if (!css) {
-                return null;
-            }
-            return css;
-        }
-        catch (error) {
-            console.error(error);
-            return null;
-        }
-    }
     async generateStrapiBlock(blockName, project, blockVariants) {
         const isAlreadyGenerated = await this.state.file.verifyBlockAlreadyGenerated(blockName, project);
         if (isAlreadyGenerated) {
@@ -80,13 +64,26 @@ class Generator {
         await this.state.file.saveGeneratedBlock(blockName, project, response);
         return response;
     }
+    async getNextjsProjectFiles(project) {
+        const styles = await this.state.file.loadProjectFiles(project, 'styles');
+        const components = await this.state.file.loadProjectFiles(project, 'components');
+        const types = await this.state.file.loadProjectFiles(project, 'types');
+        const layouts = await this.state.file.loadProjectFiles(project, 'layouts/shared');
+        return {
+            styles,
+            components,
+            types,
+            layouts,
+        };
+    }
     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);
+        const customPrompt = await this.state.file.loadCustomPrompts(blockName);
+        const files = await this.getNextjsProjectFiles(project);
+        const nextResponse = await this.fetchNextBlock(blockName, blockVariants, files, strapiBlock, customPrompt);
         await this.state.file.saveGeneratedBlock(blockName, project, nextResponse);
     }
     async generateBlock(blockName, project) {
@@ -101,7 +98,12 @@ class Generator {
             }
         }
         catch (error) {
+            console.log('------------------------------------');
+            console.log('------------------------------------');
+            console.log(`Error generating block: ${blockName}`);
             console.error(error);
+            console.log('------------------------------------');
+            console.log('------------------------------------');
         }
     }
     async generateBlocks(blockNames, project) {
@@ -124,7 +126,8 @@ class Generator {
     }
     async generateStyles() {
         console.log('- Generating Styles... Please wait');
-        const variables = this.data.variables;
+        // TODO: get variables from blocks
+        const variables = {}; // this.data.variables
         const data = await this.state.fetchApi('/generate/styles', {
             method: 'POST',
             headers: {
@@ -150,13 +153,27 @@ class Generator {
         console.log('- Generating Checklist... Please wait');
         const lines = ['# Checklist', ''];
         const blocks = this.state.getData().blocks;
+        let project = this.state.getProjectByType('next.js');
+        if (!project) {
+            project = this.state.getProjectByType('strapi');
+            if (!project) {
+                throw new Error('No suitable project found for checklist generation');
+            }
+        }
         for (const block of blocks) {
+            const isChecked = block.hidden ||
+                (await this.state.file.verifyBlockAlreadyExists(project, block.name));
             const name = block.name
                 .replace('block-', '')
                 .split('-')
                 .map((word) => word.length > 1 ? word.charAt(0).toUpperCase() + word.slice(1) : word)
                 .join(' ');
-            lines.push(`- [${block.generated || block.hidden ? 'x' : ' '}] Block | ${name} (\`${block.name}\`)`);
+            let nameContent = `Block | ${name} (\`${block.name}\`)`;
+            if (block.hidden) {
+                nameContent = `~~${nameContent}~~ <sup>hidden</sup>`;
+            }
+            const checkContent = isChecked ? 'x' : ' ';
+            lines.push(`- [${checkContent}] ${nameContent}`);
         }
         const listText = lines.join('\n');
         const tempPath = await (0, files_1.getTempFilePath)('checklist.md');

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

@@ -12,6 +12,18 @@ export interface IStrapiGenerateResponse {
     block: IStrapiComponent;
     assets: IStrapiComponent[];
 }
+export interface IGenerationExtraFile {
+    name: string;
+    content: string;
+    type: string;
+    description: string;
+}
 export interface INextjsGenerateResponse {
     block: string;
+    extraFiles: IGenerationExtraFile[];
+    definition: {
+        architecture: string[];
+        decisions: string[];
+        note: string;
+    };
 }

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

@@ -1,3 +1,4 @@
+import type { IProject, ProjectType } from '../../../../types/project';
 import FileManager from '../file-manager';
 import type { IAIFileState, IAvailableFilters } from './types';
 declare class AIState {
@@ -13,10 +14,10 @@ declare class AIState {
     save(): Promise<void>;
     get isReady(): boolean;
     getData(): IAIFileState;
+    getProjectByType(type: ProjectType): IProject | null;
     getAvailableBlocks({ generated, hidden }?: IAvailableFilters): import("./types").IBlockData[];
     getAvailableBlocksNames(filters?: IAvailableFilters): string[];
     setBlocks(blocks: IAIFileState['blocks']): void;
-    setVariables(variables: IAIFileState['variables']): void;
     setColors(colors: IAIFileState['colors']): void;
     setBlockGenerated(blockName: string, generated?: boolean): void;
     getBlockVariants(blockName: string): any[];

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

@@ -42,7 +42,6 @@ class AIState {
             },
             projects,
             blocks: [],
-            variables: {},
         };
     }
     async create() {
@@ -74,6 +73,10 @@ class AIState {
         }
         return this.data;
     }
+    getProjectByType(type) {
+        const projects = this.getData().projects;
+        return projects.find((project) => project.type === type) || null;
+    }
     getAvailableBlocks({ generated, hidden } = {}) {
         let blocks = this.getData().blocks;
         if (hidden != null || generated != null) {
@@ -96,12 +99,6 @@ class AIState {
     setBlocks(blocks) {
         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');

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

@@ -23,6 +23,5 @@ export interface IAIFileState {
     configs: IStateConfigs;
     blocks: IBlockData[];
     projects: IProject[];
-    variables: Record<string, any>;
     colors?: IProjectColor[];
 }

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

@@ -1,13 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_net_1 = require("node:net");
 const inquirer_1 = require("inquirer");
+const undici_1 = require("undici");
 const files_1 = require("../../utils/files");
 const FILE_NAME = 'ai-server.json';
+const TIMEOUT_LIMIT_TIME = 1000 * 60 * 60; // 60 minutes
+const longTimeoutAgent = new undici_1.Agent({
+    connect: {
+        timeout: TIMEOUT_LIMIT_TIME,
+    },
+    headersTimeout: TIMEOUT_LIMIT_TIME,
+    bodyTimeout: TIMEOUT_LIMIT_TIME,
+});
 class AIServerModule {
     filePath = '';
     api = '';
     token = '';
-    constructor() { }
+    constructor() {
+        (0, node_net_1.setDefaultAutoSelectFamilyAttemptTimeout)(TIMEOUT_LIMIT_TIME);
+    }
     async createConfigs() {
         const query = await inquirer_1.default.prompt([
             {
@@ -46,6 +58,10 @@ class AIServerModule {
                 Authorization: `Bearer ${this.token}`,
                 ...init?.headers,
             },
+            signal: AbortSignal.timeout(TIMEOUT_LIMIT_TIME),
+            ...{
+                dispatcher: longTimeoutAgent,
+            },
         });
         if (!response.ok) {
             throw new Error(`Failed to fetch ${path}`);

package/dist/utils/files.d.ts

@@ -9,4 +9,4 @@ export declare function writeRootFile(fileName: string, content: string): Promis
 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[]>;
+export declare function getFilesInPath(rootPath: string, includeSubFolders?: boolean): Promise<string[]>;

package/dist/utils/files.js

@@ -102,7 +102,7 @@ async function getDirectoriesInPath(rootPath) {
         return directories;
     }
 }
-async function getFilesInPath(rootPath) {
+async function getFilesInPath(rootPath, includeSubFolders = true) {
     const files = [];
     try {
         const allContent = await fs.readdir(rootPath);
@@ -113,8 +113,10 @@ async function getFilesInPath(rootPath) {
                 files.push(contentPath);
             }
             else if (stats.isDirectory()) {
-                const subFiles = await getFilesInPath(contentPath);
-                files.push(...subFiles);
+                if (includeSubFolders) {
+                    const subFiles = await getFilesInPath(contentPath);
+                    files.push(...subFiles);
+                }
             }
         }
         return files;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@futurebrand/dev-tools",
-  "version": "2.5.4",
+  "version": "2.7.0",
   "description": "FutureBrand Dev Tools",
   "scripts": {
     "build": "tsc && tsc-alias",
@@ -64,7 +64,8 @@
     "inquirer": "^12.6.3",
     "prettier": "^3.6.0",
     "prettier-plugin-tailwindcss": "^0.6.13",
-    "typescript-eslint": "^8.35.0"
+    "typescript-eslint": "^8.35.0",
+    "undici": "^7.18.2"
   },
   "devDependencies": {
     "@types/cli-progress": "^3.11.6",