package-installer-cli 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 665501d841b7bce60cdb5917c5aa517e05236932dee2966958dc444fe0bf6108
-  data.tar.gz: ab2a5a999c255824b7c903ed2b46c0018e93c3bd08010d46e4970e43dfca80c3
+  metadata.gz: 7f432378951e281eb37210295d7894abbf072093bd9a2e6099f1d3219ad45eb0
+  data.tar.gz: 0e9edf8310281ce583765615d8d41f1897b7e0fab8e6cc3dbbfa405d39a63cc9
 SHA512:
-  metadata.gz: 41e9956c319e5df07d8fd65c81129fb00c65c4d4987d706b35e035c63e70b74a9b7f0172a36ee2d278da979b4bd683b3471a824e831afa7250cec4464abf69ab
-  data.tar.gz: c8fc5ea386fbc9e0eb4c3ebf7a7601db1ea47887378f06c6d4134e615356f920a27e038cdeb67e63d6d41692ed605382f530e0642015120048828d97cf2a81fe
+  metadata.gz: b0490199b16d2f27b1513fc9360895c02cb9a1a2fc58a4cddc5611c20afa21c8ef6e609d99b4dc7271a19de0ea21c1275127839d4b56b26b91e0554cff66c296
+  data.tar.gz: 6e7cec10cae328695c8fb9328797f5efc46ced7e04b0bb99dffe40ccbb887bc9ee495277b2ac49e5196e88f98e6a71a2cec823ad4ec692ee78424ce5cc3b5d53

data/CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to the Package Installer CLI Ruby gem will be documented in
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.0] - 2025-09-23
+
+### Updated
+- Version bump to 1.1.0
+- Improved gem packaging and file inclusion
+- Enhanced security with comprehensive .gitignore rules
+- Updated documentation and README
+
 ## [1.0.0] - 2025-09-20
 
 ### Added

data/dist/commands/add.js

@@ -4,50 +4,10 @@ import gradient from 'gradient-string';
 import boxen from 'boxen';
 import path from 'path';
 import fs from 'fs-extra';
-import { fileURLToPath } from 'url';
-import { addFeature, detectProjectStack, SUPPORTED_FEATURES, getCliRootPath } from '../utils/featureInstaller.js';
+import { addFeature, detectProjectStack, SUPPORTED_FEATURES } from '../utils/featureInstaller.js';
 import { historyManager } from '../utils/historyManager.js';
 import { getCachedProject, cacheProjectData } from '../utils/cacheManager.js';
-/**
- * Resolve CLI installation paths for both local and global installations
- */
-function resolveCLIPath() {
-    // Get the current file's directory
-    const currentFile = fileURLToPath(import.meta.url);
-    const currentDir = path.dirname(currentFile);
-    // Try to find package root by looking for package.json
-    let packageRoot = currentDir;
-    while (packageRoot !== path.dirname(packageRoot)) {
-        const packageJsonPath = path.join(packageRoot, 'package.json');
-        if (fs.existsSync(packageJsonPath)) {
-            try {
-                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-                if (packageJson.name === '@0xshariq/package-installer') {
-                    return packageRoot;
-                }
-            }
-            catch (error) {
-                // Continue searching
-            }
-        }
-        packageRoot = path.dirname(packageRoot);
-    }
-    // Fallback: use current working directory if we're in development
-    if (fs.existsSync(path.join(process.cwd(), 'features'))) {
-        return process.cwd();
-    }
-    // Final fallback: try node_modules resolution
-    try {
-        const nodeModulesPath = path.join(currentDir, '../../../');
-        if (fs.existsSync(path.join(nodeModulesPath, 'features'))) {
-            return nodeModulesPath;
-        }
-    }
-    catch (error) {
-        // Ignore
-    }
-    return process.cwd();
-}
+import { getFeaturesJsonPath, getFeaturesPath } from '../utils/pathResolver.js';
 /**
  * Helper function to capitalize strings
  */
@@ -59,13 +19,12 @@ function capitalize(str) {
  */
 function getFeaturesConfig() {
     try {
-        // Get the CLI root path
-        const cliRoot = getCliRootPath();
-        const featuresPath = path.join(cliRoot, 'features', 'features.json');
+        // Use the centralized path resolver
+        const featuresPath = getFeaturesJsonPath();
         if (fs.existsSync(featuresPath)) {
             return JSON.parse(fs.readFileSync(featuresPath, 'utf-8'));
         }
-        console.warn(chalk.yellow('⚠️  features.json not found, using fallback'));
+        console.warn(chalk.yellow(`⚠️  features.json not found at: ${featuresPath}`));
         return { features: {} };
     }
     catch (error) {
@@ -404,15 +363,14 @@ export async function addCommand(feature, provider, options = {}) {
             console.log(chalk.green(`✅ Detected ${projectInfo.framework} project (${projectInfo.projectLanguage || projectInfo.language})`));
         }
         // Validate that framework features exist in features directory
-        const cliRoot = getCliRootPath();
-        const frameworkFeaturesPath = path.join(cliRoot, 'features');
+        const frameworkFeaturesPath = getFeaturesPath();
         if (!await fs.pathExists(frameworkFeaturesPath)) {
             console.log(chalk.red('❌ Features directory not found'));
             console.log(chalk.yellow('💡 Make sure you\'re running this from the Package Installer CLI root directory'));
             return;
         }
         // Load features configuration
-        const featuresConfigPath = path.join(frameworkFeaturesPath, 'features.json');
+        const featuresConfigPath = getFeaturesJsonPath();
         if (!await fs.pathExists(featuresConfigPath)) {
             console.log(chalk.red('❌ Features configuration not found'));
             return;

data/dist/index.js

@@ -18,17 +18,24 @@ import { deployCommand } from './commands/deploy.js';
 import { cleanCommand, showCleanHelp } from './commands/clean.js';
 import { environmentCommand, showEnvironmentHelp } from './commands/env.js';
 import { doctorCommand, showDoctorHelp } from './commands/doctor.js';
-// Import utilities
-import { showBanner } from './utils/ui.js';
 import { initializeCache } from './utils/cacheManager.js';
+import { displayBanner, displayCommandBanner } from './utils/banner.js';
+import { getPackageJsonPath } from './utils/pathResolver.js';
 // Get current file directory for ESM
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-// Load package.json to get version
-let packageJsonPath = join(__dirname, '../package.json');
-// Check if we're running from dist folder
-if (__dirname.includes('/dist/')) {
-    packageJsonPath = join(__dirname, '../../package.json');
+// Load package.json to get version using improved path resolution
+let packageJsonPath;
+try {
+    packageJsonPath = getPackageJsonPath();
+}
+catch (error) {
+    // Fallback to the old method if getPackageJsonPath fails
+    packageJsonPath = join(__dirname, '../package.json');
+    // Check if we're running from dist folder
+    if (__dirname.includes('/dist/')) {
+        packageJsonPath = join(__dirname, '../../package.json');
+    }
 }
 const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
 const VERSION = packageJson.version;
@@ -74,7 +81,7 @@ program
 })
     .action(async (projectName) => {
     try {
-        showBanner();
+        displayCommandBanner('create', 'Create a new project from templates');
         await createProject(projectName);
     }
     catch (error) {
@@ -206,7 +213,7 @@ program
 })
     .action(async (options) => {
     try {
-        showBanner();
+        displayCommandBanner('clean', 'Clean development artifacts and caches');
         await cleanCommand(options);
     }
     catch (error) {
@@ -336,7 +343,7 @@ program.on('--help', () => {
 });
 // ENHANCED DEFAULT BEHAVIOR - Beautiful banner and help when no command provided
 if (process.argv.length === 2) {
-    showBanner();
+    displayBanner();
     console.log('\n' + boxen(chalk.white('Welcome to Package Installer CLI! 👋') + '\n\n' +
         chalk.hex('#00d2d3')('🚀 Ready to build something amazing?') + '\n\n' +
         chalk.hex('#95afc0')('Start with these popular commands:') + '\n\n' +

data/dist/utils/banner.js

@@ -5,6 +5,7 @@
 import chalk from 'chalk';
 import gradient from 'gradient-string';
 import boxen from 'boxen';
+import { getPackageVersion } from './utils.js';
 /**
  * Generate the main CLI banner with gradient colors
  */
@@ -40,7 +41,8 @@ export function generateBanner() {
  * Generate version info banner
  */
 export function generateVersionBanner() {
-    return boxen(chalk.hex('#00d2d3')('📦 Version: ') + chalk.hex('#ffa502')('v3.2.0') +
+    const version = getPackageVersion();
+    return boxen(chalk.hex('#00d2d3')('📦 Version: ') + chalk.hex('#ffa502')(`v${version}`) +
         chalk.hex('#95afc0')('  •  ') + chalk.hex('#00d2d3')('🎯 Frameworks: ') + chalk.hex('#ffa502')('12+') +
         chalk.hex('#95afc0')('  •  ') + chalk.hex('#00d2d3')('📋 Templates: ') + chalk.hex('#ffa502')('50+') +
         chalk.hex('#95afc0')('  •  ') + chalk.hex('#00d2d3')('⚡ Status: ') + chalk.hex('#10ac84')('Ready to scaffold!'), {

data/dist/utils/cacheUtils.js

@@ -1,5 +1,5 @@
 /**
- * Enhanced Cache Utility for Package Installer CLI v3.0.0
+ * Enhanced Cache Utility for Package Installer CLI v3.2.0
  * Advanced caching system with compression, encryption, and smart invalidation
  */
 import fs from 'fs-extra';

data/dist/utils/dashboard.js

@@ -35,7 +35,7 @@ export function createBanner(title = 'Package Installer CLI') {
     console.log(banner);
     // Add tagline with updated branding
     const tagline = chalk.hex('#00d2d3')('🚀 Advanced Project Analytics Dashboard');
-    const version = chalk.hex('#95afc0')('v3.0.0');
+    const version = chalk.hex('#95afc0')('v3.2.0');
     const author = chalk.hex('#ffa502')('by @0xshariq');
     const centered = `${tagline} ${version} ${author}`;
     const padding = Math.max(0, Math.floor(((process.stdout.columns || 80) - centered.length) / 2));

data/dist/utils/dependencyInstaller.js

@@ -1,6 +1,6 @@
 /**
- * Enhanced Multi-language dependency installer utility for Package Installer CLI v3.0.0
- * Supports Node.js, Rust, Python, Go, Ruby, PHP, Java, C#, Swift, Dart/Flutter with modern features
+ * Enhanced Multi-language dependency installer utility for Package Installer CLI v3.2.0
+ * Supports Node.js, Python, Rust, Go, Ruby, and more with intelligent package management
  */
 import { exec } from 'child_process';
 import { promisify } from 'util';
@@ -332,28 +332,6 @@ function extractInstalledPackages(output, language) {
                     });
                 }
                 break;
-            case 'php':
-                // Parse composer output
-                const phpMatches = output.match(/Installing (.+?) \(/gi);
-                if (phpMatches) {
-                    phpMatches.forEach(match => {
-                        const pkg = match.replace(/Installing\s+/, '').replace(/\s+\(.*/, '');
-                        if (pkg)
-                            packages.push(pkg);
-                    });
-                }
-                break;
-            case 'java':
-                // Parse maven output
-                const javaMatches = output.match(/Downloaded from .+?: (.+?) \(/gi);
-                if (javaMatches) {
-                    javaMatches.forEach(match => {
-                        const pkg = match.match(/: (.+?) \(/)?.[1];
-                        if (pkg)
-                            packages.push(pkg);
-                    });
-                }
-                break;
             case 'ruby':
                 // Parse bundler output
                 const rubyMatches = output.match(/Installing (.+?) \(/gi);
@@ -365,17 +343,6 @@ function extractInstalledPackages(output, language) {
                     });
                 }
                 break;
-            case 'dotnet':
-                // Parse dotnet output
-                const dotnetMatches = output.match(/PackageReference for package '(.+?)'/gi);
-                if (dotnetMatches) {
-                    dotnetMatches.forEach(match => {
-                        const pkg = match.match(/'(.+?)'/)?.[1];
-                        if (pkg)
-                            packages.push(pkg);
-                    });
-                }
-                break;
             default:
                 // Generic extraction
                 packages.push('dependencies');
@@ -443,20 +410,9 @@ export async function installPackages(projectPath, language, packages, options =
         case 'go':
             command = `go get ${packages.join(' ')}`;
             break;
-        case 'php':
-            const composerFlags = isDev ? '--dev' : '';
-            command = `composer require ${composerFlags} ${packages.join(' ')}`;
-            break;
-        case 'java':
-            // For Maven, we'd typically need to edit pom.xml, but for simplicity:
-            command = `mvn dependency:get -Dartifact=${packages[0]}`;
-            break;
         case 'ruby':
             command = `bundle add ${packages.join(' ')}`;
             break;
-        case 'dotnet':
-            command = `dotnet add package ${packages.join(' ')}`;
-            break;
         default:
             throw new Error(`Unsupported language: ${language}`);
     }

data/dist/utils/featureInstaller.js

@@ -10,6 +10,7 @@ import ora from 'ora';
 import { installPackages } from './dependencyInstaller.js';
 import { detectLanguageFromFiles } from './languageConfig.js';
 import { cacheProjectData, getCachedProject } from './cacheManager.js';
+import { getCliRootPath, getFeaturesJsonPath } from './pathResolver.js';
 // Get the directory of this file for proper path resolution
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -20,15 +21,14 @@ let SUPPORTED_FEATURES = {};
  */
 async function loadFeatures() {
     try {
-        // Get CLI installation directory
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = path.dirname(__filename);
-        const cliDir = path.resolve(__dirname, '..', '..');
-        // Load directly from file system (simplified approach)
-        const featuresPath = path.join(cliDir, 'features', 'features.json');
+        // Get CLI installation directory using the centralized path resolver
+        const featuresPath = getFeaturesJsonPath();
         if (await fs.pathExists(featuresPath)) {
             const featuresData = await fs.readJson(featuresPath);
-            SUPPORTED_FEATURES = featuresData.features;
+            SUPPORTED_FEATURES = featuresData.features || featuresData;
+        }
+        else {
+            console.warn(chalk.yellow(`⚠️  Features file not found at: ${featuresPath}`));
         }
     }
     catch (error) {
@@ -39,11 +39,13 @@ async function loadFeatures() {
 await loadFeatures();
 // Export for use in other modules
 export { SUPPORTED_FEATURES };
+// Re-export path utilities for backward compatibility
+export { getCliRootPath } from './pathResolver.js';
 /**
  * Detect the current project's framework and language with improved logic
  */
 /**
- * Detect if a Next.js project uses src folder structure
+ * Detect if a Next.js project uses src folder structure (Next.js only)
  */
 async function detectNextjsSrcStructure(projectPath) {
     try {
@@ -52,17 +54,17 @@ async function detectNextjsSrcStructure(projectPath) {
         if (!await fs.pathExists(srcPath)) {
             return false;
         }
-        // Check for app directory in src (App Router)
+        // Check for Next.js App Router (app directory in src)
         const srcAppPath = path.join(srcPath, 'app');
         if (await fs.pathExists(srcAppPath)) {
             return true;
         }
-        // Check for pages directory in src (Pages Router)
+        // Check for Next.js Pages Router (pages directory in src) 
         const srcPagesPath = path.join(srcPath, 'pages');
         if (await fs.pathExists(srcPagesPath)) {
             return true;
         }
-        // Check for components directory in src
+        // Check for components directory in src (common pattern)
         const srcComponentsPath = path.join(srcPath, 'components');
         if (await fs.pathExists(srcComponentsPath)) {
             return true;
@@ -74,45 +76,35 @@ async function detectNextjsSrcStructure(projectPath) {
     }
 }
 /**
- * Adjust file path for Next.js src folder structure
+ * Adjust file path for Next.js src folder structure (Next.js only)
+ * Dynamically places files in src/ folder based on their path structure
  */
-function adjustNextjsFilePath(filePath, hasSrcFolder, projectPath) {
-    // Files that should be placed in src folder when src structure is used
-    const srcFolderFiles = [
-        'app/',
-        'pages/',
-        'components/',
-        'lib/',
-        'utils/',
-        'hooks/',
-        'context/',
-        'types/',
-        'styles/' // Only component-specific styles, not global ones
-    ];
-    // Files that should always be in root regardless of src folder
+function adjustNextjsSrcFilePath(filePath, hasSrcFolder, projectPath) {
+    // If project doesn't use src folder, return original path
+    if (!hasSrcFolder) {
+        return path.join(projectPath, filePath);
+    }
+    // Files that should ALWAYS be in root regardless of src folder
     const rootOnlyFiles = [
-        'middleware.ts',
-        'middleware.js',
-        'next.config.js',
-        'next.config.mjs',
         '.env',
         '.env.local',
         '.env.example',
         'package.json',
+        'next.config.js',
+        'next.config.mjs',
         'tailwind.config.js',
         'tailwind.config.ts',
-        'postcss.config.js'
+        'postcss.config.js',
+        'middleware.ts',
+        'middleware.js'
     ];
-    // Check if this file should always be in root
     const fileName = path.basename(filePath);
-    if (rootOnlyFiles.includes(fileName) || filePath.includes('public/')) {
-        return filePath;
-    }
-    // If project has src folder and this file should be in src
-    if (hasSrcFolder && srcFolderFiles.some(prefix => filePath.startsWith(prefix))) {
-        return path.join('src', filePath);
+    // Check if this file should always be in root
+    if (rootOnlyFiles.includes(fileName) || filePath.startsWith('public/')) {
+        return path.join(projectPath, filePath);
     }
-    return filePath;
+    // For all other files, place them in src/ folder if src structure is used
+    return path.join(projectPath, 'src', filePath);
 }
 export async function detectProjectStack(projectPath) {
     try {
@@ -181,7 +173,7 @@ export async function detectProjectStack(projectPath) {
             else if (dependencies['@remix-run/react']) {
                 framework = 'remixjs';
             }
-            // For non-Next.js projects, simple src folder check
+            // For other frameworks, simple src folder check
             if (framework !== 'nextjs' && !hasSrcFolder) {
                 hasSrcFolder = await fs.pathExists(path.join(projectPath, 'src'));
             }
@@ -319,9 +311,9 @@ async function processFeatureFile(filePath, fileConfig, featureName, provider, p
     }
     // Handle file path adjustment based on project structure
     let targetFilePath = path.join(projectPath, filePath);
-    // For Next.js projects, adjust file paths based on src folder structure
-    if (projectInfo.framework === 'nextjs') {
-        targetFilePath = adjustNextjsFilePath(filePath, projectInfo.hasSrcFolder || false, projectPath);
+    // For Next.js projects with src folder structure, adjust file paths accordingly
+    if (projectInfo.framework === 'nextjs' && projectInfo.hasSrcFolder) {
+        targetFilePath = adjustNextjsSrcFilePath(filePath, projectInfo.hasSrcFolder, projectPath);
     }
     // Ensure all parent directories exist before processing
     await fs.ensureDir(path.dirname(targetFilePath));
@@ -383,96 +375,157 @@ async function handleFileCreation(sourceFilePath, targetFilePath, cachedContent)
     console.log(chalk.green(`✅ Created: ${path.relative(process.cwd(), targetFilePath)}`));
 }
 /**
- * Handle file overwrite (replace existing content)
+ * Handle file overwrite (replace existing content or create if doesn't exist)
  */
 async function handleFileOverwrite(sourceFilePath, targetFilePath, cachedContent) {
-    if (cachedContent) {
-        await fs.outputFile(targetFilePath, cachedContent);
+    // Ensure target directory exists
+    await fs.ensureDir(path.dirname(targetFilePath));
+    const fileExists = await fs.pathExists(targetFilePath);
+    try {
+        if (cachedContent) {
+            await fs.outputFile(targetFilePath, cachedContent);
+        }
+        else {
+            // Check if source template exists
+            if (await fs.pathExists(sourceFilePath)) {
+                await copyTemplateFile(sourceFilePath, targetFilePath);
+            }
+            else {
+                console.log(chalk.yellow(`⚠️  Template file not found, skipping: ${path.relative(process.cwd(), sourceFilePath)}`));
+                console.log(chalk.gray(`   This might be due to running a globally installed CLI. Consider using 'npx' or installing locally.`));
+                return;
+            }
+        }
+        if (fileExists) {
+            console.log(chalk.green(`✅ Updated: ${path.relative(process.cwd(), targetFilePath)}`));
+        }
+        else {
+            console.log(chalk.green(`✅ Created: ${path.relative(process.cwd(), targetFilePath)}`));
+        }
     }
-    else {
-        await copyTemplateFile(sourceFilePath, targetFilePath);
+    catch (error) {
+        console.error(chalk.red(`❌ Failed to overwrite/create ${path.relative(process.cwd(), targetFilePath)}: ${error}`));
+        throw error;
     }
-    console.log(chalk.green(`✅ Updated: ${path.relative(process.cwd(), targetFilePath)}`));
 }
 /**
- * Handle file append (add content to end of file)
+ * Handle file append (add content to end of file, create if doesn't exist)
  */
 async function handleFileAppend(sourceFilePath, targetFilePath, cachedContent) {
+    // Ensure target directory exists
+    await fs.ensureDir(path.dirname(targetFilePath));
+    const fileExists = await fs.pathExists(targetFilePath);
     let existingContent = '';
-    if (await fs.pathExists(targetFilePath)) {
-        existingContent = await fs.readFile(targetFilePath, 'utf-8');
-    }
-    let templateContent;
-    if (cachedContent) {
-        templateContent = cachedContent;
+    try {
+        if (fileExists) {
+            existingContent = await fs.readFile(targetFilePath, 'utf8');
+        }
+        let contentToAppend = '';
+        if (cachedContent) {
+            contentToAppend = cachedContent;
+        }
+        else {
+            // Check if source template exists
+            if (await fs.pathExists(sourceFilePath)) {
+                contentToAppend = await fs.readFile(sourceFilePath, 'utf8');
+            }
+            else {
+                console.log(chalk.yellow(`⚠️  Template file not found, skipping append: ${path.relative(process.cwd(), sourceFilePath)}`));
+                console.log(chalk.gray(`   This might be due to running a globally installed CLI. Consider using 'npx' or installing locally.`));
+                return;
+            }
+        }
+        const newContent = existingContent + contentToAppend;
+        await fs.outputFile(targetFilePath, newContent);
+        if (fileExists) {
+            console.log(chalk.green(`✅ Appended to: ${path.relative(process.cwd(), targetFilePath)}`));
+        }
+        else {
+            console.log(chalk.green(`✅ Created with content: ${path.relative(process.cwd(), targetFilePath)}`));
+        }
     }
-    else {
-        templateContent = await fs.readFile(sourceFilePath, 'utf-8');
+    catch (error) {
+        console.error(chalk.red(`❌ Failed to append/create ${path.relative(process.cwd(), targetFilePath)}: ${error}`));
+        throw error;
     }
-    const separator = existingContent && !existingContent.endsWith('\n') ? '\n\n' : '\n';
-    const newContent = existingContent + separator + templateContent;
-    // Ensure target directory exists
-    await fs.ensureDir(path.dirname(targetFilePath));
-    await fs.outputFile(targetFilePath, newContent);
-    console.log(chalk.green(`✅ Appended to: ${path.relative(process.cwd(), targetFilePath)}`));
 }
 /**
- * Handle file prepend (add content to beginning of file)
+ * Handle file prepend (add content to beginning of file, create if doesn't exist)
  */
 async function handleFilePrepend(sourceFilePath, targetFilePath, cachedContent) {
+    // Ensure target directory exists
+    await fs.ensureDir(path.dirname(targetFilePath));
+    const fileExists = await fs.pathExists(targetFilePath);
     let existingContent = '';
-    if (await fs.pathExists(targetFilePath)) {
-        existingContent = await fs.readFile(targetFilePath, 'utf-8');
-    }
-    let templateContent;
-    if (cachedContent) {
-        templateContent = cachedContent;
+    try {
+        if (fileExists) {
+            existingContent = await fs.readFile(targetFilePath, 'utf-8');
+        }
+        let templateContent;
+        if (cachedContent) {
+            templateContent = cachedContent;
+        }
+        else {
+            // Check if source template exists
+            if (await fs.pathExists(sourceFilePath)) {
+                templateContent = await fs.readFile(sourceFilePath, 'utf-8');
+            }
+            else {
+                console.log(chalk.yellow(`⚠️  Template file not found, skipping prepend: ${path.relative(process.cwd(), sourceFilePath)}`));
+                console.log(chalk.gray(`   This might be due to running a globally installed CLI. Consider using 'npx' or installing locally.`));
+                return;
+            }
+        }
+        const separator = templateContent.endsWith('\n') ? '' : '\n';
+        const newContent = templateContent + separator + existingContent;
+        await fs.outputFile(targetFilePath, newContent);
+        if (fileExists) {
+            console.log(chalk.green(`✅ Prepended to: ${path.relative(process.cwd(), targetFilePath)}`));
+        }
+        else {
+            console.log(chalk.green(`✅ Created with content: ${path.relative(process.cwd(), targetFilePath)}`));
+        }
     }
-    else {
-        templateContent = await fs.readFile(sourceFilePath, 'utf-8');
+    catch (error) {
+        console.error(chalk.red(`❌ Failed to prepend/create ${path.relative(process.cwd(), targetFilePath)}: ${error}`));
+        throw error;
     }
-    const separator = templateContent.endsWith('\n') ? '' : '\n';
-    const newContent = templateContent + separator + existingContent;
-    // Ensure target directory exists
-    await fs.ensureDir(path.dirname(targetFilePath));
-    await fs.outputFile(targetFilePath, newContent);
-    console.log(chalk.green(`✅ Prepended to: ${path.relative(process.cwd(), targetFilePath)}`));
 }
 /**
- * Copy template file to target location with Next.js content processing
+ * Copy template file to target location with framework-agnostic content processing
  */
 async function copyTemplateFile(sourceFilePath, targetFilePath) {
     if (!await fs.pathExists(sourceFilePath)) {
+        const relativePath = path.relative(process.cwd(), sourceFilePath);
+        console.error(chalk.red(`❌ Template file not found: ${relativePath}`));
+        console.error(chalk.yellow(`💡 This might be due to running a globally installed CLI. Consider using 'npx' or installing locally.`));
         throw new Error(`Template file not found: ${sourceFilePath}`);
     }
-    // Ensure target directory exists
-    await fs.ensureDir(path.dirname(targetFilePath));
-    // For Next.js projects, we might need to adjust import paths in template files
-    if (path.extname(sourceFilePath).match(/\.(js|jsx|ts|tsx)$/)) {
-        const templateContent = await fs.readFile(sourceFilePath, 'utf-8');
-        // Process content for Next.js src folder structure
-        let processedContent = templateContent;
-        // Adjust import paths if needed (this is basic - you might want to make it more sophisticated)
-        if (targetFilePath.includes('/src/')) {
-            processedContent = processedContent.replace(/from ['"]@\//g, 'from "@/');
-            processedContent = processedContent.replace(/from ['"]\.\.\//g, 'from "../');
-        }
-        await fs.writeFile(targetFilePath, processedContent);
+    try {
+        // Ensure target directory exists
+        await fs.ensureDir(path.dirname(targetFilePath));
+        // For code files, we might need to adjust import paths based on project structure
+        if (path.extname(sourceFilePath).match(/\.(js|jsx|ts|tsx)$/)) {
+            const templateContent = await fs.readFile(sourceFilePath, 'utf-8');
+            // Process content based on project structure (framework-agnostic)
+            let processedContent = templateContent;
+            // Adjust import paths for src-based project structures
+            if (targetFilePath.includes('/src/')) {
+                processedContent = processedContent.replace(/from ['"]@\//g, 'from "@/');
+                processedContent = processedContent.replace(/from ['"]\.\.\//g, 'from "../');
+            }
+            await fs.writeFile(targetFilePath, processedContent);
+        }
+        else {
+            // For non-code files, just copy directly
+            await fs.copy(sourceFilePath, targetFilePath);
+        }
     }
-    else {
-        // For non-code files, just copy directly
-        await fs.copy(sourceFilePath, targetFilePath);
+    catch (error) {
+        console.error(chalk.red(`❌ Failed to copy template file: ${error}`));
+        throw error;
     }
 }
-/**
- * Get the CLI installation root directory
- */
-export function getCliRootPath() {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    // Go up from src/utils to root directory
-    return path.resolve(__dirname, '..', '..');
-}
 /**
  * Show setup instructions for a feature
  */