@hed-hog/cli 0.0.67 → 0.0.69

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hed-hog/cli",
-    "version": "0.0.67",
+    "version": "0.0.69",
     "description": "HedHog CLI tool",
     "author": "HedHog",
     "private": false,

package/dist/src/commands/dev.command/deploy-config.subcommand.d.ts

@@ -3,8 +3,10 @@ import { DeveloperService } from 'src/modules/developer/developer.service';
 export declare class DeployConfigCommand extends CommandRunner {
     private readonly developer;
     constructor(developer: DeveloperService);
-    run([]: Iterable<any, void, undefined>, { verbose }: {
+    run([]: Iterable<any, void, undefined>, { repo, verbose }: {
+        repo: any;
         verbose: any;
     }): Promise<void>;
     parseVerboseOption(): boolean;
+    parseRepoOption(repo: string): string;
 }

package/dist/src/commands/dev.command/deploy-config.subcommand.js

@@ -18,12 +18,18 @@ let DeployConfigCommand = class DeployConfigCommand extends nest_commander_1.Com
         super();
         this.developer = developer;
     }
-    async run([], { verbose }) {
-        return this.developer.deployConfig(process.cwd(), verbose);
+    async run([], { repo, verbose }) {
+        return this.developer.deployConfig(process.cwd(), {
+            verbose,
+            repo,
+        });
     }
     parseVerboseOption() {
         return true;
     }
+    parseRepoOption(repo) {
+        return repo.trim();
+    }
 };
 exports.DeployConfigCommand = DeployConfigCommand;
 __decorate([
@@ -36,6 +42,16 @@ __decorate([
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Boolean)
 ], DeployConfigCommand.prototype, "parseVerboseOption", null);
+__decorate([
+    (0, nest_commander_1.Option)({
+        flags: '-r, --repo <owner/name>',
+        description: 'GitHub repository used for secrets configuration',
+        required: false,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", String)
+], DeployConfigCommand.prototype, "parseRepoOption", null);
 exports.DeployConfigCommand = DeployConfigCommand = __decorate([
     (0, nest_commander_1.SubCommand)({
         name: 'deploy-config',

package/dist/src/commands/dev.command/deploy-config.subcommand.js.map

@@ -1 +1 @@
-{"version":3,"file":"deploy-config.subcommand.js","sourceRoot":"","sources":["../../../../src/commands/dev.command/deploy-config.subcommand.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,mDAAmE;AACnE,iFAA2E;AAOpE,IAAM,mBAAmB,GAAzB,MAAM,mBAAoB,SAAQ,8BAAa;IACvB;IAA7B,YAA6B,SAA2B;QACtD,KAAK,EAAE,CAAC;QADmB,cAAS,GAAT,SAAS,CAAkB;IAExD,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE;QACvB,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,OAAO,CAAC,CAAC;IAC7D,CAAC;IAOD,kBAAkB;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;CACF,CAAA;AAjBY,kDAAmB;AAc9B;IALC,IAAA,uBAAM,EAAC;QACN,KAAK,EAAE,eAAe;QACtB,WAAW,EAAE,uBAAuB;QACpC,QAAQ,EAAE,KAAK;KAChB,CAAC;;;;6DAGD;8BAhBU,mBAAmB;IAL/B,IAAA,2BAAU,EAAC;QACV,IAAI,EAAE,eAAe;QACrB,OAAO,EAAE,CAAC,IAAI,CAAC;QACf,WAAW,EAAE,yDAAyD;KACvE,CAAC;qCAEwC,oCAAgB;GAD7C,mBAAmB,CAiB/B"}
+{"version":3,"file":"deploy-config.subcommand.js","sourceRoot":"","sources":["../../../../src/commands/dev.command/deploy-config.subcommand.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,mDAAmE;AACnE,iFAA2E;AAOpE,IAAM,mBAAmB,GAAzB,MAAM,mBAAoB,SAAQ,8BAAa;IACvB;IAA7B,YAA6B,SAA2B;QACtD,KAAK,EAAE,CAAC;QADmB,cAAS,GAAT,SAAS,CAAkB;IAExD,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;QAC7B,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE;YAChD,OAAO;YACP,IAAI;SACL,CAAC,CAAC;IACL,CAAC;IAOD,kBAAkB;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;IAOD,eAAe,CAAC,IAAY;QAC1B,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC;IACrB,CAAC;CACF,CAAA;AA7BY,kDAAmB;AAiB9B;IALC,IAAA,uBAAM,EAAC;QACN,KAAK,EAAE,eAAe;QACtB,WAAW,EAAE,uBAAuB;QACpC,QAAQ,EAAE,KAAK;KAChB,CAAC;;;;6DAGD;AAOD;IALC,IAAA,uBAAM,EAAC;QACN,KAAK,EAAE,yBAAyB;QAChC,WAAW,EAAE,kDAAkD;QAC/D,QAAQ,EAAE,KAAK;KAChB,CAAC;;;;0DAGD;8BA5BU,mBAAmB;IAL/B,IAAA,2BAAU,EAAC;QACV,IAAI,EAAE,eAAe;QACrB,OAAO,EAAE,CAAC,IAAI,CAAC;QACf,WAAW,EAAE,yDAAyD;KACvE,CAAC;qCAEwC,oCAAgB;GAD7C,mBAAmB,CA6B/B"}

package/dist/src/modules/developer/developer.service.d.ts

@@ -3,21 +3,34 @@ import { DatabaseService } from '../database/database.service';
 import { HedHogService } from '../hedhog/hedhog.service';
 import { FileSystemService } from '../hedhog/services/file-system.service';
 import { RunnerService } from '../runner/runner.service';
+type DeployConfigOptions = {
+    verbose?: boolean;
+    repo?: string;
+};
 export declare class DeveloperService {
     private readonly runner;
     private readonly fileSystem;
     private readonly database;
     private readonly hedHogService;
     private verbose;
+    private readonly bootstrapIgnoredEntries;
     constructor(runner: RunnerService, fileSystem: FileSystemService, database: DatabaseService, hedHogService: HedHogService);
     log(...args: any[]): void;
     private suppressWarnings;
     private refreshEnvironmentPath;
-    deployConfig(path: string, verbose?: boolean): Promise<void>;
+    deployConfig(path: string, { repo, verbose }?: DeployConfigOptions): Promise<void>;
     private checkRequiredTools;
     private checkKubectl;
     private checkDoctl;
     private checkGhCli;
+    private ensureGhAuthenticated;
+    private generateRandomHexSecret;
+    private generateRandomBase64Secret;
+    private maskDatabaseUrl;
+    private resolveGithubRepository;
+    private promptForDatabaseUrl;
+    private setGithubSecret;
+    private promptToConfigureGithubSecrets;
     private checkHelm;
     private checkPackageManager;
     private getAvailablePackageManager;
@@ -61,6 +74,12 @@ export declare class DeveloperService {
     syncPublish(path: string, verbose?: boolean): Promise<void>;
     showLibraryVersions(path: string, verbose?: boolean): Promise<void>;
     updateBootstrapFiles(path: string, verbose?: boolean): Promise<void>;
+    private resolveBootstrapSourceRoot;
+    private validateBootstrapDestinationPath;
+    private promptForBootstrapDestination;
+    private shouldIgnoreBootstrapEntry;
+    private syncBootstrapMirror;
+    private ensureBootstrapResetState;
     route(path: string, verbose?: boolean): Promise<void>;
     private extractMainModule;
     private extractRoutes;
@@ -100,3 +119,4 @@ export declare class DeveloperService {
     resetAndInstallAll(cwd: string, verbose?: boolean): Promise<void>;
     copyAssetsToLibrary(name: string, cwd: string, verbose?: boolean): Promise<void>;
 }
+export {};

package/dist/src/modules/developer/developer.service.js

@@ -35,6 +35,21 @@ let DeveloperService = class DeveloperService {
     database;
     hedHogService;
     verbose = false;
+    bootstrapIgnoredEntries = new Set([
+        '.git',
+        'node_modules',
+        'dist',
+        '.turbo',
+        'coverage',
+        '.cache',
+        '.pnpm-store',
+        '.yarn',
+        '.next',
+        '.nuxt',
+        '.svelte-kit',
+        '.parcel-cache',
+        '.eslintcache',
+    ]);
     constructor(runner, fileSystem, database, hedHogService) {
         this.runner = runner;
         this.fileSystem = fileSystem;
@@ -98,7 +113,7 @@ let DeveloperService = class DeveloperService {
             this.log('Environment refresh attempt completed');
         }
     }
-    async deployConfig(path, verbose = false) {
+    async deployConfig(path, { repo, verbose = false } = {}) {
         const restoreWarnings = this.suppressWarnings();
         this.verbose = verbose;
         path = await this.getRootPath(path);
@@ -172,6 +187,7 @@ let DeveloperService = class DeveloperService {
             spinner.succeed(chalk.green('Deployment configuration completed successfully!'));
             // Display summary
             this.displayDeploymentSummary(config);
+            await this.promptToConfigureGithubSecrets(path, repo);
         }
         catch (error) {
             spinner.fail('Failed to configure deployment.');
@@ -217,6 +233,130 @@ let DeveloperService = class DeveloperService {
         const versionLine = result.stdout.split('\n')[0];
         return versionLine.trim();
     }
+    async ensureGhAuthenticated() {
+        await this.checkGhCli();
+        await this.runner.executeCommand(runner_service_1.ProgramName.GH, ['auth', 'status'], {}, true);
+    }
+    generateRandomHexSecret(bytes = 32) {
+        return (0, crypto_1.randomBytes)(bytes).toString('hex');
+    }
+    generateRandomBase64Secret(bytes = 32) {
+        return (0, crypto_1.randomBytes)(bytes).toString('base64');
+    }
+    maskDatabaseUrl(databaseUrl) {
+        return databaseUrl.replace(/:\/\/([^:/?#]+):([^@]*)@/, '://$1:***@');
+    }
+    async resolveGithubRepository(path, repo) {
+        if (repo?.trim()) {
+            return repo.trim();
+        }
+        try {
+            const result = await this.runner.executeCommand(runner_service_1.ProgramName.GIT, ['remote', 'get-url', 'origin'], { cwd: path }, true);
+            const remoteUrl = result.stdout.trim();
+            const match = remoteUrl.match(/github\.com[:/]([^/]+\/[^/.]+?)(?:\.git)?$/i);
+            if (match?.[1]) {
+                return match[1];
+            }
+        }
+        catch {
+            // Fall through to prompt.
+        }
+        while (true) {
+            const answers = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'repo',
+                    message: 'Enter the GitHub repository (e.g. owner/name):',
+                    validate: (input) => {
+                        const value = String(input || '').trim();
+                        return /^[^/\s]+\/[^/\s]+$/.test(value)
+                            ? true
+                            : 'Enter the repository in the format owner/name';
+                    },
+                },
+            ]);
+            const resolvedRepo = String(answers.repo || '').trim();
+            if (resolvedRepo) {
+                return resolvedRepo;
+            }
+        }
+    }
+    async promptForDatabaseUrl() {
+        while (true) {
+            const answers = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'databaseUrl',
+                    message: 'Enter DATABASE_URL:',
+                    validate: (input) => String(input || '').trim().length > 0 ||
+                        'DATABASE_URL is required.',
+                },
+            ]);
+            const databaseUrl = String(answers.databaseUrl || '').trim();
+            if (databaseUrl) {
+                return databaseUrl;
+            }
+        }
+    }
+    async setGithubSecret(secretName, secretValue, repo) {
+        await this.runner.executeCommand(runner_service_1.ProgramName.GH, ['secret', 'set', secretName, '--repo', repo, '--body', secretValue], {}, true);
+    }
+    async promptToConfigureGithubSecrets(path, repo) {
+        const { configureSecrets } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'configureSecrets',
+                message: 'Would you like to configure the required GitHub secrets now?',
+                default: true,
+            },
+        ]);
+        if (!configureSecrets) {
+            console.log(chalk.yellow('\nGitHub secrets setup skipped. You can configure them later from DEPLOYMENT.md or by rerunning this command.\n'));
+            return;
+        }
+        console.log(chalk.blue.bold('\n🔐 GitHub Secrets Setup\n'));
+        await this.ensureGhAuthenticated();
+        const resolvedRepo = await this.resolveGithubRepository(path, repo);
+        const secretsConfig = {
+            databaseUrl: await this.promptForDatabaseUrl(),
+            jwtSecret: this.generateRandomHexSecret(32),
+            encryptionSecret: this.generateRandomBase64Secret(32),
+            pepper: this.generateRandomBase64Secret(16),
+        };
+        const maskedDatabaseUrl = this.maskDatabaseUrl(secretsConfig.databaseUrl);
+        console.log(chalk.gray(`Repository: ${chalk.cyan(resolvedRepo)}`));
+        console.log(chalk.white(`DATABASE_URL:      ${maskedDatabaseUrl}`));
+        console.log(chalk.white(`JWT_SECRET:        ${secretsConfig.jwtSecret.substring(0, 16)}... (64 chars hex)`));
+        console.log(chalk.white(`ENCRYPTION_SECRET: ${secretsConfig.encryptionSecret.substring(0, 16)}... (base64, 32 bytes)`));
+        console.log(chalk.white(`PEPPER:            ${secretsConfig.pepper.substring(0, 8)}... (base64, 16 bytes)`));
+        console.log('');
+        const { confirmed } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'confirmed',
+                message: 'Proceed with overwriting these GitHub secrets?',
+                default: true,
+            },
+        ]);
+        if (!confirmed) {
+            console.log(chalk.yellow('\nGitHub secrets setup cancelled.\n'));
+            return;
+        }
+        const spinner = ora('Configuring GitHub secrets...').start();
+        try {
+            await this.setGithubSecret('DATABASE_URL', secretsConfig.databaseUrl, resolvedRepo);
+            await this.setGithubSecret('JWT_SECRET', secretsConfig.jwtSecret, resolvedRepo);
+            await this.setGithubSecret('ENCRYPTION_SECRET', secretsConfig.encryptionSecret, resolvedRepo);
+            await this.setGithubSecret('PEPPER', secretsConfig.pepper, resolvedRepo);
+            spinner.succeed(chalk.green(`GitHub secrets configured successfully for ${resolvedRepo}.`));
+            console.log(chalk.gray(`Verify with: gh secret list --repo ${resolvedRepo}`));
+            console.log('');
+        }
+        catch (error) {
+            spinner.fail('Failed to configure GitHub secrets.');
+            throw error;
+        }
+    }
     async checkHelm() {
         const result = await this.runner.executeCommand(runner_service_1.ProgramName.HELM, ['version', '--short'], {}, true);
         // Extract version (handles both --short and regular output)
@@ -1516,7 +1656,7 @@ temp
         console.log(chalk.blue.bold('\n📖 Next Steps:\n'));
         console.log(chalk.white('1. Review the generated files in your project'));
         console.log(chalk.white('2. Read DEPLOYMENT.md for setup instructions'));
-        console.log(chalk.white('3. Configure GitHub secrets (see DEPLOYMENT.md)'));
+        console.log(chalk.white('3. Configure GitHub secrets now with this CLI or follow DEPLOYMENT.md'));
         console.log(chalk.white(`4. Push to ${config.deployBranch || 'production'} branch to trigger deployment`));
         if ((config.infraServices || []).length > 0) {
             console.log('');
@@ -1850,116 +1990,21 @@ temp
         this.verbose = verbose;
         const spinner = ora('Updating bootstrap files...').start();
         try {
-            path = await this.getRootPath(path);
-            const templatePath = pathModule.join(pathModule.dirname(path), 'template');
-            this.log(chalk.blue(`Source path: ${path}`));
-            this.log(chalk.blue(`Template path: ${templatePath}`));
-            // Clean template directory but keep .git
-            spinner.start('Cleaning template directory...');
-            if ((0, fs_1.existsSync)(templatePath)) {
-                const gitPath = pathModule.join(templatePath, '.git');
-                const hasGit = (0, fs_1.existsSync)(gitPath);
-                // Remove all items except .git directory
-                const entries = (0, fs_1.readdirSync)(templatePath, { withFileTypes: true });
-                for (const entry of entries) {
-                    if (entry.name === '.git') {
-                        this.log(chalk.gray('Skipping .git directory'));
-                        continue;
-                    }
-                    const fullPath = pathModule.join(templatePath, entry.name);
-                    await this.fileSystem.remove(fullPath);
-                    this.log(chalk.gray(`Removed: ${entry.name}`));
-                }
-                this.log(chalk.gray('Cleaned template directory (preserved .git)'));
-            }
-            else {
-                await (0, promises_1.mkdir)(templatePath, { recursive: true });
-                this.log(chalk.blue('Template directory created.'));
-            }
-            spinner.succeed('Template directory cleaned.');
-            // Get all files tracked by git (respects .gitignore)
-            spinner.start('Getting list of files from repository...');
-            const result = await this.runner.executeCommand(runner_service_1.ProgramName.GIT, ['ls-files'], { cwd: path }, true);
-            const allFiles = result.stdout
-                .trim()
-                .split('\n')
-                .filter((f) => f.length > 0);
-            spinner.succeed(`Found ${allFiles.length} files in repository.`);
-            spinner.start('Filtering files...');
-            // Filter files from apps folder - only keep api and admin
-            const allowedAppsFolders = ['api', 'admin'];
-            const ignoredAppsFolders = new Set();
-            const files = allFiles.filter((file) => {
-                // Check if file is in apps directory
-                if (file.startsWith('apps/') || file.startsWith('apps\\')) {
-                    const parts = file.split(/[/\\]/);
-                    if (parts.length > 1) {
-                        const appFolder = parts[1];
-                        if (!allowedAppsFolders.includes(appFolder)) {
-                            ignoredAppsFolders.add(appFolder);
-                            return false;
-                        }
-                    }
-                }
-                return true;
-            });
-            spinner.succeed('Files filtered.');
-            // Display ignored folders
-            if (ignoredAppsFolders.size > 0) {
-                spinner.info(chalk.blue(`Ignored apps folders: ${Array.from(ignoredAppsFolders).join(', ')}`));
-                spinner.start('Copying files...');
-            }
-            this.log(chalk.blue(`Found ${files.length} files to copy (${allFiles.length - files.length} files ignored)`));
-            // Copy each file maintaining directory structure
-            spinner.start('Copying files...');
-            let copiedCount = 0;
-            for (const file of files) {
-                const sourcePath = pathModule.join(path, file);
-                const destPath = pathModule.join(templatePath, file);
-                // Create directory if it doesn't exist
-                const destDir = pathModule.dirname(destPath);
-                if (!(0, fs_1.existsSync)(destDir)) {
-                    await (0, promises_1.mkdir)(destDir, { recursive: true });
-                }
-                // Copy file
-                await this.fileSystem.copyFile(sourcePath, destPath);
-                copiedCount++;
-                if (verbose && copiedCount % 100 === 0) {
-                    spinner.text = `Copying files... (${copiedCount}/${files.length})`;
-                }
-            }
-            // Commit and push changes to git
-            spinner.start('Committing changes to git...');
-            try {
-                await this.runner.executeCommand(runner_service_1.ProgramName.GIT, ['add', '.'], { cwd: templatePath }, true);
-                // Check if there are changes to commit
-                const statusResult = await this.runner.executeCommand(runner_service_1.ProgramName.GIT, ['status', '--porcelain'], { cwd: templatePath }, true);
-                if (statusResult.stdout.trim().length > 0) {
-                    const now = new Date();
-                    const dateStr = now.toLocaleDateString('en-US', {
-                        year: 'numeric',
-                        month: 'short',
-                        day: 'numeric',
-                    });
-                    const timeStr = now.toLocaleTimeString('en-US', {
-                        hour: '2-digit',
-                        minute: '2-digit',
-                    });
-                    const commitMessage = `chore: update bootstrap files - ${dateStr} at ${timeStr}`;
-                    await this.runner.executeCommand(runner_service_1.ProgramName.GIT, ['commit', '-m', commitMessage], { cwd: templatePath }, true);
-                    spinner.text = 'Pushing changes to remote repository...';
-                    await this.runner.executeCommand(runner_service_1.ProgramName.GIT, ['push'], { cwd: templatePath }, true);
-                    spinner.succeed(`Bootstrap files updated successfully. ${copiedCount} files copied and pushed to ${templatePath}`);
-                }
-                else {
-                    spinner.succeed(`Bootstrap files updated successfully. ${copiedCount} files copied (no changes to commit)`);
-                }
-            }
-            catch (gitError) {
-                spinner.warn(`Bootstrap files copied (${copiedCount} files) but git operations failed. You may need to commit manually.`);
-                this.log(chalk.yellow('Git error:'), gitError.message);
-            }
-            this.log(chalk.green(`Successfully copied ${copiedCount} files to template directory.`));
+            spinner.text = 'Resolving project root...';
+            const sourcePath = await this.resolveBootstrapSourceRoot(path);
+            const suggestedTemplatePath = pathModule.join(pathModule.dirname(sourcePath), 'template');
+            this.log(chalk.blue(`Source path: ${sourcePath}`));
+            this.log(chalk.blue(`Suggested template path: ${suggestedTemplatePath}`));
+            spinner.stop();
+            const templatePath = await this.promptForBootstrapDestination(suggestedTemplatePath, sourcePath);
+            this.log(chalk.blue(`Confirmed template path: ${templatePath}`));
+            spinner.start('Synchronizing project files to template...');
+            const { copiedCount, deletedCount } = await this.syncBootstrapMirror(sourcePath, templatePath);
+            spinner.succeed(`Template synchronized successfully. ${copiedCount} files copied and ${deletedCount} obsolete entries removed.`);
+            spinner.stop();
+            await this.ensureBootstrapResetState(templatePath);
+            await this.resetDevelopmentEnvironment(templatePath, verbose);
+            console.log(chalk.green(`Bootstrap files updated successfully. Source: ${sourcePath} | Destination: ${templatePath}`));
         }
         catch (error) {
             spinner.fail('Failed to update bootstrap files.');
@@ -1971,6 +2016,159 @@ temp
             spinner.stop();
         }
     }
+    async resolveBootstrapSourceRoot(cwd) {
+        try {
+            const result = await this.runner.executeCommand(runner_service_1.ProgramName.GIT, ['rev-parse', '--show-toplevel'], { cwd }, true);
+            const gitRoot = result.stdout.trim();
+            if (gitRoot) {
+                return pathModule.resolve(gitRoot);
+            }
+        }
+        catch (error) {
+            this.log(chalk.yellow('Could not resolve git root. Falling back to the current working directory.'));
+        }
+        return pathModule.resolve(cwd);
+    }
+    validateBootstrapDestinationPath(templatePath, sourcePath) {
+        const trimmedPath = templatePath.trim();
+        if (!trimmedPath) {
+            return 'Informe o path absoluto do template.';
+        }
+        if (!pathModule.isAbsolute(trimmedPath)) {
+            return 'Informe um caminho absoluto.';
+        }
+        const resolvedPath = pathModule.resolve(trimmedPath);
+        if (!(0, fs_1.existsSync)(resolvedPath)) {
+            return `A pasta "${resolvedPath}" não existe.`;
+        }
+        if (!(0, fs_1.statSync)(resolvedPath).isDirectory()) {
+            return `O caminho "${resolvedPath}" não é uma pasta válida.`;
+        }
+        const relativeToSource = pathModule.relative(sourcePath, resolvedPath);
+        if (relativeToSource === '' ||
+            (!relativeToSource.startsWith('..') &&
+                !pathModule.isAbsolute(relativeToSource))) {
+            return 'O destino não pode ser o mesmo diretório do projeto atual nem ficar dentro dele.';
+        }
+        const relativeFromDestination = pathModule.relative(resolvedPath, sourcePath);
+        if (relativeFromDestination === '' ||
+            (!relativeFromDestination.startsWith('..') &&
+                !pathModule.isAbsolute(relativeFromDestination))) {
+            return 'O destino não pode conter o projeto atual.';
+        }
+        return true;
+    }
+    async promptForBootstrapDestination(suggestedTemplatePath, sourcePath) {
+        const resolvedSuggestion = pathModule.resolve(suggestedTemplatePath);
+        const suggestedPathExists = (0, fs_1.existsSync)(resolvedSuggestion) &&
+            (0, fs_1.statSync)(resolvedSuggestion).isDirectory();
+        if (suggestedPathExists) {
+            const { confirmed } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirmed',
+                    message: `Destino encontrado: ${resolvedSuggestion}. Confirmar?`,
+                    default: true,
+                },
+            ]);
+            if (confirmed) {
+                return resolvedSuggestion;
+            }
+        }
+        else {
+            console.log(chalk.yellow(`A pasta template padrão não foi encontrada em: ${resolvedSuggestion}`));
+        }
+        while (true) {
+            const { templatePath } = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'templatePath',
+                    message: 'Informe o path absoluto correto do template:',
+                    validate: (input) => this.validateBootstrapDestinationPath(input, sourcePath),
+                },
+            ]);
+            const resolvedTemplatePath = pathModule.resolve(templatePath.trim());
+            const { confirmed } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirmed',
+                    message: `Usar este destino: ${resolvedTemplatePath}?`,
+                    default: true,
+                },
+            ]);
+            if (confirmed) {
+                return resolvedTemplatePath;
+            }
+        }
+    }
+    shouldIgnoreBootstrapEntry(entryName) {
+        return this.bootstrapIgnoredEntries.has(entryName);
+    }
+    async syncBootstrapMirror(sourcePath, destinationPath) {
+        await (0, promises_1.mkdir)(destinationPath, { recursive: true });
+        const sourceEntries = await (0, promises_1.readdir)(sourcePath, { withFileTypes: true });
+        const destinationEntries = await (0, promises_1.readdir)(destinationPath, {
+            withFileTypes: true,
+        });
+        const sourceEntryMap = new Map(sourceEntries
+            .filter((entry) => !this.shouldIgnoreBootstrapEntry(entry.name))
+            .map((entry) => [entry.name, entry]));
+        let copiedCount = 0;
+        let deletedCount = 0;
+        for (const destinationEntry of destinationEntries) {
+            if (destinationEntry.name === '.git') {
+                continue;
+            }
+            if (!sourceEntryMap.has(destinationEntry.name)) {
+                await this.fileSystem.remove(pathModule.join(destinationPath, destinationEntry.name));
+                deletedCount++;
+            }
+        }
+        for (const sourceEntry of sourceEntries) {
+            if (this.shouldIgnoreBootstrapEntry(sourceEntry.name)) {
+                continue;
+            }
+            const sourceEntryPath = pathModule.join(sourcePath, sourceEntry.name);
+            const destinationEntryPath = pathModule.join(destinationPath, sourceEntry.name);
+            const destinationExists = (0, fs_1.existsSync)(destinationEntryPath);
+            if (sourceEntry.isDirectory()) {
+                if (destinationExists &&
+                    !(0, fs_1.statSync)(destinationEntryPath).isDirectory()) {
+                    await this.fileSystem.remove(destinationEntryPath);
+                    deletedCount++;
+                }
+                const nestedResult = await this.syncBootstrapMirror(sourceEntryPath, destinationEntryPath);
+                copiedCount += nestedResult.copiedCount;
+                deletedCount += nestedResult.deletedCount;
+                continue;
+            }
+            if (!sourceEntry.isFile()) {
+                this.log(chalk.yellow(`Skipping unsupported entry type: ${sourceEntryPath}`));
+                continue;
+            }
+            if (destinationExists && (0, fs_1.statSync)(destinationEntryPath).isDirectory()) {
+                await this.fileSystem.remove(destinationEntryPath);
+                deletedCount++;
+            }
+            await (0, promises_1.mkdir)(pathModule.dirname(destinationEntryPath), {
+                recursive: true,
+            });
+            await (0, promises_1.copyFile)(sourceEntryPath, destinationEntryPath);
+            copiedCount++;
+        }
+        return { copiedCount, deletedCount };
+    }
+    async ensureBootstrapResetState(templatePath) {
+        const hedhogFilePath = pathModule.join(templatePath, 'hedhog.json');
+        if (!(0, fs_1.existsSync)(hedhogFilePath)) {
+            await this.fileSystem.writeJsonFile(hedhogFilePath, {
+                libraries: [],
+                installed: false,
+                developerMode: false,
+                buildCache: {},
+            });
+        }
+    }
     async route(path, verbose = false) {
         const restoreWarnings = this.suppressWarnings();
         this.verbose = verbose;