e-pick 2.0.0 → 3.0.0

package/src/cli.js

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+
+/**
+ * CLI Entry Point for E-Pick Tool
+ *
+ * Provides a command-line interface for starting the web server
+ * with support for repository management via subcommands.
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import open from 'open';
+import { resolve, isAbsolute, dirname } from 'path';
+import { existsSync, statSync } from 'fs';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import appConfig from './config/app.config.js';
+import repoManager from './config/repo-manager.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const program = new Command();
+
+/**
+ * Check if a path is a valid git repository
+ * @param {string} path - Path to check
+ * @returns {boolean} True if valid git repo
+ */
+function isGitRepository(path) {
+  try {
+    execSync('git rev-parse --git-dir', {
+      cwd: path,
+      stdio: 'pipe',
+    });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Validate repository path
+ * @param {string} path - Path to validate
+ * @returns {string} Absolute path if valid
+ * @throws {Error} If path is invalid
+ */
+function validateRepoPath(path) {
+  const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
+
+  if (!existsSync(absolutePath)) {
+    throw new Error(`Path does not exist: ${absolutePath}`);
+  }
+
+  const stats = statSync(absolutePath);
+  if (!stats.isDirectory()) {
+    throw new Error(`Path is not a directory: ${absolutePath}`);
+  }
+
+  if (!isGitRepository(absolutePath)) {
+    throw new Error(`Path is not a git repository: ${absolutePath}\n\nPlease initialize git or specify a valid git repository.`);
+  }
+
+  return absolutePath;
+}
+
+/**
+ * Get repository name from path
+ * @param {string} repoPath - Repository path
+ * @returns {string} Repository name
+ */
+function getRepoName(repoPath) {
+  try {
+    const remoteName = execSync('git config --get remote.origin.url', {
+      cwd: repoPath,
+      stdio: 'pipe',
+      encoding: 'utf-8',
+    }).trim();
+
+    const match = remoteName.match(/\/([^\/]+?)(?:\.git)?$/);
+    if (match) {
+      return match[1];
+    }
+  } catch (error) {
+    // No remote, use directory name
+  }
+
+  return repoPath.split('/').filter(Boolean).pop();
+}
+
+/**
+ * Display startup banner
+ */
+function displayBanner(repoPath, repoName, port) {
+  console.log();
+  console.log(chalk.cyan.bold('🚀 E-Pick Server'));
+  console.log();
+  console.log(chalk.gray('Repository:'), chalk.white.bold(repoName));
+  console.log(chalk.gray('Path:'), chalk.white(repoPath));
+  console.log(chalk.gray('Server:'), chalk.green.bold(`http://localhost:${port}`));
+  console.log();
+  console.log(chalk.yellow('Press Ctrl+C to stop'));
+  console.log();
+}
+
+/**
+ * Main CLI function
+ */
+async function main() {
+  // ====================
+  // REPO SUBCOMMAND
+  // ====================
+  const repoCmd = program
+    .command('repo')
+    .description('Manage saved repositories');
+
+  // repo list
+  repoCmd
+    .command('list')
+    .description('List all saved repositories')
+    .action(() => {
+      const repos = repoManager.listRepos();
+      const entries = Object.entries(repos);
+
+      if (entries.length === 0) {
+        console.log(chalk.yellow('No saved repositories'));
+        process.exit(0);
+      }
+
+      console.log();
+      console.log(chalk.cyan.bold('📁 Saved Repositories'));
+      console.log();
+
+      entries.forEach(([alias, path]) => {
+        console.log(chalk.white.bold(alias), chalk.gray('→'), chalk.gray(path));
+      });
+
+      console.log();
+      console.log(chalk.gray(`Total: ${entries.length} repositor${entries.length === 1 ? 'y' : 'ies'}`));
+      console.log();
+    });
+
+  // repo add
+  repoCmd
+    .command('add <alias> [path]')
+    .description('Save a repository with an alias')
+    .action((alias, path) => {
+      const repoPath = path || process.cwd();
+
+      try {
+        const absolutePath = validateRepoPath(repoPath);
+        repoManager.saveRepo(alias, absolutePath);
+
+        console.log(chalk.green(`✓ Saved repository: ${alias}`));
+        console.log(chalk.gray(`  Path: ${absolutePath}`));
+      } catch (error) {
+        console.error(chalk.red('✗'), error.message);
+        process.exit(1);
+      }
+    });
+
+  // repo remove
+  repoCmd
+    .command('remove <alias>')
+    .description('Remove a saved repository')
+    .action((alias) => {
+      const success = repoManager.removeRepo(alias);
+
+      if (success) {
+        console.log(chalk.green(`✓ Removed repository: ${alias}`));
+      } else {
+        console.log(chalk.red(`✗ Repository not found: ${alias}`));
+        process.exit(1);
+      }
+    });
+
+
+  // ====================
+  // MAIN COMMAND - Start Server
+  // ====================
+  program
+    .name('epick')
+    .description('Web-based tool for cherry-picking git commits from Excel/CSV files')
+    .version('3.0.0')
+    .argument('[repository]', 'Repository alias or path (default: current directory)')
+    .option('-p, --port <number>', 'Port to run server on (default: 7991)', parseInt)
+    .option('--no-open', 'Do not automatically open browser')
+    .action(async (repository, options) => {
+      let repoPath = repository || process.cwd();
+      let resolvedFromAlias = false;
+
+      // Check if repository is an alias
+      if (repository) {
+        const savedPath = repoManager.getRepoPath(repository);
+        if (savedPath) {
+          repoPath = savedPath;
+          resolvedFromAlias = true;
+          console.log(chalk.gray(`Using saved repository: ${repository}`));
+        }
+      }
+
+      // Validate repository
+      console.log(chalk.gray('Validating repository...'));
+
+      let validatedPath;
+      try {
+        validatedPath = validateRepoPath(repoPath);
+        appConfig.setRepoPath(validatedPath);
+        console.log(chalk.green('✓ Repository validated'));
+      } catch (error) {
+        console.error();
+        console.error(chalk.red('✗ Error:'), error.message);
+        console.error();
+
+        if (error.message.includes('not a git repository')) {
+          console.error(chalk.gray('Tip: Make sure you are in a git repository or provide a valid path'));
+          console.error(chalk.gray('Example: epick /path/to/your/repo'));
+        }
+
+        process.exit(1);
+      }
+
+      // Get repository name
+      const repoName = getRepoName(validatedPath);
+
+      // Set port
+      const port = options.port || appConfig.getServerConfig().defaultPort;
+
+      // Start server
+      console.log(chalk.gray('Starting server...'));
+
+      const { startServer } = await import('./server.js');
+      const { server, actualPort } = await startServer({
+        repoPath: validatedPath,
+        port,
+      });
+
+      console.log(chalk.green(`✓ Server started on port ${actualPort}`));
+
+      // Auto-save repository if not already saved
+      if (!resolvedFromAlias && repository && repository !== process.cwd()) {
+        repoManager.saveRepo(getRepoName(validatedPath), validatedPath);
+        console.log(chalk.gray(`Auto-saved as: ${getRepoName(validatedPath)}`));
+      }
+
+      // Display banner
+      displayBanner(validatedPath, repoName, actualPort);
+
+      // Auto-open browser
+      if (options.open !== false) {
+        try {
+          await open(`http://localhost:${actualPort}`);
+        } catch (error) {
+          console.log(chalk.gray('Note: Could not auto-open browser'));
+        }
+      }
+
+      // Handle graceful shutdown
+      const shutdown = async () => {
+        console.log();
+        console.log(chalk.yellow('Shutting down server...'));
+
+        if (server) {
+          server.close(() => {
+            console.log(chalk.green('Server stopped'));
+            process.exit(0);
+          });
+
+          setTimeout(() => {
+            console.log(chalk.red('Forcing shutdown...'));
+            process.exit(1);
+          }, 5000);
+        } else {
+          process.exit(0);
+        }
+      };
+
+      process.on('SIGINT', shutdown);
+      process.on('SIGTERM', shutdown);
+    });
+
+  await program.parseAsync(process.argv);
+}
+
+// Run CLI
+main().catch((error) => {
+  console.error(chalk.red('Fatal error:'), error.message);
+  process.exit(1);
+});

package/src/commands/cherry-pick.command.js

@@ -0,0 +1,79 @@
+/**
+ * Cherry-Pick Command (Command Pattern)
+ *
+ * Encapsulates cherry-pick operations as command objects.
+ */
+
+class CherryPickCommand {
+  constructor(gitService, commits, options = {}) {
+    this.gitService = gitService;
+    this.commits = commits;
+    this.options = options;
+  }
+
+  /**
+   * Execute the cherry-pick command
+   * @returns {object} Execution result
+   */
+  execute() {
+    try {
+      // Generate the command
+      const command = this.gitService.generateCherryPickCommand(
+        this.commits,
+        this.options,
+      );
+
+      // Get sorted commits with info
+      const sortedCommits = this.gitService.sortCommitsByDate(this.commits);
+      const commitsWithInfo = sortedCommits.map((hash) => {
+        const info = this.gitService.getCommitInfo(hash);
+        return info || { hash, message: 'Unknown', date: null };
+      });
+
+      // Get list of changed files
+      const changedFiles = this.gitService.getChangedFiles(this.commits);
+
+      return {
+        success: true,
+        command,
+        commits: commitsWithInfo,
+        changedFiles,
+        warning: this._generateWarnings(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        command: null,
+        commits: [],
+        changedFiles: [],
+      };
+    }
+  }
+
+  /**
+   * Generate warnings if needed
+   * @returns {string|null} Warning message
+   * @private
+   */
+  _generateWarnings() {
+    if (this.commits.length > 50) {
+      return `You are cherry-picking ${this.commits.length} commits. This may take a while and could result in conflicts.`;
+    }
+    return null;
+  }
+
+  /**
+   * Undo the command (for future implementation)
+   * @returns {object} Undo result
+   */
+  undo() {
+    // Future: Implement cherry-pick abort
+    return {
+      success: false,
+      message: 'Undo not yet implemented',
+    };
+  }
+}
+
+export default CherryPickCommand;

package/src/config/app.config.js

@@ -0,0 +1,115 @@
+/**
+ * Application Configuration (Singleton Pattern)
+ *
+ * Centralized configuration management for the application.
+ * Ensures a single source of truth for all configuration values.
+ */
+
+class AppConfig {
+  constructor() {
+    if (AppConfig.instance) {
+      return AppConfig.instance;
+    }
+
+    // Server configuration
+    this.server = {
+      defaultPort: 7991,
+      fallbackPortRange: {
+        min: 8000,
+        max: 9000,
+      },
+      host: 'localhost',
+    };
+
+    // Git configuration
+    this.git = {
+      timeout: 30000, // 30 seconds
+      maxCommitsPerBatch: 100,
+    };
+
+    // CORS configuration
+    this.cors = {
+      origin: '*',
+      methods: ['GET', 'POST'],
+      allowedHeaders: ['Content-Type'],
+    };
+
+    // Logging configuration
+    this.logging = {
+      level: process.env.LOG_LEVEL || 'info',
+      file: {
+        enabled: false,
+        path: 'logs/app.log',
+      },
+    };
+
+    // Repository configuration (set by CLI)
+    this.repository = {
+      path: null, // Will be set by CLI
+    };
+
+    AppConfig.instance = this;
+  }
+
+  /**
+   * Set the repository path
+   * @param {string} path - Full path to the git repository
+   */
+  setRepoPath(path) {
+    this.repository.path = path;
+  }
+
+  /**
+   * Get the repository path
+   * @returns {string|null} Repository path
+   */
+  getRepoPath() {
+    return this.repository.path;
+  }
+
+  /**
+   * Get server configuration
+   * @returns {object} Server configuration
+   */
+  getServerConfig() {
+    return { ...this.server };
+  }
+
+  /**
+   * Get git configuration
+   * @returns {object} Git configuration
+   */
+  getGitConfig() {
+    return { ...this.git };
+  }
+
+  /**
+   * Get CORS configuration
+   * @returns {object} CORS configuration
+   */
+  getCorsConfig() {
+    return { ...this.cors };
+  }
+
+  /**
+   * Get logging configuration
+   * @returns {object} Logging configuration
+   */
+  getLoggingConfig() {
+    return { ...this.logging };
+  }
+
+  /**
+   * Get singleton instance
+   * @returns {AppConfig} AppConfig instance
+   */
+  static getInstance() {
+    if (!AppConfig.instance) {
+      AppConfig.instance = new AppConfig();
+    }
+    return AppConfig.instance;
+  }
+}
+
+// Export singleton instance
+export default AppConfig.getInstance();

package/src/config/repo-manager.js

@@ -0,0 +1,131 @@
+/**
+ * Repository Configuration Manager
+ * Manages saved repository paths and aliases
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+class RepoManager {
+  constructor() {
+    this.configDir = path.join(os.homedir(), '.e-pick');
+    this.configFile = path.join(this.configDir, 'repos.json');
+    this.ensureConfigExists();
+  }
+
+  /**
+   * Ensure config directory and file exist
+   */
+  ensureConfigExists() {
+    try {
+      if (!fs.existsSync(this.configDir)) {
+        fs.mkdirSync(this.configDir, { recursive: true });
+      }
+
+      if (!fs.existsSync(this.configFile)) {
+        fs.writeFileSync(this.configFile, JSON.stringify({}, null, 2));
+      }
+    } catch (error) {
+      throw new Error(`Failed to create config directory: ${error.message}`);
+    }
+  }
+
+  /**
+   * Load all saved repositories
+   * @returns {object} Map of alias → path
+   */
+  loadRepos() {
+    try {
+      const data = fs.readFileSync(this.configFile, 'utf8');
+      return JSON.parse(data);
+    } catch (error) {
+      return {};
+    }
+  }
+
+  /**
+   * Save repositories to config file
+   * @param {object} repos - Map of alias → path
+   */
+  saveRepos(repos) {
+    try {
+      fs.writeFileSync(this.configFile, JSON.stringify(repos, null, 2));
+    } catch (error) {
+      throw new Error(`Failed to save repos: ${error.message}`);
+    }
+  }
+
+  /**
+   * Save a repository with an alias
+   * @param {string} alias - Repository alias
+   * @param {string} repoPath - Absolute path to repository
+   * @returns {boolean} Success
+   */
+  saveRepo(alias, repoPath) {
+    const repos = this.loadRepos();
+    const absolutePath = path.resolve(repoPath);
+
+    repos[alias] = absolutePath;
+    this.saveRepos(repos);
+
+    return true;
+  }
+
+  /**
+   * Get repository path by alias
+   * @param {string} alias - Repository alias
+   * @returns {string|null} Repository path or null if not found
+   */
+  getRepoPath(alias) {
+    const repos = this.loadRepos();
+    return repos[alias] || null;
+  }
+
+  /**
+   * Remove a saved repository
+   * @param {string} alias - Repository alias
+   * @returns {boolean} Success
+   */
+  removeRepo(alias) {
+    const repos = this.loadRepos();
+
+    if (!repos[alias]) {
+      return false;
+    }
+
+    delete repos[alias];
+    this.saveRepos(repos);
+
+    return true;
+  }
+
+  /**
+   * List all saved repositories
+   * @returns {object} Map of alias → path
+   */
+  listRepos() {
+    return this.loadRepos();
+  }
+
+  /**
+   * Check if a repository alias exists
+   * @param {string} alias - Repository alias
+   * @returns {boolean}
+   */
+  hasRepo(alias) {
+    const repos = this.loadRepos();
+    return alias in repos;
+  }
+
+  /**
+   * Get repository name from path
+   * @param {string} repoPath - Repository path
+   * @returns {string} Repository name (folder name)
+   */
+  getRepoNameFromPath(repoPath) {
+    return path.basename(repoPath);
+  }
+}
+
+export default new RepoManager();

package/src/controllers/commit.controller.js

@@ -0,0 +1,102 @@
+/**
+ * Commit Controller
+ *
+ * Handles API requests for commit validation and cherry-pick operations
+ */
+
+import appConfig from '../config/app.config.js';
+import ValidationService from '../services/validation.service.js';
+import GitService from '../services/git.service.js';
+import CherryPickCommand from '../commands/cherry-pick.command.js';
+import { asyncHandler } from '../utils/error-handler.js';
+
+/**
+ * POST /api/validate
+ * Validate array of commit hashes
+ */
+export const validateCommits = asyncHandler(async (req, res) => {
+  const { commits } = req.body;
+  const repoPath = appConfig.getRepoPath();
+
+  const validationService = new ValidationService(repoPath);
+  const result = await validationService.validateCommits(commits);
+
+  res.json({
+    success: true,
+    ...result,
+  });
+});
+
+/**
+ * POST /api/generate-command
+ * Generate cherry-pick command from validated commits
+ */
+export const generateCommand = asyncHandler(async (req, res) => {
+  const { commits, ignoredCommits = [], options = {} } = req.body;
+  const repoPath = appConfig.getRepoPath();
+
+  // Filter out ignored commits
+  const commitsToProcess = commits.filter(
+    (commit) => !ignoredCommits.includes(commit),
+  );
+
+  if (commitsToProcess.length === 0) {
+    return res.status(400).json({
+      success: false,
+      error: 'ValidationError',
+      message: 'No commits to cherry-pick after filtering ignored commits',
+    });
+  }
+
+  const gitService = new GitService(repoPath);
+  const command = new CherryPickCommand(gitService, commitsToProcess, options);
+  const result = command.execute();
+
+  if (!result.success) {
+    return res.status(500).json({
+      success: false,
+      error: 'GitError',
+      message: result.error,
+    });
+  }
+
+  res.json({
+    success: true,
+    ...result,
+  });
+});
+
+/**
+ * GET /api/repo-info
+ * Get current repository information
+ */
+export const getRepoInfo = asyncHandler(async (req, res) => {
+  const repoPath = appConfig.getRepoPath();
+  const gitService = new GitService(repoPath);
+
+  const repoInfo = gitService.getRepoInfo();
+
+  res.json({
+    success: true,
+    repo: repoInfo,
+  });
+});
+
+/**
+ * GET /api/check-commit/:commitHash
+ * Check if a commit exists in the repository
+ */
+export const checkCommit = asyncHandler(async (req, res) => {
+  const { commitHash } = req.params;
+
+  const repoPath = appConfig.getRepoPath();
+  const gitService = new GitService(repoPath);
+
+  const exists = gitService.validateCommit(commitHash);
+
+  res.json({
+    success: true,
+    exists,
+    commit: commitHash,
+  });
+});