e-pick 2.0.0 → 3.0.0

package/src/middleware/error.middleware.js

@@ -0,0 +1,33 @@
+/**
+ * Error Handling Middleware
+ *
+ * Global error handler for Express
+ */
+
+import { serializeError } from '../utils/error-handler.js';
+
+/**
+ * Global error handling middleware
+ * Must be registered last in middleware chain
+ */
+export function errorHandler(err, req, res, next) {
+  console.error('Error:', err);
+
+  const serialized = serializeError(err);
+
+  res.status(serialized.statusCode || 500).json({
+    success: false,
+    ...serialized,
+  });
+}
+
+/**
+ * 404 Not Found handler
+ */
+export function notFoundHandler(req, res) {
+  res.status(404).json({
+    success: false,
+    error: 'NotFound',
+    message: `Cannot ${req.method} ${req.path}`,
+  });
+}

package/src/middleware/validation.middleware.js

@@ -0,0 +1,61 @@
+/**
+ * Validation Middleware
+ *
+ * Request validation using Joi schemas
+ */
+
+import Joi from 'joi';
+import { ValidationError } from '../utils/error-handler.js';
+
+/**
+ * Validate request body against Joi schema
+ * @param {object} schema - Joi schema
+ * @returns {Function} Express middleware
+ */
+export function validateBody(schema) {
+  return (req, res, next) => {
+    const { error, value } = schema.validate(req.body, {
+      abortEarly: false,
+      stripUnknown: true,
+    });
+
+    if (error) {
+      const message = error.details.map((d) => d.message).join(', ');
+      return next(new ValidationError(message));
+    }
+
+    req.body = value;
+    next();
+  };
+}
+
+/**
+ * Validate commits array schema
+ */
+export const validateCommitsSchema = Joi.object({
+  commits: Joi.array()
+    .items(Joi.string().pattern(/^[0-9a-f]{40}$/i))
+    .min(1)
+    .required()
+    .messages({
+      'array.min': 'At least one commit is required',
+      'string.pattern.base': 'Each commit must be a valid 40-character hash',
+    }),
+});
+
+/**
+ * Generate command schema
+ */
+export const generateCommandSchema = Joi.object({
+  commits: Joi.array()
+    .items(Joi.string().pattern(/^[0-9a-f]{40}$/i))
+    .min(1)
+    .required(),
+  ignoredCommits: Joi.array()
+    .items(Joi.string().pattern(/^[0-9a-f]{40}$/i))
+    .default([]),
+  options: Joi.object({
+    allowEmpty: Joi.boolean().default(false),
+    continueOnConflict: Joi.boolean().default(false),
+  }).default({}),
+});

package/src/server.js

@@ -0,0 +1,121 @@
+/**
+ * Express Server
+ *
+ * Main server file that sets up Express app and routes.
+ */
+
+import express from 'express';
+import helmet from 'helmet';
+import cors from 'cors';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { readFileSync } from 'fs';
+import appConfig from './config/app.config.js';
+import * as commitController from './controllers/commit.controller.js';
+import { validateBody, validateCommitsSchema, generateCommandSchema } from './middleware/validation.middleware.js';
+import { errorHandler, notFoundHandler } from './middleware/error.middleware.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Start the Express server
+ * @param {object} options - Server options
+ * @param {string} options.repoPath - Path to git repository
+ * @param {number} options.port - Port to run server on
+ * @returns {Promise<{server: object, actualPort: number}>}
+ */
+export async function startServer(options) {
+  const { repoPath, port } = options;
+
+  // Set repo path in config
+  appConfig.setRepoPath(repoPath);
+
+  // Create Express app
+  const app = express();
+
+  // Security middleware
+  app.use(helmet({
+    contentSecurityPolicy: false, // Allow inline scripts for CDN libraries
+  }));
+
+  // CORS middleware
+  app.use(cors(appConfig.getCorsConfig()));
+
+  // Parse JSON bodies
+  app.use(express.json({ limit: '10mb' }));
+
+  // Serve static files
+  const publicPath = join(__dirname, '../public');
+  app.use(express.static(publicPath));
+
+  // API Routes
+
+  // Health check endpoint
+  app.get('/api/health', (req, res) => {
+    res.json({
+      status: 'ok',
+      repoPath: appConfig.getRepoPath(),
+    });
+  });
+
+  // Get version from package.json
+  app.get('/api/version', (req, res) => {
+    try {
+      const packageJsonPath = join(__dirname, '../package.json');
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+      res.json({
+        version: packageJson.version,
+        name: packageJson.name,
+      });
+    } catch (error) {
+      res.status(500).json({ error: 'Failed to read version' });
+    }
+  });
+
+  // Get repository information
+  app.get('/api/repo-info', commitController.getRepoInfo);
+
+  // Check if commit exists
+  app.get('/api/check-commit/:commitHash', commitController.checkCommit);
+
+  // Validate commits
+  app.post(
+    '/api/validate',
+    validateBody(validateCommitsSchema),
+    commitController.validateCommits,
+  );
+
+  // Generate cherry-pick command
+  app.post(
+    '/api/generate-command',
+    validateBody(generateCommandSchema),
+    commitController.generateCommand,
+  );
+
+  // 404 handler
+  app.use(notFoundHandler);
+
+  // Error handling middleware (must be last)
+  app.use(errorHandler);
+
+  // Start server with port fallback logic
+  return new Promise((resolve, reject) => {
+    const tryPort = (portToTry) => {
+      const server = app.listen(portToTry, () => {
+        resolve({ server, actualPort: portToTry });
+      }).on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+          // Port is in use, try random port in fallback range
+          const { min, max } = appConfig.getServerConfig().fallbackPortRange;
+          const randomPort = Math.floor(Math.random() * (max - min + 1)) + min;
+          tryPort(randomPort);
+        } else {
+          reject(err);
+        }
+      });
+    };
+
+    tryPort(port);
+  });
+}

package/src/services/git.service.js

@@ -0,0 +1,277 @@
+/**
+ * Git Service (Repository Pattern)
+ *
+ * Abstracts all git operations and provides a clean interface
+ * for interacting with git repositories.
+ */
+
+import { execSync } from 'child_process';
+import appConfig from '../config/app.config.js';
+
+class GitService {
+  constructor(repoPath) {
+    this.repoPath = repoPath || appConfig.getRepoPath();
+    this.timeout = appConfig.getGitConfig().timeout;
+  }
+
+  /**
+   * Execute a git command
+   * @param {string} command - Git command to execute
+   * @returns {string} Command output
+   * @private
+   */
+  _execGit(command) {
+    try {
+      return execSync(command, {
+        cwd: this.repoPath,
+        encoding: 'utf-8',
+        timeout: this.timeout,
+        stdio: 'pipe',
+      }).trim();
+    } catch (error) {
+      throw new Error(`Git command failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if a path is a valid git repository (static method)
+   * @param {string} path - Path to check
+   * @returns {boolean} True if valid git repo
+   */
+  static checkIfGitRepo(path) {
+    try {
+      execSync('git rev-parse --git-dir', {
+        cwd: path,
+        stdio: 'pipe',
+      });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Validate if a commit hash exists in the repository
+   * @param {string} commitHash - Commit hash to validate
+   * @returns {boolean} True if commit exists
+   */
+  validateCommit(commitHash) {
+    try {
+      const result = this._execGit(`git cat-file -t ${commitHash}`);
+      return result === 'commit';
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get detailed information about a commit
+   * @param {string} commitHash - Commit hash
+   * @returns {object|null} Commit information or null if not found
+   */
+  getCommitInfo(commitHash) {
+    try {
+      // Get commit details in a specific format
+      const format = '%ci|%an|%ae|%s|%H';
+      const output = this._execGit(`git show -s --format="${format}" ${commitHash}`);
+
+      const [date, author, email, message, hash] = output.split('|');
+
+      return {
+        hash,
+        date: new Date(date).toISOString(),
+        author,
+        email,
+        message,
+        shortHash: hash.substring(0, 7),
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Get current branch name
+   * @returns {string} Branch name
+   */
+  getCurrentBranch() {
+    try {
+      return this._execGit('git rev-parse --abbrev-ref HEAD');
+    } catch (error) {
+      return 'unknown';
+    }
+  }
+
+  /**
+   * Get repository name/identifier
+   * @returns {string} Repository name
+   */
+  getRepoName() {
+    try {
+      // Try to get from remote URL first
+      const remoteUrl = this._execGit('git config --get remote.origin.url');
+      const match = remoteUrl.match(/\/([^\/]+?)(?:\.git)?$/);
+      if (match) {
+        return match[1];
+      }
+    } catch (error) {
+      // No remote, use directory name
+    }
+
+    // Fallback to directory name
+    return this.repoPath.split('/').filter(Boolean).pop();
+  }
+
+  /**
+   * Get repository information
+   * @returns {object} Repository information
+   */
+  getRepoInfo() {
+    try {
+      const branch = this.getCurrentBranch();
+      const lastCommit = this._execGit('git log -1 --format="%H|%s|%ci"');
+      const [hash, message, date] = lastCommit.split('|');
+
+      let remoteName = 'No remote';
+      let remoteUrl = null;
+
+      try {
+        remoteUrl = this._execGit('git config --get remote.origin.url');
+        // Extract repo name from URL
+        const match = remoteUrl.match(/\/([^\/]+?)(?:\.git)?$/);
+        if (match) {
+          remoteName = match[1];
+        }
+      } catch (error) {
+        // No remote configured
+      }
+
+      return {
+        path: this.repoPath,
+        branch,
+        remoteName,
+        remoteUrl,
+        repoName: this.getRepoName(),
+        lastCommit: {
+          hash: hash.substring(0, 7),
+          message,
+          date: new Date(date).toISOString(),
+        },
+      };
+    } catch (error) {
+      throw new Error(`Failed to get repository info: ${error.message}`);
+    }
+  }
+
+  /**
+   * Sort commits by date (chronological order)
+   * @param {string[]} commits - Array of commit hashes
+   * @returns {string[]} Sorted commit hashes
+   */
+  sortCommitsByDate(commits) {
+    try {
+      if (commits.length === 0) return [];
+
+      // Get commit dates
+      const command = `git show -s --format="%ci %H" ${commits.join(' ')}`;
+      const output = this._execGit(command);
+
+      // Parse and sort by date
+      const commitData = output
+        .split('\n')
+        .map((line) => {
+          const parts = line.split(' ');
+          const date = parts.slice(0, 3).join(' ');
+          const hash = parts[3];
+          return { date, hash };
+        })
+        .sort((a, b) => new Date(a.date) - new Date(b.date));
+
+      return commitData.map((item) => item.hash);
+    } catch (error) {
+      throw new Error(`Failed to sort commits: ${error.message}`);
+    }
+  }
+
+  /**
+   * Generate cherry-pick command
+   * @param {string[]} commits - Array of commit hashes (will be sorted)
+   * @param {object} options - Options for cherry-pick
+   * @returns {string} Cherry-pick command
+   */
+  generateCherryPickCommand(commits, options = {}) {
+    if (commits.length === 0) {
+      throw new Error('No commits provided');
+    }
+
+    // Sort commits chronologically
+    const sortedCommits = this.sortCommitsByDate(commits);
+
+    // Build command
+    let command = 'git cherry-pick';
+
+    if (options.allowEmpty) {
+      command += ' --allow-empty';
+    }
+
+    if (options.continueOnConflict) {
+      command += ' --continue';
+    }
+
+    command += ` ${sortedCommits.join(' ')}`;
+
+    return command;
+  }
+
+  /**
+   * Execute cherry-pick command (optional - for Phase 6)
+   * @param {string[]} commits - Array of commit hashes
+   * @param {object} options - Options for cherry-pick
+   * @returns {object} Execution result
+   */
+  executeCherryPick(commits, options = {}) {
+    try {
+      const command = this.generateCherryPickCommand(commits, options);
+      const output = this._execGit(command);
+
+      return {
+        success: true,
+        output,
+        command,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        command: this.generateCherryPickCommand(commits, options),
+      };
+    }
+  }
+
+  /**
+   * Get list of files changed in commits
+   * @param {string[]} commits - Array of commit hashes
+   * @returns {string[]} Array of unique file paths
+   */
+  getChangedFiles(commits) {
+    try {
+      if (commits.length === 0) return [];
+
+      // Get list of files changed in all commits using git show
+      const command = `git show --name-only --pretty=format: ${commits.join(' ')}`;
+      const output = this._execGit(command);
+
+      // Split by newline and remove duplicates
+      const files = output
+        .split('\n')
+        .filter((file) => file.trim() !== '')
+        .filter((file, index, self) => self.indexOf(file) === index);
+
+      return files;
+    } catch (error) {
+      throw new Error(`Failed to get changed files: ${error.message}`);
+    }
+  }
+}
+
+export default GitService;

package/src/services/validation.service.js

@@ -0,0 +1,102 @@
+/**
+ * Validation Service
+ *
+ * Orchestrates validation of multiple commits and provides
+ * summary and grouping functionality.
+ */
+
+import { validateCommit } from '../validators/commit.validator.js';
+import GitService from './git.service.js';
+
+class ValidationService {
+  constructor(repoPath) {
+    this.gitService = new GitService(repoPath);
+  }
+
+  /**
+   * Validate multiple commits
+   * @param {string[]} commits - Array of commit hashes
+   * @returns {Promise<object>} Validation results
+   */
+  async validateCommits(commits) {
+    if (!Array.isArray(commits) || commits.length === 0) {
+      return {
+        results: [],
+        summary: {
+          total: 0,
+          valid: 0,
+          invalid: 0,
+          canBeIgnored: 0,
+        },
+      };
+    }
+
+    // Validate each commit
+    const validationPromises = commits.map((commit) => validateCommit(commit, { gitService: this.gitService }));
+
+    const results = await Promise.all(validationPromises);
+
+    // Generate summary
+    const summary = this.generateSummary(results);
+
+    return {
+      results,
+      summary,
+    };
+  }
+
+  /**
+   * Generate validation summary
+   * @param {array} results - Validation results
+   * @returns {object} Summary statistics
+   * @private
+   */
+  generateSummary(results) {
+    const summary = {
+      total: results.length,
+      valid: 0,
+      invalid: 0,
+      canBeIgnored: 0,
+    };
+
+    results.forEach((result) => {
+      if (result.isValid) {
+        summary.valid++;
+      } else {
+        summary.invalid++;
+        if (result.canIgnore) {
+          summary.canBeIgnored++;
+        }
+      }
+    });
+
+    return summary;
+  }
+
+  /**
+   * Group validation results by status
+   * @param {array} results - Validation results
+   * @returns {object} Grouped results
+   */
+  groupValidationResults(results) {
+    return {
+      valid: results.filter((r) => r.isValid),
+      invalid: results.filter((r) => !r.isValid && !r.canIgnore),
+      ignorable: results.filter((r) => !r.isValid && r.canIgnore),
+    };
+  }
+
+  /**
+   * Filter commits by validity
+   * @param {array} results - Validation results
+   * @param {array} ignoredCommits - Commits to ignore (optional)
+   * @returns {array} Valid commit hashes
+   */
+  getValidCommits(results, ignoredCommits = []) {
+    return results
+      .filter((r) => r.isValid && !ignoredCommits.includes(r.commit))
+      .map((r) => r.commit);
+  }
+}
+
+export default ValidationService;

package/src/utils/error-handler.js

@@ -0,0 +1,80 @@
+/**
+ * Error Handler Utilities
+ *
+ * Custom error classes and error handling utilities
+ */
+
+/**
+ * Base application error class
+ */
+export class AppError extends Error {
+  constructor(message, statusCode = 500) {
+    super(message);
+    this.statusCode = statusCode;
+    this.isOperational = true;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+/**
+ * Validation error (400)
+ */
+export class ValidationError extends AppError {
+  constructor(message) {
+    super(message, 400);
+    this.name = 'ValidationError';
+  }
+}
+
+/**
+ * Git operation error (500)
+ */
+export class GitError extends AppError {
+  constructor(message) {
+    super(message, 500);
+    this.name = 'GitError';
+  }
+}
+
+/**
+ * Not found error (404)
+ */
+export class NotFoundError extends AppError {
+  constructor(message) {
+    super(message, 404);
+    this.name = 'NotFoundError';
+  }
+}
+
+/**
+ * Serialize error for API response
+ * @param {Error} error - Error object
+ * @returns {object} Serialized error
+ */
+export function serializeError(error) {
+  if (error instanceof AppError) {
+    return {
+      error: error.name,
+      message: error.message,
+      statusCode: error.statusCode,
+    };
+  }
+
+  // Unknown error
+  return {
+    error: 'InternalServerError',
+    message: 'An unexpected error occurred',
+    statusCode: 500,
+  };
+}
+
+/**
+ * Async handler wrapper to catch errors in async route handlers
+ * @param {Function} fn - Async function
+ * @returns {Function} Wrapped function
+ */
+export function asyncHandler(fn) {
+  return (req, res, next) => {
+    Promise.resolve(fn(req, res, next)).catch(next);
+  };
+}