package-installer-cli 1.0.0 → 1.2.0

data/dist/utils/pathResolver.js

@@ -0,0 +1,179 @@
+/**
+ * Path resolution utility for Package Installer CLI
+ * Centralized path resolution logic that works for both local development and global installations
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+/**
+ * Get the CLI installation root directory
+ * Works for both local development and global installations across multiple package managers
+ */
+export function getCliRootPath() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    // All possible package names across different package managers
+    const packageNames = [
+        '@0xshariq/package-installer', // npm
+        'package-installer-cli', // PyPI, RubyGems, Rust crates
+        'go_package_installer_cli' // Go (from github.com/0xshariq/go_package_installer_cli)
+    ];
+    // Method 1: Walk up the directory tree to find package.json with any of our package names
+    let currentDir = __dirname;
+    while (currentDir !== path.dirname(currentDir)) {
+        const packageJsonPath = path.join(currentDir, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+                if (packageNames.includes(packageJson.name)) {
+                    return currentDir;
+                }
+            }
+            catch (error) {
+                // Continue searching
+            }
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    // Method 2: Check if this is a local development environment
+    const localDevPath = path.resolve(__dirname, '..', '..');
+    if (fs.existsSync(path.join(localDevPath, 'package.json')) &&
+        fs.existsSync(path.join(localDevPath, 'features'))) {
+        try {
+            const packageJson = JSON.parse(fs.readFileSync(path.join(localDevPath, 'package.json'), 'utf-8'));
+            if (packageNames.includes(packageJson.name)) {
+                return localDevPath;
+            }
+        }
+        catch (error) {
+            // Continue to other methods
+        }
+    }
+    // Method 3: Try to resolve using require.resolve for npm installations
+    for (const packageName of packageNames) {
+        try {
+            const packageMainPath = require.resolve(`${packageName}/package.json`);
+            return path.dirname(packageMainPath);
+        }
+        catch (error) {
+            // Package not found in require cache, try next
+        }
+    }
+    // Method 4: Check common global installation paths for all package managers
+    const globalPaths = [];
+    // npm global paths
+    globalPaths.push(
+    // Linux/macOS npm global paths
+    '/usr/local/lib/node_modules/@0xshariq/package-installer', '/usr/lib/node_modules/@0xshariq/package-installer', 
+    // User-specific npm global paths
+    path.join(process.env.HOME || '', '.npm-global/lib/node_modules/@0xshariq/package-installer'), path.join(process.env.HOME || '', '.npm/lib/node_modules/@0xshariq/package-installer'), 
+    // Windows npm global paths
+    path.join(process.env.APPDATA || '', 'npm/node_modules/@0xshariq/package-installer'), path.join(process.env.ProgramFiles || '', 'nodejs/node_modules/@0xshariq/package-installer'));
+    // PyPI/pip global paths
+    if (process.env.HOME) {
+        globalPaths.push(
+        // Linux/macOS pip user install paths
+        path.join(process.env.HOME, '.local/lib/python*/site-packages/package-installer-cli'), path.join(process.env.HOME, '.local/bin/package-installer-cli'), 
+        // System-wide pip install paths
+        '/usr/local/lib/python*/site-packages/package-installer-cli', '/usr/lib/python*/site-packages/package-installer-cli');
+    }
+    // RubyGems global paths
+    if (process.env.HOME) {
+        globalPaths.push(
+        // User gem installation paths
+        path.join(process.env.HOME, '.gem/ruby/*/gems/package-installer-cli-*'), path.join(process.env.HOME, '.local/share/gem/ruby/*/gems/package-installer-cli-*'), 
+        // System gem installation paths
+        '/usr/local/lib/ruby/gems/*/gems/package-installer-cli-*', '/var/lib/gems/*/gems/package-installer-cli-*');
+    }
+    // Rust cargo global paths
+    if (process.env.HOME) {
+        globalPaths.push(path.join(process.env.HOME, '.cargo/bin/package-installer-cli'), path.join(process.env.HOME, '.cargo/registry/src/*/package-installer-cli-*'));
+    }
+    // Go global paths
+    const goPath = process.env.GOPATH || path.join(process.env.HOME || '', 'go');
+    globalPaths.push(path.join(goPath, 'bin/go_package_installer_cli'), path.join(goPath, 'bin/pi'), // In case the binary is named 'pi'
+    path.join(goPath, 'pkg/mod/github.com/0xshariq/go_package_installer_cli*'), 
+    // Also check system-wide go installation paths
+    '/usr/local/bin/go_package_installer_cli', '/usr/local/bin/pi');
+    // Check all possible global paths
+    for (const globalPath of globalPaths) {
+        // Handle wildcard paths
+        if (globalPath.includes('*')) {
+            try {
+                const { execSync } = require('child_process');
+                const expandedPaths = execSync(`ls -d ${globalPath} 2>/dev/null || true`, { encoding: 'utf8' }).trim().split('\n').filter((p) => p);
+                for (const expandedPath of expandedPaths) {
+                    if (fs.existsSync(expandedPath) && (fs.existsSync(path.join(expandedPath, 'features')) ||
+                        fs.existsSync(path.join(path.dirname(expandedPath), 'features')))) {
+                        return fs.existsSync(path.join(expandedPath, 'features')) ? expandedPath : path.dirname(expandedPath);
+                    }
+                }
+            }
+            catch (error) {
+                // Continue to next path
+            }
+        }
+        else {
+            if (fs.existsSync(globalPath) && fs.existsSync(path.join(globalPath, 'features'))) {
+                return globalPath;
+            }
+        }
+    }
+    // Method 5: Check if npm prefix is available and use it (for npm installations)
+    try {
+        const { execSync } = require('child_process');
+        const npmPrefix = execSync('npm config get prefix', { encoding: 'utf8' }).trim();
+        const npmGlobalPath = path.join(npmPrefix, 'lib/node_modules/@0xshariq/package-installer');
+        if (fs.existsSync(npmGlobalPath) && fs.existsSync(path.join(npmGlobalPath, 'features'))) {
+            return npmGlobalPath;
+        }
+    }
+    catch (error) {
+        // npm not available or command failed
+    }
+    // Method 6: Check binary location and work backwards (for compiled languages like Go/Rust)
+    try {
+        const { execSync } = require('child_process');
+        const whichResult = execSync('which pi || which package-installer-cli || which go_package_installer_cli || echo ""', { encoding: 'utf8' }).trim();
+        if (whichResult) {
+            // Go up from binary location to find the package root
+            let binaryDir = path.dirname(whichResult);
+            while (binaryDir !== path.dirname(binaryDir)) {
+                if (fs.existsSync(path.join(binaryDir, 'features'))) {
+                    return binaryDir;
+                }
+                binaryDir = path.dirname(binaryDir);
+            }
+        }
+    }
+    catch (error) {
+        // which command failed or not available
+    }
+    // Final fallback: use the local development path
+    console.warn('⚠️  Could not resolve CLI root path, using fallback');
+    return path.resolve(__dirname, '..', '..');
+}
+/**
+ * Get the path to the features directory
+ */
+export function getFeaturesPath() {
+    return path.join(getCliRootPath(), 'features');
+}
+/**
+ * Get the path to the features.json file
+ */
+export function getFeaturesJsonPath() {
+    return path.join(getFeaturesPath(), 'features.json');
+}
+/**
+ * Get the path to the templates directory
+ */
+export function getTemplatesPath() {
+    return path.join(getCliRootPath(), 'templates');
+}
+/**
+ * Get the path to the package.json file
+ */
+export function getPackageJsonPath() {
+    return path.join(getCliRootPath(), 'package.json');
+}

data/dist/utils/prompts.js

@@ -1,22 +1,15 @@
 /**
- * User interaction prompts for Package Installer CLI v3.0.0
+ * User interaction prompts for Package Installer CLI v3.2.0
  * Handles framework selection and template configuration based on template.json
  */
 import inquirer from 'inquirer';
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
-import { fileURLToPath } from 'url';
-// Get CLI installation directory
-function getCLIDirectory() {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    // Go up from src/utils to root directory
-    return path.resolve(__dirname, '..', '..');
-}
+import { getCliRootPath, getFeaturesJsonPath } from './pathResolver.js';
 // Helper functions to read template.json
 function getTemplateConfig() {
-    const cliDir = getCLIDirectory();
+    const cliDir = getCliRootPath();
     const templatePath = path.join(cliDir, 'template.json');
     if (!fs.existsSync(templatePath)) {
         throw new Error(`template.json not found at: ${templatePath}`);
@@ -275,8 +268,7 @@ export async function promptFeatureSelection() {
         return [];
     }
     // Get available feature categories from features.json
-    const cliDir = getCLIDirectory();
-    const featuresPath = path.join(cliDir, 'features', 'features.json');
+    const featuresPath = getFeaturesJsonPath();
     if (!fs.existsSync(featuresPath)) {
         console.log(chalk.yellow('⚠️  Features configuration not found'));
         return [];
@@ -302,8 +294,7 @@ export async function promptFeatureSelection() {
  * Specific feature provider selection
  */
 export async function promptFeatureProvider(category, framework) {
-    const cliDir = getCLIDirectory();
-    const featuresPath = path.join(cliDir, 'features', 'features.json');
+    const featuresPath = getFeaturesJsonPath();
     const featuresConfig = JSON.parse(fs.readFileSync(featuresPath, 'utf-8'));
     if (!featuresConfig[category]) {
         return null;

data/dist/utils/templateCreator.js

@@ -1,5 +1,5 @@
 /**
- * Template creation utilities for Package Installer CLI v3.0.0
+ * Template creation utilities for Package Installer CLI v3.2.0
  * Enhanced with features integration support
  */
 import fs from 'fs-extra';
@@ -329,11 +329,11 @@ async function initializeGitRepositoryForCreate(projectPath) {
         // Make initial commit
         try {
             gitSpinner.text = chalk.hex('#00d2d3')('Creating initial commit with gcommit...');
-            await execAsync('gcommit "Initial commit from Package Installer CLI v3.0.0"', { cwd: projectPath });
+            await execAsync('gcommit "Initial commit from Package Installer CLI v3.2.0"', { cwd: projectPath });
         }
         catch {
             gitSpinner.text = chalk.hex('#00d2d3')('Creating initial commit with git commit...');
-            await execAsync('git commit -m "Initial commit from Package Installer CLI v3.0.0"', { cwd: projectPath });
+            await execAsync('git commit -m "Initial commit from Package Installer CLI v3.2.0"', { cwd: projectPath });
         }
         gitSpinner.succeed(chalk.green('✅ Git repository initialized with initial commit'));
     }

data/dist/utils/templateResolver.js

@@ -4,17 +4,10 @@
  */
 import path from 'path';
 import fs from 'fs-extra';
-import { fileURLToPath } from 'url';
-// Get CLI installation directory
-function getCLIDirectory() {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    // Go up from src/utils to root directory
-    return path.resolve(__dirname, '..', '..');
-}
+import { getCliRootPath, getTemplatesPath } from './pathResolver.js';
 // Helper functions to read template.json
 function getTemplateConfig() {
-    const cliDir = getCLIDirectory();
+    const cliDir = getCliRootPath();
     const templatePath = path.join(cliDir, 'template.json');
     if (!fs.existsSync(templatePath)) {
         throw new Error(`template.json not found at: ${templatePath}`);
@@ -50,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')) {
@@ -84,8 +76,7 @@ export function generateTemplateName(framework, options) {
  */
 export function resolveTemplatePath(projectInfo) {
     const { framework, language, templateName } = projectInfo;
-    const cliDir = getCLIDirectory();
-    const templatesRoot = path.join(cliDir, 'templates');
+    const templatesRoot = getTemplatesPath();
     // Handle combination templates (like reactjs+expressjs+shadcn)
     if (framework.includes('+')) {
         const frameworkDir = framework.replace(/\+/g, '-');
@@ -144,8 +135,8 @@ export function templateExists(templatePath) {
  * Get all available templates for a framework
  */
 export function getFrameworkTemplates(framework) {
-    const cliDir = getCLIDirectory();
-    const frameworkPath = path.join(cliDir, 'templates', framework);
+    const templatesRoot = getTemplatesPath();
+    const frameworkPath = path.join(templatesRoot, framework);
     if (!fs.existsSync(frameworkPath)) {
         return [];
     }

data/dist/utils/types.js

@@ -1,5 +1,5 @@
 /**
- * Type definitions for Package Installer CLI v3.0.0
- * Enhanced type system without database logic, focused on modern template structure
+ * Type definitions for Package Installer CLI v3.2.0
+ * Comprehensive type system for enhanced CLI functionality
  */
 export {};

data/dist/utils/ui.js

@@ -1,6 +1,6 @@
 /**
- * UI and display utilities for Package Installer CLI v3.0.0
- * Enhanced with modern styling, progress indicators, and better user experience
+ * UI and display utilities for Package Installer CLI v3.2.0
+ * Enhanced user interface components and styling utilities
  */
 import chalk from 'chalk';
 import figlet from 'figlet';

data/dist/utils/utils.js

@@ -1,5 +1,5 @@
 /**
- * Enhanced utility functions for Package Installer CLI v3.0.0
+ * Enhanced utility functions for Package Installer CLI v3.2.0
  * Comprehensive utilities for project management, validation, and operations
  */
 import chalk from 'chalk';
@@ -8,7 +8,26 @@ import * as fs from 'fs';
 import * as crypto from 'crypto';
 import { promisify } from 'util';
 import { exec } from 'child_process';
+import { fileURLToPath } from 'url';
+import { getPackageJsonPath } from './pathResolver.js';
 const execAsync = promisify(exec);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Get the current version from package.json
+ */
+export function getPackageVersion() {
+    try {
+        const packageJsonPath = getPackageJsonPath();
+        const packageJsonContent = fs.readFileSync(packageJsonPath, 'utf-8');
+        const packageJson = JSON.parse(packageJsonContent);
+        return packageJson.version || '3.4.0';
+    }
+    catch (error) {
+        console.warn('Warning: Could not read version from package.json, using fallback version');
+        return '3.2.0';
+    }
+}
 /**
  * Enhanced string utilities
  */

data/lib/package_installer_cli.rb

@@ -4,7 +4,7 @@ require 'open3'
 require 'json'
 
 module PackageInstallerCli
-  VERSION = "3.2.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.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - sharique
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-09-22 00:00:00.000000000 Z
+date: 2025-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -105,6 +105,7 @@ files:
 - dist/utils/featureInstaller.js
 - dist/utils/historyManager.js
 - dist/utils/languageConfig.js
+- dist/utils/pathResolver.js
 - dist/utils/prompts.js
 - dist/utils/templateCreator.js
 - dist/utils/templateResolver.js
@@ -2984,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: []