projxo 1.0.2 → 1.1.0

package/index.js

@@ -1,20 +1,57 @@
 #!/usr/bin/env node
 
 /**
- * ProjXO - Quick Project Setup CLI
+ * ProjXO - Quick Project Setup & Management CLI
  * 
  * Entry point for the CLI application
- * This file should remain minimal, with all logic in src/cli.js
+ * Handles command routing and argument parsing
  * 
- * @author Sasanga Chathumal
- * @version 1.0.1
+ * @version 1.1.0
  */
 
-// Import the main CLI function
-const { run } = require('./src/cli');
+const { program } = require('commander');
+const { run: createProject } = require('./src/cli');
+const { listCommand } = require('./src/commands/list');
+const logger = require('./src/utils/logger');
 
-// Run the CLI
-run().catch((error) => {
-  console.error('Fatal error:', error.message);
-  process.exit(1);
-});
+// Package info
+const packageJson = require('./package.json');
+
+// Configure CLI
+program
+  .name('pxo')
+  .description('Quick project setup and management for modern web frameworks')
+  .version(packageJson.version);
+
+// Default command (no arguments) - Create new project
+program
+  .action(() => {
+    createProject();
+  });
+
+// List all projects
+program
+  .command('list')
+  .alias('ls')
+  .description('List all tracked projects')
+  .action(() => {
+    listCommand();
+  });
+
+// Handle errors
+program.exitOverride();
+
+try {
+  program.parse(process.argv);
+} catch (error) {
+  if (error.code === 'commander.help') {
+    // Help was displayed, exit normally
+    process.exit(0);
+  } else if (error.code === 'commander.version') {
+    // Version was displayed, exit normally
+    process.exit(0);
+  } else {
+    // logger.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "projxo",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Cross-platform CLI tool to quickly create React, Next.js, Angular, and React Native projects with automatic IDE integration",
   "main": "index.js",
   "bin": {
@@ -55,6 +55,7 @@
     "win32"
   ],
   "dependencies": {
-    "inquirer": "^8.2.6"
+    "inquirer": "^8.2.6",
+    "commander": "^11.1.0"
   }
 }

package/src/cli.js

@@ -60,6 +60,17 @@ async function run() {
     // Open in IDE if selected
     if (answers.selectedIDE !== 'skip') {
       await openInIDE(projectPath, answers.selectedIDE);
+      
+      // Update project with IDE preference
+      const { getProjectByPath, updateProject } = require('./storage/projects');
+      const project = getProjectByPath(projectPath);
+      if (project) {
+        updateProject(project.id, { ide: answers.selectedIDE });
+      }
+    } else {
+      // Show quick access info
+      logger.log('\nQuick access:', 'dim');
+      logger.log(`  pxo list`, 'cyan');
     }
 
   } catch (error) {

package/src/commands/list.js

@@ -0,0 +1,251 @@
+/**
+ * List command - Show all tracked projects
+ * Usage: pxo list
+ */
+
+const inquirer = require('inquirer');
+const path = require('path');
+const { getAllProjects, touchProject, deleteProject } = require('../storage/projects');
+const { openInIDE } = require('../handlers/ideOpener');
+const { getIDE } = require('../config/ides');
+const logger = require('../utils/logger');
+
+/**
+ * Format relative time
+ * @param {string} isoDate - ISO date string
+ * @returns {string} Human-readable relative time
+ */
+function formatRelativeTime(isoDate) {
+  const date = new Date(isoDate);
+  const now = new Date();
+  const diffMs = now - date;
+  const diffMins = Math.floor(diffMs / 60000);
+  const diffHours = Math.floor(diffMs / 3600000);
+  const diffDays = Math.floor(diffMs / 86400000);
+  
+  if (diffMins < 1) return 'just now';
+  if (diffMins < 60) return `${diffMins} min${diffMins > 1 ? 's' : ''} ago`;
+  if (diffHours < 24) return `${diffHours} hour${diffHours > 1 ? 's' : ''} ago`;
+  if (diffDays < 7) return `${diffDays} day${diffDays > 1 ? 's' : ''} ago`;
+  if (diffDays < 30) return `${Math.floor(diffDays / 7)} week${Math.floor(diffDays / 7) > 1 ? 's' : ''} ago`;
+  return `${Math.floor(diffDays / 30)} month${Math.floor(diffDays / 30) > 1 ? 's' : ''} ago`;
+}
+
+/**
+ * Get project type display name
+ * @param {string} type - Project type key
+ * @returns {string} Formatted display name
+ */
+function getTypeDisplay(type) {
+  const typeMap = {
+    'react-vite': 'React+Vite',
+    'react-vite-ts': 'React+Vite(TS)',
+    'nextjs': 'Next.js',
+    'angular': 'Angular',
+    'react-native': 'React Native'
+  };
+  return typeMap[type] || type;
+}
+
+/**
+ * Execute list command
+ */
+async function listCommand() {
+  try {
+    const projects = getAllProjects();
+    
+    if (projects.length === 0) {
+      logger.info('No projects found');
+      logger.log('\nCreate your first project with:', 'dim');
+      logger.log('  pxo', 'cyan');
+      return;
+    }
+    
+    logger.newLine();
+    logger.log(`📦 Your Projects (${projects.length})`, 'bright');
+    logger.newLine();
+    
+    // Create choices for inquirer
+    const choices = projects.map(project => {
+      const typeDisplay = getTypeDisplay(project.type);
+      const timeAgo = formatRelativeTime(project.lastAccessed);
+      
+      return {
+        name: `${project.name}  │  ${typeDisplay}  │  ${timeAgo}`,
+        value: project.id,
+        short: project.name
+      };
+    });
+    
+    // Add separator and action options
+    choices.push(
+      new inquirer.Separator(),
+      { name: '← Back', value: 'back' }
+    );
+    
+    const { selectedId } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selectedId',
+        message: 'Select a project:',
+        choices,
+        pageSize: 15
+      }
+    ]);
+    
+    if (selectedId === 'back') {
+      return;
+    }
+    
+    // Show actions for selected project
+    await showProjectActions(selectedId);
+    
+  } catch (error) {
+    if (error.isTtyError) {
+      logger.error('This command requires an interactive terminal');
+    } else {
+      logger.error(`Failed to list projects: ${error.message}`);
+    }
+  }
+}
+
+/**
+ * Show actions for a selected project
+ * @param {string} projectId - Project ID
+ */
+async function showProjectActions(projectId) {
+  const { getProjectById } = require('../storage/projects');
+  const project = getProjectById(projectId);
+  
+  if (!project) {
+    logger.error('Project not found');
+    return;
+  }
+  
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: `Actions for "${project.name}":`,
+      choices: [
+        { name: '📂 Open in IDE', value: 'open' },
+        { name: '📋 Copy path', value: 'copy' },
+        { name: '🗑️  Remove from tracking', value: 'delete' },
+        { name: 'ℹ️  Show details', value: 'details' },
+        new inquirer.Separator(),
+        { name: '← Back to list', value: 'back' }
+      ]
+    }
+  ]);
+  
+  switch (action) {
+    case 'open':
+      await handleOpenProject(project);
+      break;
+      
+    case 'copy':
+      handleCopyPath(project);
+      break;
+      
+    case 'delete':
+      await handleDeleteProject(project);
+      await listCommand(); // Refresh list
+      break;
+      
+    case 'details':
+      showProjectDetails(project);
+      await showProjectActions(projectId); // Show actions again
+      break;
+      
+    case 'back':
+      await listCommand(); // Go back to list
+      break;
+  }
+}
+
+/**
+ * Handle opening project in IDE
+ * @param {Object} project - Project object
+ */
+async function handleOpenProject(project) {
+  // Update last accessed time
+  touchProject(project.id);
+  
+  // Use project's preferred IDE or prompt
+  let ideKey = project.ide;
+  
+  if (!ideKey || ideKey === 'skip') {
+    const { getIDEChoices } = require('../config/ides');
+    const { selectedIDE } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selectedIDE',
+        message: 'Select IDE:',
+        choices: getIDEChoices()
+      }
+    ]);
+    ideKey = selectedIDE;
+  }
+  
+  if (ideKey !== 'skip') {
+    const success = await openInIDE(project.path, ideKey);
+    if (success) {
+      logger.success(`Opened ${project.name}`);
+    }
+  }
+}
+
+/**
+ * Handle copying project path
+ * @param {Object} project - Project object
+ */
+function handleCopyPath(project) {
+  // For now, just display the path
+  // In future, could use clipboard library
+  logger.info('Project path:');
+  logger.log(`  ${project.path}`, 'cyan');
+  logger.log('\n(Copy from above)', 'dim');
+}
+
+/**
+ * Handle deleting project from tracking
+ * @param {Object} project - Project object
+ */
+async function handleDeleteProject(project) {
+  const { confirm } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: `Remove "${project.name}" from tracking? (Files won't be deleted)`,
+      default: false
+    }
+  ]);
+  
+  if (confirm) {
+    deleteProject(project.id);
+    logger.success(`Removed ${project.name} from tracking`);
+  }
+}
+
+/**
+ * Show detailed project information
+ * @param {Object} project - Project object
+ */
+function showProjectDetails(project) {
+  logger.newLine();
+  logger.log('━'.repeat(50), 'dim');
+  logger.log(`  ${project.name}`, 'bright');
+  logger.log('━'.repeat(50), 'dim');
+  logger.log(`  Type:         ${getTypeDisplay(project.type)}`, 'cyan');
+  logger.log(`  Path:         ${project.path}`, 'dim');
+  logger.log(`  Created:      ${new Date(project.createdAt).toLocaleString()}`, 'dim');
+  logger.log(`  Last accessed: ${formatRelativeTime(project.lastAccessed)}`, 'dim');
+  if (project.ide) {
+    const ide = getIDE(project.ide);
+    logger.log(`  Default IDE:  ${ide?.name || project.ide}`, 'dim');
+  }
+  logger.log('━'.repeat(50), 'dim');
+  logger.newLine();
+}
+
+module.exports = { listCommand };

package/src/handlers/projectCreator.js

@@ -59,6 +59,24 @@ async function createProject({ projectType, projectName, directory }) {
       await runCommand('npm', ['install'], fullPath);
     }
 
+    // Add project to tracking database
+    const { addProject } = require('../storage/projects');
+    try {
+      addProject({
+        name: projectName,
+        path: fullPath,
+        type: projectType,
+        ide: null // Will be set when opened
+      });
+      logger.success('Project added to ProjXO tracking');
+    } catch (dbError) {
+      // Don't fail project creation if database save fails
+      logger.error(`Failed to add project to tracking database: ${dbError.message}`);
+      if (process.env.DEBUG) {
+        console.error(dbError);
+      }
+    }
+
     return fullPath;
     
   } catch (error) {

package/src/storage/database.js

@@ -0,0 +1,149 @@
+/**
+ * Database utility for ProjXO
+ * Handles low-level file operations for project tracking
+ */
+
+/**
+ * Storage implementation using JSON files.
+ * 
+ * Future consideration: Migrate to SQLite for better performance
+ * at scale (1000+ projects). Node.js includes sqlite module
+ * since v22.5.0, making it dependency-free.
+ * 
+ * Reasons for current JSON approach:
+ * - Human-readable and editable
+ * - Zero dependencies
+ * - Sufficient performance for typical use
+ * - Easier debugging and backup
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Storage directory in user's home
+const STORAGE_DIR = path.join(os.homedir(), '.projxo');
+const PROJECTS_FILE = path.join(STORAGE_DIR, 'projects.json');
+const CONFIG_FILE = path.join(STORAGE_DIR, 'config.json');
+
+/**
+ * Initialize storage directory and files
+ * Creates directory and empty files if they don't exist
+ */
+function initializeStorage() {
+  // Create storage directory if it doesn't exist
+  if (!fs.existsSync(STORAGE_DIR)) {
+    fs.mkdirSync(STORAGE_DIR, { recursive: true });
+  }
+
+  // Create projects file if it doesn't exist
+  if (!fs.existsSync(PROJECTS_FILE)) {
+    fs.writeFileSync(PROJECTS_FILE, JSON.stringify({ projects: [] }, null, 2), 'utf8');
+  }
+
+  // Create config file if it doesn't exist
+  if (!fs.existsSync(CONFIG_FILE)) {
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify({ 
+      version: '1.0.0',
+      defaultIDE: null,
+      lastSync: null
+    }, null, 2), 'utf8');
+  }
+}
+
+/**
+ * Read projects database
+ * @returns {Object} Projects data object
+ */
+function readProjects() {
+  try {
+    initializeStorage();
+    const data = fs.readFileSync(PROJECTS_FILE, 'utf8');
+    return JSON.parse(data);
+  } catch (error) {
+    // If file is corrupted, return empty structure
+    console.warn('Failed to read projects database, initializing new one');
+    return { projects: [] };
+  }
+}
+
+/**
+ * Write projects database
+ * @param {Object} data - Projects data object
+ */
+function writeProjects(data) {
+  try {
+    initializeStorage();
+    fs.writeFileSync(PROJECTS_FILE, JSON.stringify(data, null, 2), 'utf8');
+  } catch (error) {
+    throw new Error(`Failed to write projects database: ${error.message}`);
+  }
+}
+
+/**
+ * Read config
+ * @returns {Object} Config data object
+ */
+function readConfig() {
+  try {
+    initializeStorage();
+    const data = fs.readFileSync(CONFIG_FILE, 'utf8');
+    return JSON.parse(data);
+  } catch (error) {
+    console.warn('Failed to read config, initializing new one');
+    return { version: '1.0.0', defaultIDE: null };
+  }
+}
+
+/**
+ * Write config
+ * @param {Object} data - Config data object
+ */
+function writeConfig(data) {
+  try {
+    initializeStorage();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), 'utf8');
+  } catch (error) {
+    throw new Error(`Failed to write config: ${error.message}`);
+  }
+}
+
+/**
+ * Get storage directory path
+ * @returns {string} Full path to storage directory
+ */
+function getStorageDir() {
+  return STORAGE_DIR;
+}
+
+/**
+ * Backup database files
+ * Creates timestamped backups
+ * @returns {string} Backup directory path
+ */
+function backupDatabase() {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupDir = path.join(STORAGE_DIR, 'backups', timestamp);
+  
+  fs.mkdirSync(backupDir, { recursive: true });
+  
+  if (fs.existsSync(PROJECTS_FILE)) {
+    fs.copyFileSync(PROJECTS_FILE, path.join(backupDir, 'projects.json'));
+  }
+  
+  if (fs.existsSync(CONFIG_FILE)) {
+    fs.copyFileSync(CONFIG_FILE, path.join(backupDir, 'config.json'));
+  }
+  
+  return backupDir;
+}
+
+module.exports = {
+  initializeStorage,
+  readProjects,
+  writeProjects,
+  readConfig,
+  writeConfig,
+  getStorageDir,
+  backupDatabase
+};

package/src/storage/debug-storage.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+
+/**
+ * Debug script for ProjXO storage
+ * Run this to test if storage is working correctly
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+console.log('🔍 ProjXO Storage Debug\n');
+
+// Check storage directory
+const STORAGE_DIR = path.join(os.homedir(), '.projxo');
+console.log('1. Storage directory:', STORAGE_DIR);
+console.log('   Exists?', fs.existsSync(STORAGE_DIR) ? '✓' : '✗');
+
+if (fs.existsSync(STORAGE_DIR)) {
+  // Check permissions
+  try {
+    fs.accessSync(STORAGE_DIR, fs.constants.R_OK | fs.constants.W_OK);
+    console.log('   Writable? ✓');
+  } catch (err) {
+    console.log('   Writable? ✗ (Permission denied)');
+    console.log('   Error:', err.message);
+  }
+  
+  // List files
+  const files = fs.readdirSync(STORAGE_DIR);
+  console.log('   Files:', files.length > 0 ? files.join(', ') : '(empty)');
+} else {
+  console.log('   Creating directory...');
+  try {
+    fs.mkdirSync(STORAGE_DIR, { recursive: true });
+    console.log('   ✓ Created successfully');
+  } catch (err) {
+    console.log('   ✗ Failed to create:', err.message);
+    process.exit(1);
+  }
+}
+
+console.log('\n2. Testing storage module...');
+
+try {
+  const { initializeStorage, readProjects, writeProjects } = require('./database');
+  
+  // Initialize
+  console.log('   Initializing storage...');
+  initializeStorage();
+  console.log('   ✓ Initialized');
+  
+  // Check files again
+  const PROJECTS_FILE = path.join(STORAGE_DIR, 'projects.json');
+  const BOOKMARKS_FILE = path.join(STORAGE_DIR, 'bookmarks.json');
+  const CONFIG_FILE = path.join(STORAGE_DIR, 'config.json');
+  
+  console.log('\n3. Checking files:');
+  console.log('   projects.json:', fs.existsSync(PROJECTS_FILE) ? '✓' : '✗');
+  console.log('   bookmarks.json:', fs.existsSync(BOOKMARKS_FILE) ? '✓' : '✗');
+  console.log('   config.json:', fs.existsSync(CONFIG_FILE) ? '✓' : '✗');
+  
+  // Test read/write
+  console.log('\n4. Testing read/write:');
+  const data = readProjects();
+  console.log('   Read projects:', data.projects ? `✓ (${data.projects.length} projects)` : '✗');
+  
+  // Test adding a project
+  console.log('\n5. Testing addProject:');
+  const { addProject } = require('./projects');
+  
+  const testProject = {
+    name: 'test-project-' + Date.now(),
+    path: '/tmp/test-project',
+    type: 'react-vite',
+    ide: null
+  };
+  
+  const project = addProject(testProject);
+  console.log('   ✓ Added test project:', project.name);
+  
+  // Read back
+  const updatedData = readProjects();
+  console.log('   ✓ Total projects now:', updatedData.projects.length);
+  
+  // Show the file contents
+  console.log('\n6. projects.json contents:');
+  const content = fs.readFileSync(PROJECTS_FILE, 'utf8');
+  console.log(content);
+  
+  console.log('\n✅ All tests passed!');
+  console.log('\nYou can now run: pxo list');
+  
+} catch (error) {
+  console.log('   ✗ Error:', error.message);
+  console.log('\nFull error:');
+  console.error(error);
+  process.exit(1);
+}