package-installer-cli 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67f8a4e5d268f24f01d493f27c9cf688d7e909fb0ec7f67906c0955e4d022ee9
-  data.tar.gz: 52f196b68f262f313be40bac842f592d32c1a8c3310247bd7cc386cc5298103a
+  metadata.gz: 7f432378951e281eb37210295d7894abbf072093bd9a2e6099f1d3219ad45eb0
+  data.tar.gz: 0e9edf8310281ce583765615d8d41f1897b7e0fab8e6cc3dbbfa405d39a63cc9
 SHA512:
-  metadata.gz: b9cbbdb378e2bff40893095c025e5b02802080e1e06a25c471d0e096beadbe4ff40bd3b377959dc9e4a4a7d946f805ffa491ee8194315dd8cd93cc6af2680d86
-  data.tar.gz: 45b213c38590a89247580f3ccf78ca0d4d714aafdc67f30effe08c45efebdd9ad1d7022857c82fc897f20087d03b6c0f14157d5544f58e6536c16e67db972e8c
+  metadata.gz: b0490199b16d2f27b1513fc9360895c02cb9a1a2fc58a4cddc5611c20afa21c8ef6e609d99b4dc7271a19de0ea21c1275127839d4b56b26b91e0554cff66c296
+  data.tar.gz: 6e7cec10cae328695c8fb9328797f5efc46ced7e04b0bb99dffe40ccbb887bc9ee495277b2ac49e5196e88f98e6a71a2cec823ad4ec692ee78424ce5cc3b5d53

data/dist/utils/dependencyInstaller.js

@@ -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

@@ -45,7 +45,7 @@ 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 {
@@ -54,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;
@@ -76,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 {
@@ -183,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'));
             }
@@ -321,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));
@@ -385,85 +375,155 @@ 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;
     }
 }
 /**

data/dist/utils/languageConfig.js

@@ -12,39 +12,6 @@ export const ENHANCED_LANGUAGE_CONFIGS = {
         category: 'web',
         maturity: 'stable',
         packageManagers: [
-            {
-                name: 'bun',
-                displayName: 'Bun',
-                description: 'Fast all-in-one JavaScript runtime & toolkit',
-                installCommand: 'bun install',
-                updateCommand: 'bun update',
-                addCommand: 'bun add',
-                removeCommand: 'bun remove',
-                listCommand: 'bun pm ls',
-                lockFiles: ['bun.lockb'],
-                configFiles: ['bunfig.toml'],
-                detectCommand: 'bun --version',
-                versionCommand: 'bun --version',
-                priority: 1,
-                features: [
-                    { name: 'Native bundling', description: 'Built-in bundler and transpiler', supported: true },
-                    { name: 'TypeScript support', description: 'Native TypeScript execution', supported: true },
-                    { name: 'JSX support', description: 'Native JSX transpilation', supported: true },
-                    { name: 'Hot reloading', description: 'Development server with hot reload', supported: true }
-                ],
-                performance: {
-                    installSpeed: 'fast',
-                    diskUsage: 'low',
-                    networkEfficiency: 'excellent',
-                    caching: 'global'
-                },
-                security: {
-                    checksums: true,
-                    signatures: true,
-                    vulnerabilityScanning: true,
-                    lockFileValidation: true
-                }
-            },
             {
                 name: 'pnpm',
                 displayName: 'pnpm',
@@ -59,7 +26,7 @@ export const ENHANCED_LANGUAGE_CONFIGS = {
                 configFiles: ['pnpm-workspace.yaml', '.pnpmrc'],
                 detectCommand: 'pnpm --version',
                 versionCommand: 'pnpm --version',
-                priority: 2,
+                priority: 1,
                 globalFlag: '-g',
                 features: [
                     { name: 'Workspace support', description: 'Monorepo and workspace management', supported: true },
@@ -80,6 +47,41 @@ export const ENHANCED_LANGUAGE_CONFIGS = {
                     lockFileValidation: true
                 }
             },
+            {
+                name: 'npm',
+                displayName: 'npm',
+                description: 'Node.js package manager',
+                installCommand: 'npm install',
+                updateCommand: 'npm update',
+                addCommand: 'npm install',
+                removeCommand: 'npm uninstall',
+                listCommand: 'npm list',
+                searchCommand: 'npm search',
+                lockFiles: ['package-lock.json'],
+                configFiles: ['.npmrc'],
+                detectCommand: 'npm --version',
+                versionCommand: 'npm --version',
+                priority: 2,
+                globalFlag: '-g',
+                features: [
+                    { name: 'Package scripts', description: 'Custom script execution', supported: true },
+                    { name: 'Version management', description: 'Semantic versioning support', supported: true },
+                    { name: 'Workspaces', description: 'Monorepo support', supported: true }
+                ],
+                performance: {
+                    installSpeed: 'medium',
+                    diskUsage: 'high',
+                    networkEfficiency: 'good',
+                    caching: 'local'
+                },
+                security: {
+                    checksums: true,
+                    signatures: false,
+                    auditCommand: 'npm audit',
+                    vulnerabilityScanning: true,
+                    lockFileValidation: true
+                }
+            },
             {
                 name: 'yarn',
                 displayName: 'Yarn',
@@ -115,36 +117,34 @@ export const ENHANCED_LANGUAGE_CONFIGS = {
                 }
             },
             {
-                name: 'npm',
-                displayName: 'npm',
-                description: 'Node.js package manager',
-                installCommand: 'npm install',
-                updateCommand: 'npm update',
-                addCommand: 'npm install',
-                removeCommand: 'npm uninstall',
-                listCommand: 'npm list',
-                searchCommand: 'npm search',
-                lockFiles: ['package-lock.json'],
-                configFiles: ['.npmrc'],
-                detectCommand: 'npm --version',
-                versionCommand: 'npm --version',
+                name: 'bun',
+                displayName: 'Bun',
+                description: 'Fast all-in-one JavaScript runtime & toolkit',
+                installCommand: 'bun install',
+                updateCommand: 'bun update',
+                addCommand: 'bun add',
+                removeCommand: 'bun remove',
+                listCommand: 'bun pm ls',
+                lockFiles: ['bun.lockb'],
+                configFiles: ['bunfig.toml'],
+                detectCommand: 'bun --version',
+                versionCommand: 'bun --version',
                 priority: 4,
-                globalFlag: '-g',
                 features: [
-                    { name: 'Package scripts', description: 'Custom script execution', supported: true },
-                    { name: 'Version management', description: 'Semantic versioning support', supported: true },
-                    { name: 'Workspaces', description: 'Monorepo support', supported: true }
+                    { name: 'Native bundling', description: 'Built-in bundler and transpiler', supported: true },
+                    { name: 'TypeScript support', description: 'Native TypeScript execution', supported: true },
+                    { name: 'JSX support', description: 'Native JSX transpilation', supported: true },
+                    { name: 'Hot reloading', description: 'Development server with hot reload', supported: true }
                 ],
                 performance: {
-                    installSpeed: 'medium',
-                    diskUsage: 'high',
-                    networkEfficiency: 'good',
-                    caching: 'local'
+                    installSpeed: 'fast',
+                    diskUsage: 'low',
+                    networkEfficiency: 'excellent',
+                    caching: 'global'
                 },
                 security: {
                     checksums: true,
-                    signatures: false,
-                    auditCommand: 'npm audit',
+                    signatures: true,
                     vulnerabilityScanning: true,
                     lockFileValidation: true
                 }
@@ -304,7 +304,111 @@ export const ENHANCED_LANGUAGE_CONFIGS = {
         category: 'web',
         maturity: 'stable',
         packageManagers: [
-            // Inherits from JavaScript but with TypeScript-specific tooling
+            // Inherits from JavaScript with same priority order: pnpm > npm > yarn > bun
+            {
+                name: 'pnpm',
+                displayName: 'pnpm',
+                description: 'Fast, disk space efficient package manager',
+                installCommand: 'pnpm install',
+                updateCommand: 'pnpm update',
+                addCommand: 'pnpm add',
+                removeCommand: 'pnpm remove',
+                listCommand: 'pnpm list',
+                searchCommand: 'pnpm search',
+                lockFiles: ['pnpm-lock.yaml'],
+                configFiles: ['pnpm-workspace.yaml', '.pnpmrc'],
+                detectCommand: 'pnpm --version',
+                versionCommand: 'pnpm --version',
+                priority: 1,
+                globalFlag: '-g',
+                features: [
+                    { name: 'TypeScript support', description: 'Excellent TypeScript integration', supported: true },
+                    { name: 'Workspace support', description: 'Monorepo and workspace management', supported: true },
+                    { name: 'Content-addressed storage', description: 'Efficient disk space usage', supported: true }
+                ],
+                performance: {
+                    installSpeed: 'fast',
+                    diskUsage: 'low',
+                    networkEfficiency: 'excellent',
+                    caching: 'global'
+                },
+                security: {
+                    checksums: true,
+                    signatures: false,
+                    auditCommand: 'pnpm audit',
+                    vulnerabilityScanning: true,
+                    lockFileValidation: true
+                }
+            },
+            {
+                name: 'npm',
+                displayName: 'npm',
+                description: 'Node.js package manager with TypeScript support',
+                installCommand: 'npm install',
+                updateCommand: 'npm update',
+                addCommand: 'npm install',
+                removeCommand: 'npm uninstall',
+                listCommand: 'npm list',
+                searchCommand: 'npm search',
+                lockFiles: ['package-lock.json'],
+                configFiles: ['.npmrc'],
+                detectCommand: 'npm --version',
+                versionCommand: 'npm --version',
+                priority: 2,
+                globalFlag: '-g',
+                features: [
+                    { name: 'TypeScript support', description: 'Official TypeScript support', supported: true },
+                    { name: 'Package scripts', description: 'Custom script execution', supported: true },
+                    { name: 'Version management', description: 'Semantic versioning support', supported: true }
+                ],
+                performance: {
+                    installSpeed: 'medium',
+                    diskUsage: 'high',
+                    networkEfficiency: 'good',
+                    caching: 'local'
+                },
+                security: {
+                    checksums: true,
+                    signatures: false,
+                    auditCommand: 'npm audit',
+                    vulnerabilityScanning: true,
+                    lockFileValidation: true
+                }
+            },
+            {
+                name: 'yarn',
+                displayName: 'Yarn',
+                description: 'Reliable, secure, fast package manager with TypeScript support',
+                installCommand: 'yarn install',
+                updateCommand: 'yarn upgrade',
+                addCommand: 'yarn add',
+                removeCommand: 'yarn remove',
+                listCommand: 'yarn list',
+                lockFiles: ['yarn.lock'],
+                configFiles: ['.yarnrc.yml', '.yarnrc'],
+                detectCommand: 'yarn --version',
+                versionCommand: 'yarn --version',
+                priority: 3,
+                globalFlag: 'global',
+                features: [
+                    { name: 'TypeScript support', description: 'Excellent TypeScript integration', supported: true },
+                    { name: 'Zero-installs', description: 'Offline installation support', supported: true },
+                    { name: 'Plug\'n\'Play', description: 'Fast module resolution', supported: true }
+                ],
+                performance: {
+                    installSpeed: 'fast',
+                    diskUsage: 'medium',
+                    networkEfficiency: 'good',
+                    caching: 'global'
+                },
+                security: {
+                    checksums: true,
+                    signatures: false,
+                    auditCommand: 'yarn npm audit',
+                    vulnerabilityScanning: true,
+                    lockFileValidation: true
+                }
+            },
             {
                 name: 'bun',
                 displayName: 'Bun',
@@ -312,14 +416,17 @@ export const ENHANCED_LANGUAGE_CONFIGS = {
                 installCommand: 'bun install',
                 updateCommand: 'bun update',
                 addCommand: 'bun add',
+                removeCommand: 'bun remove',
+                listCommand: 'bun pm ls',
                 lockFiles: ['bun.lockb'],
                 configFiles: ['bunfig.toml'],
                 detectCommand: 'bun --version',
                 versionCommand: 'bun --version',
-                priority: 1,
+                priority: 4,
                 features: [
                     { name: 'Native TypeScript', description: 'No transpilation needed', supported: true },
-                    { name: 'Type checking', description: 'Built-in type checking', supported: true }
+                    { name: 'Type checking', description: 'Built-in type checking', supported: true },
+                    { name: 'Hot reloading', description: 'Development server with hot reload', supported: true }
                 ],
                 performance: {
                     installSpeed: 'fast',
@@ -880,164 +987,6 @@ export const ENHANCED_LANGUAGE_CONFIGS = {
             ]
         }
     },
-    php: {
-        name: 'php',
-        displayName: 'PHP',
-        description: 'Server-side scripting language for web development',
-        icon: '🐘',
-        category: 'web',
-        maturity: 'stable',
-        packageManagers: [
-            {
-                name: 'composer',
-                displayName: 'Composer',
-                description: 'Dependency Manager for PHP',
-                installCommand: 'composer install',
-                updateCommand: 'composer update',
-                addCommand: 'composer require',
-                removeCommand: 'composer remove',
-                listCommand: 'composer show',
-                lockFiles: ['composer.lock'],
-                configFiles: ['composer.json'],
-                detectCommand: 'composer --version',
-                versionCommand: 'composer --version',
-                priority: 1,
-                features: [
-                    { name: 'Autoloading', description: 'PSR-4 autoloading support', supported: true },
-                    { name: 'Version constraints', description: 'Semantic versioning', supported: true }
-                ],
-                performance: {
-                    installSpeed: 'medium',
-                    diskUsage: 'medium',
-                    networkEfficiency: 'good',
-                    caching: 'global'
-                },
-                security: {
-                    checksums: true,
-                    signatures: false,
-                    vulnerabilityScanning: true,
-                    lockFileValidation: true
-                }
-            }
-        ],
-        configFiles: [
-            {
-                filename: 'composer.json',
-                description: 'PHP dependency configuration',
-                required: true,
-                type: 'dependency',
-                parser: 'json'
-            }
-        ],
-        buildFiles: ['vendor'],
-        sourceFileExtensions: ['.php'],
-        frameworkDetection: [
-            {
-                framework: 'laravel',
-                displayName: 'Laravel',
-                patterns: ['artisan'],
-                dependencies: ['laravel/framework'],
-                popularity: 90,
-                category: 'backend'
-            }
-        ],
-        toolchain: {
-            interpreter: { name: 'PHP', command: 'php', optional: false, description: 'PHP interpreter' }
-        },
-        ecosystem: {
-            registry: { name: 'Packagist', url: 'packagist.org' },
-            community: { github: { repos: 300000, stars: 1000000 }, stackoverflow: { questions: 300000, activity: 'high' } },
-            learning: [],
-            trends: { githubStars: 1000000, stackoverflowQuestions: 300000, jobPostings: 120000, trendDirection: 'stable' }
-        },
-        compatibility: {
-            operatingSystems: ['windows', 'macos', 'linux'],
-            architectures: ['x64', 'arm64'],
-            containers: true,
-            cloud: [
-                { name: 'AWS', supported: true, deployment: ['Lambda', 'EC2'] }
-            ]
-        }
-    },
-    java: {
-        name: 'java',
-        displayName: 'Java',
-        description: 'Enterprise-grade, platform-independent programming language',
-        icon: '☕',
-        category: 'enterprise',
-        maturity: 'stable',
-        packageManagers: [
-            {
-                name: 'maven',
-                displayName: 'Maven',
-                description: 'Build automation and dependency management',
-                installCommand: 'mvn install',
-                updateCommand: 'mvn versions:use-latest-versions',
-                addCommand: 'mvn dependency:get',
-                listCommand: 'mvn dependency:list',
-                lockFiles: [],
-                configFiles: ['pom.xml'],
-                detectCommand: 'mvn --version',
-                versionCommand: 'mvn --version',
-                priority: 1,
-                features: [
-                    { name: 'Central repository', description: 'Maven Central repository', supported: true },
-                    { name: 'Build lifecycle', description: 'Standardized build process', supported: true }
-                ],
-                performance: {
-                    installSpeed: 'medium',
-                    diskUsage: 'high',
-                    networkEfficiency: 'good',
-                    caching: 'local'
-                },
-                security: {
-                    checksums: true,
-                    signatures: true,
-                    vulnerabilityScanning: true,
-                    lockFileValidation: false
-                }
-            }
-        ],
-        configFiles: [
-            {
-                filename: 'pom.xml',
-                description: 'Maven project configuration',
-                required: true,
-                type: 'dependency',
-                parser: 'xml'
-            }
-        ],
-        buildFiles: ['target', '.m2'],
-        sourceFileExtensions: ['.java'],
-        frameworkDetection: [
-            {
-                framework: 'spring',
-                displayName: 'Spring Boot',
-                patterns: ['src/main/java/**/*Application.java'],
-                dependencies: ['org.springframework.boot:spring-boot-starter'],
-                popularity: 95,
-                category: 'backend'
-            }
-        ],
-        toolchain: {
-            interpreter: { name: 'Java', command: 'java', optional: false, description: 'Java runtime' }
-        },
-        ecosystem: {
-            registry: { name: 'Maven Central', url: 'mvnrepository.com' },
-            community: { github: { repos: 800000, stars: 3000000 }, stackoverflow: { questions: 1500000, activity: 'high' } },
-            learning: [],
-            trends: { githubStars: 3000000, stackoverflowQuestions: 1500000, jobPostings: 200000, trendDirection: 'stable' }
-        },
-        compatibility: {
-            operatingSystems: ['windows', 'macos', 'linux'],
-            architectures: ['x64', 'arm64'],
-            containers: true,
-            cloud: [
-                { name: 'AWS', supported: true },
-                { name: 'Google Cloud', supported: true }
-            ]
-        }
-    },
     ruby: {
         name: 'ruby',
         displayName: 'Ruby',
@@ -1115,86 +1064,6 @@ export const ENHANCED_LANGUAGE_CONFIGS = {
                 { name: 'Heroku', supported: true }
             ]
         }
-    },
-    dotnet: {
-        name: 'dotnet',
-        displayName: '.NET',
-        description: 'Cross-platform framework for modern applications',
-        icon: '🟣',
-        category: 'enterprise',
-        maturity: 'stable',
-        packageManagers: [
-            {
-                name: 'dotnet',
-                displayName: 'NuGet',
-                description: '.NET package manager',
-                installCommand: 'dotnet restore',
-                updateCommand: 'dotnet outdated --upgrade',
-                addCommand: 'dotnet add package',
-                removeCommand: 'dotnet remove package',
-                listCommand: 'dotnet list package',
-                lockFiles: ['packages.lock.json'],
-                configFiles: ['*.csproj', '*.fsproj', '*.vbproj'],
-                detectCommand: 'dotnet --version',
-                versionCommand: 'dotnet --version',
-                priority: 1,
-                features: [
-                    { name: 'Package references', description: 'Modern package management', supported: true },
-                    { name: 'Central package management', description: 'Centralized version control', supported: true }
-                ],
-                performance: {
-                    installSpeed: 'fast',
-                    diskUsage: 'medium',
-                    networkEfficiency: 'excellent',
-                    caching: 'global'
-                },
-                security: {
-                    checksums: true,
-                    signatures: true,
-                    vulnerabilityScanning: true,
-                    lockFileValidation: true
-                }
-            }
-        ],
-        configFiles: [
-            {
-                filename: '*.csproj',
-                description: 'C# project file',
-                required: true,
-                type: 'dependency',
-                parser: 'xml'
-            }
-        ],
-        buildFiles: ['bin', 'obj'],
-        sourceFileExtensions: ['.cs', '.fs', '.vb'],
-        frameworkDetection: [
-            {
-                framework: 'aspnet',
-                displayName: 'ASP.NET Core',
-                patterns: ['Program.cs', 'Startup.cs'],
-                dependencies: ['Microsoft.AspNetCore'],
-                popularity: 85,
-                category: 'backend'
-            }
-        ],
-        toolchain: {
-            interpreter: { name: '.NET', command: 'dotnet', optional: false, description: '.NET CLI' }
-        },
-        ecosystem: {
-            registry: { name: 'NuGet', url: 'nuget.org' },
-            community: { github: { repos: 600000, stars: 2500000 }, stackoverflow: { questions: 800000, activity: 'high' } },
-            learning: [],
-            trends: { githubStars: 2500000, stackoverflowQuestions: 800000, jobPostings: 150000, trendDirection: 'rising' }
-        },
-        compatibility: {
-            operatingSystems: ['windows', 'macos', 'linux'],
-            architectures: ['x64', 'arm64'],
-            containers: true,
-            cloud: [
-                { name: 'Azure', supported: true },
-                { name: 'AWS', supported: true }
-            ]
-        }
     }
     // Additional languages would be added here with full configuration...
     // For brevity, I'm showing the structure with key languages implemented

data/dist/utils/templateResolver.js

@@ -43,14 +43,13 @@ export function generateTemplateName(framework, options) {
                 parts.push('no-src');
             }
         }
-        // Handle UI library
+        // Handle UI library - only add if actually selected (not "none")
+        // When UI is "none", templates simply omit the UI part from their names
         if (config.ui && config.ui.length > 0) {
             if (options.ui && options.ui !== 'none') {
                 parts.push(options.ui);
             }
-            else {
-                parts.push('no-' + config.ui[0]);
-            }
+            // For "none" selection, don't add any UI part to the template name
         }
         // Handle tailwind option
         if (config.options?.includes('tailwind')) {

data/dist/utils/utils.js

@@ -21,7 +21,7 @@ export function getPackageVersion() {
         const packageJsonPath = getPackageJsonPath();
         const packageJsonContent = fs.readFileSync(packageJsonPath, 'utf-8');
         const packageJson = JSON.parse(packageJsonContent);
-        return packageJson.version || '3.2.0';
+        return packageJson.version || '3.4.0';
     }
     catch (error) {
         console.warn('Warning: Could not read version from package.json, using fallback version');

data/lib/package_installer_cli.rb

@@ -4,7 +4,7 @@ require 'open3'
 require 'json'
 
 module PackageInstallerCli
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
   
   class << self
     def run(args = ARGV)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: package-installer-cli
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - sharique
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-09-23 00:00:00.000000000 Z
+date: 2025-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -2985,8 +2985,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.4.20
+signing_key:
 specification_version: 4
 summary: A cross-platform, interactive CLI to scaffold modern web app templates
 test_files: []