projxo 1.0.1 → 1.1.0

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

package/src/storage/projects.js

@@ -0,0 +1,273 @@
+/**
+ * Projects storage management
+ * CRUD operations for project tracking
+ */
+
+const { randomUUID } = require('crypto');
+const fs = require('fs');
+const { readProjects, writeProjects } = require('./database');
+
+/**
+ * Add a new project to tracking
+ * @param {Object} projectData - Project information
+ * @param {string} projectData.name - Project name
+ * @param {string} projectData.path - Full path to project
+ * @param {string} projectData.type - Project type (react-vite, nextjs, etc.)
+ * @param {string} [projectData.ide] - IDE used to open
+ * @returns {Object} Created project object with ID
+ */
+function addProject({ name, path, type, ide = null }) {
+  const data = readProjects();
+  
+  // Check if project already exists
+  const existing = data.projects.find(p => p.path === path);
+  if (existing) {
+    // Update existing project
+    existing.lastAccessed = new Date().toISOString();
+    existing.type = type;
+    if (ide) existing.ide = ide;
+    writeProjects(data);
+    return existing;
+  }
+  
+  // Create new project entry
+  const project = {
+    id: randomUUID(),
+    name,
+    path,
+    type,
+    createdAt: new Date().toISOString(),
+    lastAccessed: new Date().toISOString(),
+    ide: ide || null,
+    bookmarked: false,
+    tags: []
+  };
+  
+  data.projects.push(project);
+  writeProjects(data);
+  
+  return project;
+}
+
+/**
+ * Get all projects
+ * @param {Object} options - Filter options
+ * @param {boolean} [options.bookmarkedOnly] - Return only bookmarked projects
+ * @param {string} [options.type] - Filter by project type
+ * @returns {Array} Array of project objects
+ */
+function getAllProjects({ bookmarkedOnly = false, type = null } = {}) {
+  const data = readProjects();
+  let projects = data.projects;
+  
+  // Filter bookmarked
+  if (bookmarkedOnly) {
+    projects = projects.filter(p => p.bookmarked);
+  }
+  
+  // Filter by type
+  if (type) {
+    projects = projects.filter(p => p.type === type);
+  }
+  
+  // Sort by last accessed (most recent first)
+  projects.sort((a, b) => 
+    new Date(b.lastAccessed) - new Date(a.lastAccessed)
+  );
+  
+  return projects;
+}
+
+/**
+ * Get project by name (fuzzy match)
+ * @param {string} name - Project name to search for
+ * @returns {Object|null} Project object or null if not found
+ */
+function getProjectByName(name) {
+  const data = readProjects();
+  
+  // Try exact match first
+  let project = data.projects.find(p => 
+    p.name.toLowerCase() === name.toLowerCase()
+  );
+  
+  if (project) return project;
+  
+  // Try partial match
+  project = data.projects.find(p => 
+    p.name.toLowerCase().includes(name.toLowerCase())
+  );
+  
+  return project || null;
+}
+
+/**
+ * Get project by ID
+ * @param {string} id - Project ID
+ * @returns {Object|null} Project object or null if not found
+ */
+function getProjectById(id) {
+  const data = readProjects();
+  return data.projects.find(p => p.id === id) || null;
+}
+
+/**
+ * Get project by path
+ * @param {string} path - Project path
+ * @returns {Object|null} Project object or null if not found
+ */
+function getProjectByPath(path) {
+  const data = readProjects();
+  return data.projects.find(p => p.path === path) || null;
+}
+
+/**
+ * Update project
+ * @param {string} id - Project ID
+ * @param {Object} updates - Fields to update
+ * @returns {Object|null} Updated project or null if not found
+ */
+function updateProject(id, updates) {
+  const data = readProjects();
+  const project = data.projects.find(p => p.id === id);
+  
+  if (!project) return null;
+  
+  // Update fields
+  Object.assign(project, updates);
+  project.lastAccessed = new Date().toISOString();
+  
+  writeProjects(data);
+  return project;
+}
+
+/**
+ * Update project's last accessed time
+ * @param {string} id - Project ID
+ */
+function touchProject(id) {
+  updateProject(id, { lastAccessed: new Date().toISOString() });
+}
+
+/**
+ * Delete project from tracking
+ * @param {string} id - Project ID
+ * @returns {boolean} True if deleted, false if not found
+ */
+function deleteProject(id) {
+  const data = readProjects();
+  const index = data.projects.findIndex(p => p.id === id);
+  
+  if (index === -1) return false;
+  
+  data.projects.splice(index, 1);
+  writeProjects(data);
+  
+  return true;
+}
+
+/**
+ * Get recently accessed projects
+ * @param {number} limit - Maximum number of projects to return
+ * @returns {Array} Array of recent project objects
+ */
+function getRecentProjects(limit = 10) {
+  const data = readProjects();
+  
+  return data.projects
+    .sort((a, b) => new Date(b.lastAccessed) - new Date(a.lastAccessed))
+    .slice(0, limit);
+}
+
+/**
+ * Search projects by query
+ * @param {string} query - Search query
+ * @returns {Array} Array of matching project objects
+ */
+function searchProjects(query) {
+  const data = readProjects();
+  const lowerQuery = query.toLowerCase();
+  
+  return data.projects.filter(p => 
+    p.name.toLowerCase().includes(lowerQuery) ||
+    p.type.toLowerCase().includes(lowerQuery) ||
+    p.path.toLowerCase().includes(lowerQuery) ||
+    (p.tags && p.tags.some(tag => tag.toLowerCase().includes(lowerQuery)))
+  );
+}
+
+/**
+ * Clean projects that no longer exist on disk
+ * @returns {Array} Array of removed project paths
+ */
+function cleanProjects() {
+  const data = readProjects();
+  const removed = [];
+  
+  data.projects = data.projects.filter(p => {
+    if (!fs.existsSync(p.path)) {
+      removed.push(p.path);
+      return false;
+    }
+    return true;
+  });
+  
+  if (removed.length > 0) {
+    writeProjects(data);
+  }
+  
+  return removed;
+}
+
+/**
+ * Get project statistics
+ * @returns {Object} Statistics object
+ */
+function getProjectStats() {
+  const data = readProjects();
+  
+  // Count by type
+  const byType = {};
+  data.projects.forEach(p => {
+    byType[p.type] = (byType[p.type] || 0) + 1;
+  });
+  
+  // Most used IDE
+  const ideCount = {};
+  data.projects.forEach(p => {
+    if (p.ide) {
+      ideCount[p.ide] = (ideCount[p.ide] || 0) + 1;
+    }
+  });
+  
+  const mostUsedIDE = Object.entries(ideCount)
+    .sort((a, b) => b[1] - a[1])[0]?.[0] || 'None';
+  
+  return {
+    total: data.projects.length,
+    bookmarked: data.projects.filter(p => p.bookmarked).length,
+    byType,
+    mostUsedIDE,
+    oldest: data.projects.sort((a, b) => 
+      new Date(a.createdAt) - new Date(b.createdAt)
+    )[0],
+    newest: data.projects.sort((a, b) => 
+      new Date(b.createdAt) - new Date(a.createdAt)
+    )[0]
+  };
+}
+
+module.exports = {
+  addProject,
+  getAllProjects,
+  getProjectByName,
+  getProjectById,
+  getProjectByPath,
+  updateProject,
+  touchProject,
+  deleteProject,
+  getRecentProjects,
+  searchProjects,
+  cleanProjects,
+  getProjectStats
+};

package/src/utils/command.js

@@ -0,0 +1,64 @@
+/**
+ * Command execution utility
+ * Handles spawning child processes and command execution
+ */
+
+const { spawn } = require('child_process');
+const logger = require('./logger');
+
+/**
+ * Execute a shell command
+ * @param {string} command - Command to execute (e.g., 'npm', 'npx')
+ * @param {string[]} args - Array of command arguments
+ * @param {string} [cwd] - Working directory for command execution
+ * @returns {Promise<void>} Resolves when command completes successfully
+ * @throws {Error} If command exits with non-zero code
+ */
+function runCommand(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    // Log the command being executed for debugging
+    logger.log(`\nExecuting: ${command} ${args.join(' ')}`, 'cyan');
+    
+    // Spawn the process
+    const proc = spawn(command, args, {
+      stdio: 'inherit', // Pipe stdin, stdout, stderr to parent process
+      shell: true,      // Use shell for command execution
+      cwd: cwd || process.cwd() // Use provided cwd or current directory
+    });
+
+    // Handle process completion
+    proc.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(`Command failed with exit code ${code}`));
+      } else {
+        resolve();
+      }
+    });
+
+    // Handle process errors (e.g., command not found)
+    proc.on('error', (err) => {
+      reject(new Error(`Failed to execute command: ${err.message}`));
+    });
+  });
+}
+
+/**
+ * Check if a command exists in the system PATH
+ * @param {string} command - Command to check
+ * @returns {Promise<boolean>} True if command exists
+ */
+async function commandExists(command) {
+  const checkCmd = process.platform === 'win32' ? 'where' : 'which';
+  
+  try {
+    await runCommand(checkCmd, [command], process.cwd());
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  runCommand,
+  commandExists
+};

package/src/utils/fileSystem.js

@@ -0,0 +1,147 @@
+/**
+ * File system utility functions
+ * Handles all file and directory operations
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const logger = require('./logger');
+
+/**
+ * Expand tilde (~) in path to home directory
+ * @param {string} filePath - Path that may contain ~
+ * @returns {string} Expanded absolute path
+ * @example
+ * expandHomePath('~/Documents') // -> '/Users/username/Documents'
+ */
+function expandHomePath(filePath) {
+  if (filePath.startsWith('~')) {
+    return filePath.replace('~', os.homedir());
+  }
+  return filePath;
+}
+
+/**
+ * Ensure a directory exists, create if it doesn't
+ * @param {string} dirPath - Directory path to ensure
+ * @returns {boolean} True if directory was created, false if already existed
+ */
+function ensureDirectory(dirPath) {
+  const expandedPath = expandHomePath(dirPath);
+  
+  if (!fs.existsSync(expandedPath)) {
+    fs.mkdirSync(expandedPath, { recursive: true });
+    logger.success(`Created directory: ${expandedPath}`);
+    return true;
+  }
+  
+  return false;
+}
+
+/**
+ * Check if a path exists
+ * @param {string} filePath - Path to check
+ * @returns {boolean} True if path exists
+ */
+function pathExists(filePath) {
+  return fs.existsSync(expandHomePath(filePath));
+}
+
+/**
+ * Check if a path is a directory
+ * @param {string} dirPath - Path to check
+ * @returns {boolean} True if path exists and is a directory
+ */
+function isDirectory(dirPath) {
+  try {
+    const stats = fs.statSync(expandHomePath(dirPath));
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the full absolute path
+ * @param {string} dirPath - Directory path
+ * @param {string} projectName - Project name
+ * @returns {string} Full project path
+ */
+function getProjectPath(dirPath, projectName) {
+  const expandedDir = expandHomePath(dirPath);
+  return path.join(expandedDir, projectName);
+}
+
+/**
+ * Validate directory path
+ * @param {string} dirPath - Directory path to validate
+ * @returns {Object} { valid: boolean, error?: string }
+ */
+function validateDirectoryPath(dirPath) {
+  const expandedPath = expandHomePath(dirPath);
+  
+  // Check if path contains invalid characters
+  const invalidChars = /[<>:"|?*]/;
+  if (invalidChars.test(expandedPath)) {
+    return {
+      valid: false,
+      error: 'Path contains invalid characters'
+    };
+  }
+  
+  // Check if parent directory exists (if path doesn't exist)
+  if (!pathExists(expandedPath)) {
+    const parentDir = path.dirname(expandedPath);
+    if (!pathExists(parentDir)) {
+      return {
+        valid: false,
+        error: 'Parent directory does not exist'
+      };
+    }
+  }
+  
+  return { valid: true };
+}
+
+/**
+ * Validate project name
+ * @param {string} projectName - Project name to validate
+ * @returns {Object} { valid: boolean, error?: string }
+ */
+function validateProjectName(projectName) {
+  if (!projectName || !projectName.trim()) {
+    return {
+      valid: false,
+      error: 'Project name cannot be empty'
+    };
+  }
+  
+  // Allow letters, numbers, hyphens, underscores, dots
+  if (!/^[a-zA-Z0-9-_.]+$/.test(projectName)) {
+    return {
+      valid: false,
+      error: 'Project name can only contain letters, numbers, hyphens, underscores, and dots'
+    };
+  }
+  
+  // Don't allow names starting with dots or hyphens
+  if (/^[.-]/.test(projectName)) {
+    return {
+      valid: false,
+      error: 'Project name cannot start with a dot or hyphen'
+    };
+  }
+  
+  return { valid: true };
+}
+
+module.exports = {
+  expandHomePath,
+  ensureDirectory,
+  pathExists,
+  isDirectory,
+  getProjectPath,
+  validateDirectoryPath,
+  validateProjectName
+};

package/src/utils/logger.js

@@ -0,0 +1,110 @@
+/**
+ * Logger utility for colored terminal output
+ * Provides consistent formatting across the application
+ */
+
+// ANSI color codes for terminal styling
+const COLORS = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  
+  // Standard colors
+  black: '\x1b[30m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  
+  // Bright colors
+  brightRed: '\x1b[91m',
+  brightGreen: '\x1b[92m',
+  brightYellow: '\x1b[93m',
+  brightBlue: '\x1b[94m',
+  brightCyan: '\x1b[96m'
+};
+
+/**
+ * Main logging function
+ * @param {string} message - Message to log
+ * @param {string} color - Color key from COLORS object
+ */
+function log(message, color = 'reset') {
+  const colorCode = COLORS[color] || COLORS.reset;
+  console.log(`${colorCode}${message}${COLORS.reset}`);
+}
+
+/**
+ * Log success message with green checkmark
+ * @param {string} message - Success message
+ */
+function success(message) {
+  log(`✓ ${message}`, 'green');
+}
+
+/**
+ * Log error message with red X
+ * @param {string} message - Error message
+ */
+function error(message) {
+  log(`✗ ${message}`, 'red');
+}
+
+/**
+ * Log warning message with yellow exclamation
+ * @param {string} message - Warning message
+ */
+function warning(message) {
+  log(`⚠ ${message}`, 'yellow');
+}
+
+/**
+ * Log info message with blue icon
+ * @param {string} message - Info message
+ */
+function info(message) {
+  log(`ℹ ${message}`, 'blue');
+}
+
+/**
+ * Log a horizontal separator line
+ * @param {number} length - Length of separator (default: 50)
+ * @param {string} color - Color of separator
+ */
+function separator(length = 50, color = 'bright') {
+  log('='.repeat(length), color);
+}
+
+/**
+ * Log a section header with separators
+ * @param {string} title - Section title
+ */
+function section(title) {
+  console.log(); // Empty line
+  separator();
+  log(title, 'bright');
+  separator();
+  console.log(); // Empty line
+}
+
+/**
+ * Log an empty line
+ */
+function newLine() {
+  console.log();
+}
+
+module.exports = {
+  log,
+  success,
+  error,
+  warning,
+  info,
+  separator,
+  section,
+  newLine,
+  COLORS
+};