@common-stack/generate-plugin 7.0.4-alpha.0 → 7.0.4-alpha.10

package/src/generators/add-fullstack/files/package.json

@@ -52,7 +52,6 @@
         "devpublish:push": "yarn predevpublish && git push origin $PUBLISH_BRANCH && yarn postdevpublish",
         "format": "yarn lint --fix",
         "format:md": "yarn lint:md --fix",
-        "pregenerateGraphql": " node --experimental-modules tools/codegenGenerator.mjs",
         "generateGraphql": "graphql-codegen-esm",
         "postgenerateGraphql": "lerna run watch --scope=common",
         "generateGraphql:watch": "yarn generateGraphql -- --watch",
@@ -77,6 +76,7 @@
         "publish:forceManual": "yarn lernapublish --force-publish=*",
         "publish:push": "yarn prelernapublish && git push origin publish && yarn postlernapublish",
         "push-develop": "git push origin develop",
+        "regenerateGraphql": " node --experimental-modules tools/codegenGenerator.mjs",
         "setBranchEnv": "cross-env REPOSITORY_BRANCH=${1:-$REPOSITORY_BRANCH} PUBLISH_BRANCH=${2:-$PUBLISH_BRANCH}",
         "sort-packages": "node tools/sortPackageJson.mjs && prettier --write package.json **/**/*/package.json **/*/package.json",
         "start": "cross-env NODE_ENV=development ENV_FILE=../../config/development/dev.env yarn startWeb",
@@ -98,12 +98,6 @@
         "zen:watch": "zen  watch -x",
         "zen:watch:debug": "yarn zen:watch -- -v"
     },
-    "husky": {
-        "hooks": {
-            "pre-commit": "lint-staged",
-            "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
-        }
-    },
     "resolutions": {
         "@apollo/client": "^3.9.0",
         "@nx/workspace": "20.4.3",
@@ -150,9 +144,9 @@
         "@babel/preset-typescript": "^7.18.6",
         "@babel/register": "^7.18.9",
         "@babel/runtime": "^7.20.1",
-        "@common-stack/env-list-loader": "6.0.8-alpha.31",
-        "@common-stack/generate-plugin": "7.0.3-alpha.2",
-        "@common-stack/rollup-vite-utils": "7.0.3-alpha.2",
+        "@common-stack/env-list-loader": "7.0.4-alpha.0",
+        "@common-stack/generate-plugin": "7.0.4-alpha.9",
+        "@common-stack/rollup-vite-utils": "7.0.4-alpha.8",
         "@emotion/babel-plugin": "^11.11.0",
         "@graphql-codegen/add": "^5.0.3",
         "@graphql-codegen/cli": "^5.0.4",

package/src/generators/add-fullstack/files/rollup.config.base.mjs

@@ -2,16 +2,22 @@
 import graphql from '@rollup/plugin-graphql';
 import image from '@rollup/plugin-image';
 import typescript from '@rollup/plugin-typescript';
+import esbuild from 'rollup-plugin-esbuild'
 import { string } from 'rollup-plugin-string';
 import svg from 'rollup-plugin-svg';
 import { copy } from '@web/rollup-plugin-copy';
+import json from '@rollup/plugin-json';
 import modifyLibFilesPlugin from '@common-stack/rollup-vite-utils/lib/rollup/rollupPluginModifyLibFiles.js';
 import generateJsonFromObject from '@common-stack/rollup-vite-utils/lib/rollup/rollupPluginGenerateJson.js';
 import addJsExtensionToImportsPlugin from '@common-stack/rollup-vite-utils/lib/rollup/rollupPluginAddJsExtension.js';
 import { ignoreCssUrlPlugin } from '@common-stack/rollup-vite-utils/lib/rollup/pluginIgnore.js';
 // Define any additional plugins specific to this bundle
 const additionalPlugins = [
-    copy({ patterns: ['**/cdm-locales/**/*', '**/*.gql', '**/**/*.graphql', '**/styles/**/*', '**/css/**/*'], rootDir: './src' }),
+    copy({
+        patterns: ['**/cdm-locales/**/*', '**/*.gql', '**/**/*.graphql', '**/styles/**/*', '**/templates/**/*', '**/css/**/*'],
+        rootDir: './src',
+    }),
+    json(),
 ];
 
 function deepMergeConfigs(baseConfig, specificConfig) {
@@ -35,39 +41,55 @@ const baseConfig = {
             include: ['**/*.ejs', '**/*.graphql'],
         }),
         addJsExtensionToImportsPlugin({
-            packages: '*',
-            needToAddIndexJs: [],
+            packages: ['@react-icons/all-files', '@apollo/client', '@vscode-alt/monaco-editor'],
+            needToAddIndexJs: ['@apollo/client'],
             excludeImports: ['@emotion/react/jsx-runtime'],
         }),
-        typescript(), // TypeScript at the top as per best practices
+        typescript(), // Initially include the TypeScript plugin
         ignoreCssUrlPlugin(),
-        modifyLibFilesPlugin({
-            include: ['**/**/compute.js'], // Adjust to target specific files or patterns
-            outputDir: 'lib', // Ensure this matches your actual output directory
-        }),
-        generateJsonFromObject({}),
-
         ...additionalPlugins,
     ],
     external: (id) => !/^[./]/.test(id),
     globals: { react: 'React' },
 };
 
-// Function to create a configuration by extending the base
-function createRollupConfig(overrides, isWatchMode = false) {
-    const config = deepMergeConfigs(baseConfig, overrides);
+// Updated createRollupConfig function to accept an options object as the second parameter.
+// If useEsbuild is true, the TypeScript plugin is removed completely and replaced with the esbuild plugin.
+function createRollupConfig(specificOverrides, options = {}) {
+    const { useEsbuild, isWatchMode, generateRoutesJSON } = options;
+    const config = deepMergeConfigs(baseConfig, specificOverrides);
 
-    // Adjust TypeScript plugin based on watch mode
-    config.plugins = config.plugins.map((plugin) => {
-        if (plugin.name === 'typescript') {
-            return typescript({
-                ...plugin.options,
-                noEmitOnError: !isWatchMode, // Set to false only in watch mode
-            });
-        }
-        return plugin;
-    });
+    // Conditionally add both modifyLibFilesPlugin and generateJsonFromObject plugins if generateRoutesJSON option is provided.
+    if (generateRoutesJSON) {
+        // Add modifyLibFilesPlugin with predetermined configuration.
+        config.plugins.push(modifyLibFilesPlugin({
+            include: ['**/**/compute.js'], // Adjust to target specific files or patterns
+            outputDir: 'lib',              // Ensure this matches your actual output directory
+        }));
+        // Allow generateRoutesJSON to be an object with plugin configuration or simply a boolean.
+        const jsonConfig = typeof generateRoutesJSON === 'object' ? generateRoutesJSON : {};
+        config.plugins.push(generateJsonFromObject(jsonConfig));
+    }
 
+    if (useEsbuild) {
+        // Remove the TypeScript plugin completely.
+        config.plugins = config.plugins.filter((plugin) => plugin.name !== 'typescript');
+        // Add the esbuild plugin only. Note: The "watch" option is removed as it's not supported by esbuild.
+        config.plugins.push(esbuild({
+            target: 'es2017', // Adjust the target as needed
+        }));
+    } else {
+        // Retain the TypeScript plugin and adjust its options based on watch mode.
+        config.plugins = config.plugins.map((plugin) => {
+            if (plugin.name === 'typescript') {
+                return typescript({
+                    ...plugin.options,
+                    noEmitOnError: !isWatchMode, // Adjust based on watch mode
+                });
+            }
+            return plugin;
+        });
+    }
     return config;
 }
 

package/src/generators/add-fullstack/generator.spec.ts

@@ -1,3 +1,4 @@
+import { beforeEach, describe, expect, it } from '@jest/globals';
 import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing';
 import { Tree, readProjectConfiguration } from '@nx/devkit';
 
@@ -15,6 +16,7 @@ describe('add-fullstack generator', () => {
     it('should run successfully', async () => {
         await addFullstackGenerator(tree, options);
         const config = readProjectConfiguration(tree, 'test');
+
         expect(config).toBeDefined();
     });
 });

package/src/generators/add-fullstack/generator.ts

@@ -1,11 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable import/no-cycle */
-import { addProjectConfiguration, formatFiles, generateFiles, Tree } from '@nx/devkit';
+import { formatFiles, generateFiles, Tree, updateJson } from '@nx/devkit';
 import * as path from 'path';
 import * as fs from 'fs';
 import { AddFullstackGeneratorSchema } from './schema';
 import { getValid, isValid } from '../../utils';
-import { 
+import {
     updateJenkinsFile,
     updatePackageJson,
     backupLernaJson,
@@ -15,15 +15,24 @@ import {
     backupFiles,
     restoreFiles,
     updateRepository,
+    renameDotFiles,
+    setupGit,
+    commitInitialFiles,
+    setupGitCrypt,
+    setupHusky,
+    prepareGitAttributes,
+    setupNpmAuth,
+    setupNxConfig,
 } from './updates';
-import {
-    generateBackend,
-    generateFrontend,
-    generateMoleculer,
-    generatePackage,
-} from '../../index';
+import { addBackendGenerator as generateBackend } from '../add-backend/generator';
+import { addFrontendGenerator as generateFrontend } from '../add-frontend/generator';
+import { addMoleculerGenerator as generateMoleculer } from '../add-moleculer/generator';
+import { addPackageGenerator as generatePackage } from '../add-package/generator';
 
 export async function addFullstackGenerator(tree: Tree, options: AddFullstackGeneratorSchema) {
+    // Immediately set the environment variable to skip NX config
+    process.env.SKIP_NX_CONFIG = 'true';
+
     let projectPath = options.path || '';
     if (projectPath !== '') {
         const basePath = process.cwd();
@@ -37,31 +46,37 @@ export async function addFullstackGenerator(tree: Tree, options: AddFullstackGen
     // backup existing lerna values
     const lernaBackup = backupLernaJson(tree, projectRoot);
 
-    // backup files codegen.yaml
-    const filesToBackup = ['codegen.yml', 'values-dev.yaml', 'values-prod.yaml', 'values-stage.yaml'];
+    // backup files including codegen.ts (instead of codegen.yml)
+    const filesToBackup = ['codegen.ts', 'values-dev.yaml', 'values-prod.yaml', 'values-stage.yaml'];
     const filesBackup = backupFiles(tree, projectRoot, filesToBackup);
 
     generateFiles(tree, path.join(__dirname, 'files'), projectRoot, options);
 
-    // Update Jenkinsfile with dynamic values
-    updateJenkinsFile(tree, projectRoot, projectName);
+    // Rename files that begin with underscore to dot files
+    renameDotFiles(tree, projectRoot);
 
-    // Update package.json with the project name
-    updatePackageJson(tree, projectRoot, { name: projectName });
+    // Handle gitattributes file (Tree-phase)
+    prepareGitAttributes(tree, projectRoot);
 
-    // Update tools/html-plugin-template
+    // First update files in the tree
+    updateJenkinsFile(tree, projectRoot, projectName);
+    updatePackageJson(tree, projectRoot, { name: projectName });
     updateHtmlPlugin(tree, projectRoot);
 
     if (lernaBackup) {
-        // When update the existing lerna.json, it shouldn't overwrite version, allowbranch, packages
         restoreLernaJson(tree, projectRoot, lernaBackup);
     }
 
-    // Restore files backup to ignore update
     restoreFiles(tree, projectRoot, filesBackup);
+    updateLicense(tree, projectRoot);
 
+    // Format all files
     await formatFiles(tree);
 
+    // Set a flag to perform Git operations after files are written
+    const performGitOperations = true;
+
+    // Process configurations if needed
     if (isValid(options.config)) {
         const configPath = path.resolve(projectPath, getValid(options.config));
         if (fs.existsSync(configPath)) {
@@ -77,8 +92,53 @@ export async function addFullstackGenerator(tree: Tree, options: AddFullstackGen
         }
     }
 
-    // Update license from package.json
-    updateLicense(tree, projectRoot);
+    // Setup Nx config with AWS credentials
+    // Allow skipping via environment variable
+    if (options.skipNxConfig) {
+        process.env.SKIP_NX_CONFIG = 'true';
+    }
+    await setupNxConfig(tree, projectRoot);
+
+    // Setup git and commit files
+    setupGit(tree, projectRoot);
+
+    // Step 2: Set up git-crypt
+    setupGitCrypt(tree, projectRoot);
+
+    // Step 3: Set up npm authentication
+    setupNpmAuth(tree, projectRoot);
+
+    // Step 4: Set up husky
+    setupHusky(tree, projectRoot);
+
+    // Step 5: Commit all files (they will be encrypted if they match patterns in .gitattributes)
+    commitInitialFiles(projectRoot);
+
+    console.log('Git setup completed.');
+
+    // Return function to execute after all files are written to disk
+    if (performGitOperations) {
+        return () => {
+            console.log('All files have been generated. Now setting up Git...');
+
+            // Step 1: Initialize git repository
+            setupGit(tree, projectRoot);
+
+            // Step 2: Set up git-crypt
+            setupGitCrypt(tree, projectRoot);
+
+            // Step 3: Set up npm authentication
+            setupNpmAuth(tree, projectRoot);
+
+            // Step 4: Set up husky
+            setupHusky(tree, projectRoot);
+
+            // Step 5: Commit all files (they will be encrypted if they match patterns in .gitattributes)
+            commitInitialFiles(projectRoot);
+
+            console.log('Git setup completed.');
+        };
+    }
 }
 
 const generateServers = async (tree: Tree, options: any) => {
@@ -114,7 +174,7 @@ const generateModules = async (tree: Tree, options: any) => {
                 ns: options.ns,
                 type: packageName,
             };
-            await generatePackage(tree, configs, false);
+            await generatePackage(tree, configs);
         }
     }
 };

package/src/generators/add-fullstack/schema.d.ts

@@ -1,5 +1,5 @@
 export interface AddFullstackGeneratorSchema {
     name: string;
     config?: string;
-    path?: string;  // Optional path property for specifying the base path
-}
+    path?: string; // Optional path property for specifying the base path
+}

package/src/generators/add-fullstack/schema.ts

@@ -0,0 +1,10 @@
+export interface AddFullstackGeneratorSchema {
+    name?: string;
+    path?: string;
+    skipGit?: boolean;
+    skipGitCrypt?: boolean;
+    skipHusky?: boolean;
+    skipNxConfig?: boolean;
+    template?: string;
+    config?: any;
+}

package/src/generators/add-fullstack/updates/gitAttributesSetup.ts

@@ -0,0 +1,60 @@
+import { Tree } from '@nx/devkit';
+import * as path from 'path';
+import * as fs from 'fs';
+
+/**
+ * Renames _gitattributes to .gitattributes during the Tree modification phase
+ */
+export function prepareGitAttributes(tree: Tree, projectRoot: string) {
+    const gitattributesSrc = path.join(projectRoot, '_gitattributes');
+    const gitattributesDest = path.join(projectRoot, '.gitattributes');
+    
+    if (tree.exists(gitattributesSrc)) {
+        // Read content and write to destination
+        const content = tree.read(gitattributesSrc).toString();
+        tree.write(gitattributesDest, content);
+        // Remove the source file
+        tree.delete(gitattributesSrc);
+        console.log(`Renamed ${gitattributesSrc} to ${gitattributesDest}`);
+        return true;
+    }
+    
+    return false;
+}
+
+/**
+ * Updates .gitattributes with additional patterns if needed after files are on disk
+ */
+export function updateGitAttributes(projectRoot: string, attributesToAdd: Record<string, string>) {
+    try {
+        const gitattributesPath = path.join(projectRoot, '.gitattributes');
+        
+        if (!fs.existsSync(gitattributesPath)) {
+            console.log('.gitattributes file not found, skipping update');
+            return false;
+        }
+        
+        let gitattributesContent = fs.readFileSync(gitattributesPath, 'utf8');
+        let contentUpdated = false;
+        
+        // Add each attribute if not already present
+        Object.entries(attributesToAdd).forEach(([pattern, attribute]) => {
+            const attributeLine = `${pattern} ${attribute}`;
+            if (!gitattributesContent.includes(attributeLine)) {
+                contentUpdated = true;
+                gitattributesContent += `\n${attributeLine}`;
+            }
+        });
+        
+        // Write the file if we made changes
+        if (contentUpdated) {
+            fs.writeFileSync(gitattributesPath, gitattributesContent, 'utf8');
+            console.log('Updated .gitattributes file with additional patterns');
+        }
+        
+        return contentUpdated;
+    } catch (error) {
+        console.error('Error updating .gitattributes:', error);
+        return false;
+    }
+} 

package/src/generators/add-fullstack/updates/gitCryptSetup.ts

@@ -0,0 +1,77 @@
+import { Tree } from '@nx/devkit';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+
+/**
+ * Set up git-crypt for encrypting sensitive files
+ */
+export function setupGitCrypt(tree: Tree, projectRoot: string) {
+    try {
+        // Navigate to the project directory
+        const originalDir = process.cwd();
+        process.chdir(projectRoot);
+        
+        console.log('Setting up git-crypt in:', projectRoot);
+        
+        // Check if git-crypt is installed
+        try {
+            execSync('git-crypt --version', { stdio: 'ignore' });
+        } catch (error) {
+            console.log('git-crypt not found. Please install git-crypt to encrypt sensitive files.');
+            console.log('Continuing without git-crypt setup.');
+            process.chdir(originalDir);
+            return;
+        }
+        
+        // Check if git-crypt is already initialized
+        const gitCryptDir = path.join(projectRoot, '.git-crypt');
+        const gitCryptConfigExists = fs.existsSync(gitCryptDir);
+        
+        if (gitCryptConfigExists) {
+            console.log('git-crypt is already initialized for this repository');
+        } else {
+            // Initialize git-crypt
+            try {
+                execSync('git-crypt init', { stdio: 'inherit' });
+                console.log('git-crypt initialized');
+            } catch (error) {
+                console.error('Error initializing git-crypt:', error);
+                process.chdir(originalDir);
+                return;
+            }
+        }
+        
+        // Create keys directory if it doesn't exist
+        const keysDir = path.join(projectRoot, '.git-crypt', 'keys');
+        if (!fs.existsSync(keysDir)) {
+            fs.mkdirSync(keysDir, { recursive: true });
+        }
+        
+        // Generate and export a key for sharing only if it doesn't exist
+        const keyFile = path.join(keysDir, 'default-git-crypt-key');
+        if (!fs.existsSync(keyFile)) {
+            try {
+                execSync(`git-crypt export-key ${keyFile}`, { stdio: 'inherit' });
+                console.log(`Generated git-crypt key at: ${keyFile}`);
+                console.log('Keep this key secure and share it with team members who need access to encrypted files.');
+            } catch (error) {
+                console.error('Error exporting git-crypt key:', error);
+            }
+        } else {
+            console.log(`git-crypt key already exists at: ${keyFile}`);
+        }
+        
+        console.log('Git-crypt setup completed - sensitive files will be encrypted');
+        
+        // Return to original directory
+        process.chdir(originalDir);
+    } catch (error) {
+        console.error('Error setting up git-crypt:', error);
+        // Continue even if there's an error to not block the overall process
+        const originalDir = process.cwd();
+        if (originalDir !== projectRoot) {
+            process.chdir(originalDir);
+        }
+    }
+}

package/src/generators/add-fullstack/updates/gitSetup.ts

@@ -0,0 +1,63 @@
+import { Tree } from '@nx/devkit';
+import { execSync } from 'child_process';
+
+/**
+ * Sets up git repository in the project
+ */
+export function setupGit(tree: Tree, projectRoot: string) {
+    try {
+        // Navigate to the project directory
+        const originalDir = process.cwd();
+        process.chdir(projectRoot);
+        
+        console.log('Setting up git in:', projectRoot);
+        
+        // Initialize git repository
+        execSync('git init', { stdio: 'inherit' });
+        console.log('Git repository initialized');
+        
+        // Return to original directory
+        process.chdir(originalDir);
+    } catch (error) {
+        console.error('Error setting up git:', error);
+        // Continue even if there's an error to not block the overall process
+        const originalDir = process.cwd();
+        if (originalDir !== projectRoot) {
+            process.chdir(originalDir);
+        }
+    }
+}
+
+/**
+ * Commit all initial files to git
+ */
+export function commitInitialFiles(projectRoot: string) {
+    try {
+        // Navigate to the project directory
+        const originalDir = process.cwd();
+        process.chdir(projectRoot);
+        
+        console.log('Staging initial files...');
+        
+        try {
+            // Add all files
+            execSync('git add .', { stdio: 'inherit' });
+            
+            // Commit with --no-verify to bypass husky hooks
+            execSync('git commit -m "Initial commit from @common-stack/generate-plugin" --no-verify', { stdio: 'inherit' });
+            console.log('Initial commit created (bypassing pre-commit hooks)');
+        } catch (error) {
+            console.error('Error committing files:', error);
+        }
+        
+        // Return to original directory
+        process.chdir(originalDir);
+    } catch (error) {
+        console.error('Error during git commit process:', error);
+        // Continue even if there's an error to not block the overall process
+        const originalDir = process.cwd();
+        if (originalDir !== projectRoot) {
+            process.chdir(originalDir);
+        }
+    }
+}

package/src/generators/add-fullstack/updates/htmlPluginUpdate.ts

@@ -1,5 +1,6 @@
 import { Tree } from '@nx/devkit';
 import * as path from 'path';
+import * as fs from 'fs';
 
 export function updateHtmlPlugin(tree: Tree, projectRoot: string) {
     const filePath = path.join(projectRoot, 'tools', 'html-plugin-template.ejs');
@@ -9,3 +10,33 @@ export function updateHtmlPlugin(tree: Tree, projectRoot: string) {
         tree.write(filePath, newContents);
     }
 }
+
+export function renameDotFiles(tree: Tree, projectRoot: string) {
+    // List of files that need to be renamed from _name to .name
+    const dotFiles = [
+        { src: '_gitignore', dest: '.gitignore' },
+        { src: '_browserslistrc', dest: '.browserslistrc' },
+        { src: '_eslintignore', dest: '.eslintignore' },
+        { src: '_eslintrc.js', dest: '.eslintrc.js' },
+        { src: '_nxignore', dest: '.nxignore' },
+        { src: '_markdownlint.json', dest: '.markdownlint.json' },
+        { src: '_markdownlintignore', dest: '.markdownlintignore' },
+        { src: '_npmrc', dest: '.npmrc' },
+    ];
+
+    // Process each file
+    dotFiles.forEach(({ src, dest }) => {
+        const srcPath = path.join(projectRoot, src);
+        const destPath = path.join(projectRoot, dest);
+        
+        // Check if the source file exists
+        if (tree.exists(srcPath)) {
+            // Read content and write to destination
+            const content = tree.read(srcPath).toString();
+            tree.write(destPath, content);
+            // Remove the source file
+            tree.delete(srcPath);
+            console.log(`Renamed ${srcPath} to ${destPath}`);
+        }
+    });
+}

package/src/generators/add-fullstack/updates/huskySetup.ts

@@ -0,0 +1,84 @@
+import { Tree } from '@nx/devkit';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+
+export function setupHusky(tree: Tree, projectRoot: string) {
+    try {
+        // Navigate to the project directory
+        const originalDir = process.cwd();
+        process.chdir(projectRoot);
+        
+        console.log('Setting up husky in:', projectRoot);
+        
+        try {
+            // Initialize husky (creates .husky directory and prepares hooks)
+            execSync('npx husky init', { stdio: 'inherit' });
+            console.log('Husky initialized successfully');
+            
+            // Copy the husky hook files from _husky/ to .husky/
+            const sourceDir = path.join(projectRoot, '_husky');
+            const targetDir = path.join(projectRoot, '.husky');
+            
+            if (fs.existsSync(sourceDir) && fs.existsSync(targetDir)) {
+                // Read all files from _husky directory
+                const files = fs.readdirSync(sourceDir);
+                
+                // Copy each file to .husky directory
+                files.forEach(file => {
+                    const sourcePath = path.join(sourceDir, file);
+                    const targetPath = path.join(targetDir, file);
+                    
+                    if (fs.statSync(sourcePath).isFile()) {
+                        // Read content from our hook template
+                        const content = fs.readFileSync(sourcePath, 'utf8');
+                        
+                        // Remove any old shebang lines to avoid deprecation warnings
+                        const cleanContent = content
+                            .replace(/^#!\/usr\/bin\/env sh\n/, '')
+                            .replace(/^\. "\$\(dirname -- "\$0"\)\/\_\/husky\.sh"\n/, '')
+                            .trim();
+                        
+                        // Write the hook content
+                        fs.writeFileSync(targetPath, cleanContent, 'utf8');
+                        
+                        try {
+                            // Make the hook executable
+                            fs.chmodSync(targetPath, '755');
+                            console.log(`Made executable: ${file}`);
+                        } catch (error) {
+                            console.log(`Note: Could not set executable permissions for ${file}. This is normal on Windows.`);
+                        }
+                        
+                        console.log(`Copied: ${file} to .husky directory`);
+                    }
+                });
+                
+                // Remove the _husky directory after copying
+                try {
+                    fs.rmdirSync(sourceDir, { recursive: true });
+                    console.log('Removed _husky directory after copying');
+                } catch (error) {
+                    console.log('Could not remove _husky directory, but continuing...');
+                }
+            } else {
+                console.log('Source or target directory not found, skipping hook setup');
+            }
+            
+            console.log('Husky setup completed successfully');
+        } catch (error) {
+            console.error('Error running husky commands:', error);
+            console.log('Continuing despite husky setup failure');
+        }
+        
+        // Return to original directory
+        process.chdir(originalDir);
+    } catch (error) {
+        console.error('Error setting up husky:', error);
+        // Continue even if there's an error to not block the overall process
+        const originalDir = process.cwd();
+        if (originalDir !== projectRoot) {
+            process.chdir(originalDir);
+        }
+    }
+}