projxo 1.0.1 → 1.1.0

package/src/config/projectTypes.js

@@ -0,0 +1,145 @@
+/**
+ * Project type configurations
+ * Defines all supported project types and their creation commands
+ * 
+ * To add a new project type:
+ * 1. Add a new key to PROJECT_TYPES object
+ * 2. Specify name, command, getArgs function, and postInstall flag
+ * 3. Add corresponding help text to getNextSteps function
+ */
+
+/**
+ * Project type configuration object
+ * @typedef {Object} ProjectTypeConfig
+ * @property {string} name - Display name for the project type
+ * @property {string} command - Command to execute (npm, npx, etc.)
+ * @property {Function} getArgs - Function that returns command arguments
+ * @property {boolean} postInstall - Whether to run npm install after creation
+ * @property {string} [description] - Optional description
+ */
+
+const PROJECT_TYPES = {
+  'react-vite': {
+    name: 'React + Vite',
+    description: 'React with Vite bundler (JavaScript)',
+    command: 'npm',
+    getArgs: (name) => ['create', 'vite@latest', name, '--', '--template', 'react'],
+    postInstall: true
+  },
+  
+  'react-vite-ts': {
+    name: 'React + Vite (TypeScript)',
+    description: 'React with Vite bundler and TypeScript',
+    command: 'npm',
+    getArgs: (name) => ['create', 'vite@latest', name, '--', '--template', 'react-ts'],
+    postInstall: true
+  },
+  
+  'nextjs': {
+    name: 'Next.js',
+    description: 'React framework for production',
+    command: 'npx',
+    getArgs: (name) => ['create-next-app@latest', name],
+    postInstall: false // create-next-app already installs dependencies
+  },
+  
+  'angular': {
+    name: 'Angular',
+    description: 'Platform for building web applications',
+    command: 'npx',
+    getArgs: (name) => ['@angular/cli@latest', 'new', name],
+    postInstall: false // Angular CLI already installs dependencies
+  },
+  
+  'react-native': {
+    name: 'React Native (Expo)',
+    description: 'Build native mobile apps with React',
+    command: 'npx',
+    getArgs: (name) => ['create-expo-app', name],
+    postInstall: false // Expo already installs dependencies
+  }
+};
+
+/**
+ * Get project type configuration
+ * @param {string} typeKey - Project type key
+ * @returns {ProjectTypeConfig|null} Configuration object or null if not found
+ */
+function getProjectType(typeKey) {
+  return PROJECT_TYPES[typeKey] || null;
+}
+
+/**
+ * Get all project types as an array
+ * @returns {Array<{key: string, config: ProjectTypeConfig}>}
+ */
+function getAllProjectTypes() {
+  return Object.entries(PROJECT_TYPES).map(([key, config]) => ({
+    key,
+    config
+  }));
+}
+
+/**
+ * Get formatted choices for inquirer prompts
+ * @returns {Array<{name: string, value: string}>}
+ */
+function getProjectTypeChoices() {
+  return Object.entries(PROJECT_TYPES).map(([key, config]) => ({
+    name: `${config.name} (${key})`,
+    value: key,
+    short: config.name
+  }));
+}
+
+/**
+ * Get next steps instructions based on project type
+ * @param {string} typeKey - Project type key
+ * @param {string} projectPath - Full path to the project
+ * @returns {string[]} Array of instruction strings
+ */
+function getNextSteps(typeKey, projectPath) {
+  const steps = [`cd ${projectPath}`];
+  
+  switch (typeKey) {
+    case 'react-vite':
+    case 'react-vite-ts':
+      steps.push('npm run dev');
+      break;
+      
+    case 'nextjs':
+      steps.push('npm run dev');
+      break;
+      
+    case 'angular':
+      steps.push('ng serve');
+      break;
+      
+    case 'react-native':
+      steps.push('npx expo start');
+      break;
+      
+    default:
+      steps.push('npm start');
+  }
+  
+  return steps;
+}
+
+/**
+ * Check if a project type exists
+ * @param {string} typeKey - Project type key to check
+ * @returns {boolean}
+ */
+function isValidProjectType(typeKey) {
+  return typeKey in PROJECT_TYPES;
+}
+
+module.exports = {
+  PROJECT_TYPES,
+  getProjectType,
+  getAllProjectTypes,
+  getProjectTypeChoices,
+  getNextSteps,
+  isValidProjectType
+};

package/src/handlers/ideOpener.js

@@ -0,0 +1,73 @@
+/**
+ * IDE opener handler
+ * Handles opening projects in various IDEs
+ */
+
+const { runCommand } = require('../utils/command');
+const { getIDE, getIDEInstallInstructions } = require('../config/ides');
+const logger = require('../utils/logger');
+
+/**
+ * Open a project in the specified IDE
+ * @param {string} projectPath - Full path to the project
+ * @param {string} ideKey - IDE key (e.g., 'vscode', 'cursor')
+ * @returns {Promise<boolean>} True if opened successfully, false otherwise
+ */
+async function openInIDE(projectPath, ideKey) {
+  // Get IDE configuration
+  const ide = getIDE(ideKey);
+  
+  // Skip if no IDE selected or invalid IDE
+  if (!ide || !ide.command) {
+    return false;
+  }
+
+  try {
+    logger.info(`Opening project in ${ide.name}...`);
+    
+    // Execute IDE command with project path
+    await runCommand(ide.command, [projectPath]);
+    
+    logger.success(`Project opened in ${ide.name}`);
+    return true;
+    
+  } catch (error) {
+    // Handle IDE command failure
+    logger.error(`Could not open ${ide.name}`);
+    logger.warning(`Please ensure ${ide.name} is installed and command-line tools are enabled`);
+    
+    // Provide installation instructions
+    const instructions = getIDEInstallInstructions(ideKey);
+    logger.log(`\n  Setup: ${instructions}`, 'dim');
+    
+    // Provide fallback option
+    logger.log(`  Or manually open: ${projectPath}`, 'yellow');
+    
+    return false;
+  }
+}
+
+/**
+ * Validate if IDE command is available
+ * @param {string} ideKey - IDE key to validate
+ * @returns {Promise<boolean>} True if command is available
+ */
+async function validateIDECommand(ideKey) {
+  const ide = getIDE(ideKey);
+  
+  if (!ide || !ide.command) {
+    return true; // Skip validation for 'skip' option
+  }
+
+  try {
+    const { commandExists } = require('../utils/command');
+    return await commandExists(ide.command);
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  openInIDE,
+  validateIDECommand
+};

package/src/handlers/projectCreator.js

@@ -0,0 +1,151 @@
+/**
+ * Project creator handler
+ * Handles the project creation process
+ */
+
+const { runCommand } = require('../utils/command');
+const { 
+  expandHomePath, 
+  ensureDirectory, 
+  pathExists, 
+  getProjectPath 
+} = require('../utils/fileSystem');
+const { getProjectType, getNextSteps } = require('../config/projectTypes');
+const logger = require('../utils/logger');
+
+/**
+ * Create a new project
+ * @param {Object} options - Project creation options
+ * @param {string} options.projectType - Project type key
+ * @param {string} options.projectName - Name of the project
+ * @param {string} options.directory - Directory path where project will be created
+ * @returns {Promise<string>} Full path to the created project
+ * @throws {Error} If project creation fails
+ */
+async function createProject({ projectType, projectName, directory }) {
+  // Get project type configuration
+  const config = getProjectType(projectType);
+  
+  if (!config) {
+    throw new Error(`Invalid project type: ${projectType}`);
+  }
+
+  // Expand home directory and ensure directory exists
+  const expandedDir = expandHomePath(directory);
+  ensureDirectory(expandedDir);
+
+  // Get full project path
+  const fullPath = getProjectPath(expandedDir, projectName);
+
+  // Check if project already exists
+  if (pathExists(fullPath)) {
+    throw new Error('PROJECT_EXISTS');
+  }
+
+  // Display creation start message
+  logger.section('Starting project creation...');
+
+  try {
+    // Execute project creation command in the target directory
+    await runCommand(
+      config.command,
+      config.getArgs(projectName),
+      expandedDir
+    );
+
+    // Run post-install if needed
+    if (config.postInstall) {
+      logger.info('Installing dependencies...');
+      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) {
+    // Provide helpful error message
+    throw new Error(`Failed to create project: ${error.message}`);
+  }
+}
+
+/**
+ * Display project creation success message with next steps
+ * @param {string} projectPath - Full path to the created project
+ * @param {string} projectType - Project type key
+ */
+function displaySuccessMessage(projectPath, projectType) {
+  logger.section('✓ Project created successfully!');
+
+  logger.log('Project location:', 'bright');
+  logger.log(`  ${projectPath}`, 'cyan');
+  
+  logger.newLine();
+  logger.log('Next steps:', 'bright');
+  
+  const steps = getNextSteps(projectType, projectPath);
+  steps.forEach(step => {
+    logger.log(`  ${step}`, 'green');
+  });
+  
+  logger.newLine();
+}
+
+/**
+ * Validate project creation parameters
+ * @param {Object} params - Parameters to validate
+ * @param {string} params.projectType - Project type key
+ * @param {string} params.projectName - Project name
+ * @param {string} params.directory - Directory path
+ * @returns {Object} { valid: boolean, error?: string }
+ */
+function validateProjectParams({ projectType, projectName, directory }) {
+  // Validate project type
+  const config = getProjectType(projectType);
+  if (!config) {
+    return {
+      valid: false,
+      error: `Invalid project type: ${projectType}`
+    };
+  }
+
+  // Validate project name
+  if (!projectName || projectName.trim() === '') {
+    return {
+      valid: false,
+      error: 'Project name is required'
+    };
+  }
+
+  // Validate directory
+  if (!directory || directory.trim() === '') {
+    return {
+      valid: false,
+      error: 'Directory is required'
+    };
+  }
+
+  return { valid: true };
+}
+
+module.exports = {
+  createProject,
+  displaySuccessMessage,
+  validateProjectParams
+};

package/src/prompts/questions.js

@@ -0,0 +1,105 @@
+/**
+ * Inquirer prompt definitions
+ * Centralizes all user prompts for consistency
+ */
+
+const { getProjectTypeChoices } = require('../config/projectTypes');
+const { getIDEChoices } = require('../config/ides');
+const { validateProjectName } = require('../utils/fileSystem');
+
+/**
+ * Get project type selection prompt
+ * @returns {Object} Inquirer prompt configuration
+ */
+function getProjectTypePrompt() {
+  return {
+    type: 'list',
+    name: 'projectType',
+    message: 'Select project type:',
+    choices: getProjectTypeChoices(),
+    pageSize: 10
+  };
+}
+
+/**
+ * Get project name input prompt
+ * @returns {Object} Inquirer prompt configuration
+ */
+function getProjectNamePrompt() {
+  return {
+    type: 'input',
+    name: 'projectName',
+    message: 'Enter project name:',
+    validate: (input) => {
+      const result = validateProjectName(input);
+      return result.valid ? true : result.error;
+    },
+    filter: (input) => input.trim() // Remove leading/trailing whitespace
+  };
+}
+
+/**
+ * Get directory path input prompt
+ * @param {string} defaultPath - Default directory path
+ * @returns {Object} Inquirer prompt configuration
+ */
+function getDirectoryPrompt(defaultPath) {
+  return {
+    type: 'input',
+    name: 'directory',
+    message: 'Enter directory path:',
+    default: defaultPath,
+    filter: (input) => input.trim()
+  };
+}
+
+/**
+ * Get IDE selection prompt
+ * @returns {Object} Inquirer prompt configuration
+ */
+function getIDEPrompt() {
+  return {
+    type: 'list',
+    name: 'selectedIDE',
+    message: 'Select IDE to open:',
+    choices: getIDEChoices(),
+    pageSize: 10
+  };
+}
+
+/**
+ * Get overwrite confirmation prompt
+ * @param {string} projectName - Name of the project that already exists
+ * @returns {Object} Inquirer prompt configuration
+ */
+function getOverwritePrompt(projectName) {
+  return {
+    type: 'confirm',
+    name: 'overwrite',
+    message: `Project "${projectName}" already exists. Overwrite?`,
+    default: false
+  };
+}
+
+/**
+ * Get all prompts for project creation flow
+ * @param {string} defaultDirectory - Default directory path
+ * @returns {Array<Object>} Array of prompt configurations
+ */
+function getProjectCreationPrompts(defaultDirectory) {
+  return [
+    getProjectTypePrompt(),
+    getProjectNamePrompt(),
+    getDirectoryPrompt(defaultDirectory),
+    getIDEPrompt()
+  ];
+}
+
+module.exports = {
+  getProjectTypePrompt,
+  getProjectNamePrompt,
+  getDirectoryPrompt,
+  getIDEPrompt,
+  getOverwritePrompt,
+  getProjectCreationPrompts
+};

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
+};