codecritique 1.0.0

package/src/pr-history/bot-detector.js

@@ -0,0 +1,123 @@
+/**
+ * Bot Detection Utility
+ *
+ * Detects and filters out bot comments from PR analysis.
+ * Bots provide automated feedback that isn't useful for human review pattern analysis.
+ */
+
+/**
+ * Common bot patterns found in GitHub usernames and comment content
+ */
+const BOT_PATTERNS = {
+  // Username patterns
+  usernames: [
+    /\[bot\]$/i, // e.g., sonarqubecloud[bot], dependabot[bot]
+    /^bot-/i, // e.g., bot-reviewer
+    /-bot$/i, // e.g., review-bot
+    /^dependabot/i, // Dependabot variations
+    /^renovate/i, // Renovate bot variations
+    /^github-actions/i, // GitHub Actions bot
+    /^codecov/i, // Codecov bot
+    /^sonarcloud/i, // SonarCloud variations
+    /^sonarqube/i, // SonarQube variations
+    /^snyk/i, // Snyk security bot
+    /^greenkeeper/i, // Greenkeeper bot
+    /^semantic-release/i, // Semantic release bot
+    /^allcontributors/i, // All contributors bot
+    /^stale/i, // Stale bot
+    /^mergify/i, // Mergify bot
+    /^auto-merge/i, // Auto-merge bots
+    /^ci-bot/i, // CI bots
+    /^deploy-bot/i, // Deploy bots
+  ],
+};
+
+/**
+ * Known bot usernames (exact matches)
+ */
+const KNOWN_BOTS = new Set([
+  'dependabot[bot]',
+  'renovate[bot]',
+  'github-actions[bot]',
+  'codecov[bot]',
+  'sonarqubecloud[bot]',
+  'sonarcloud[bot]',
+  'snyk[bot]',
+  'greenkeeper[bot]',
+  'semantic-release-bot',
+  'allcontributors[bot]',
+  'stale[bot]',
+  'mergify[bot]',
+  'auto-merge-bot',
+  'ci-bot',
+  'deploy-bot',
+  'vercel[bot]',
+  'netlify[bot]',
+  'heroku[bot]',
+  'circleci[bot]',
+  'travis[bot]',
+  'jenkins[bot]',
+  'azure-pipelines[bot]',
+  'gitpod[bot]',
+  'codesandbox[bot]',
+  'deepsource[bot]',
+  'codeclimate[bot]',
+  'codebeat[bot]',
+  'codacy[bot]',
+  'houndci-bot',
+  'danger[bot]',
+  'prettier[bot]',
+  'eslint[bot]',
+  'typescript[bot]',
+]);
+
+/**
+ * Check if a username indicates a bot account
+ * @param {string} username - GitHub username to check
+ * @returns {boolean} True if username appears to be a bot
+ */
+function isBotUsername(username) {
+  if (!username || typeof username !== 'string') {
+    return false;
+  }
+
+  const normalizedUsername = username.toLowerCase().trim();
+
+  // Check exact matches first (most reliable)
+  if (KNOWN_BOTS.has(username) || KNOWN_BOTS.has(normalizedUsername)) {
+    return true;
+  }
+
+  // Check username patterns
+  return BOT_PATTERNS.usernames.some((pattern) => pattern.test(username));
+}
+
+/**
+ * Bot detection for a comment based only on username
+ * @param {Object} comment - Comment object with user and body properties
+ * @returns {boolean} True if comment appears to be from a bot
+ */
+function isBotComment(comment) {
+  if (!comment) {
+    return false;
+  }
+
+  // Only check username (most reliable indicator)
+  const username = comment.user?.login || comment.author_login || comment.author;
+  return username ? isBotUsername(username) : false;
+}
+
+/**
+ * Filter out bot comments from an array of comments
+ * @param {Array<Object>} comments - Array of comment objects
+ * @returns {Array<Object>} Filtered array with bot comments removed
+ */
+export function filterBotComments(comments) {
+  if (!Array.isArray(comments)) {
+    return [];
+  }
+
+  const filtered = comments.filter((comment) => !isBotComment(comment));
+
+  return filtered;
+}

package/src/pr-history/cli-utils.js

@@ -0,0 +1,204 @@
+/**
+ * CLI Utilities for PR History Analysis
+ *
+ * Provides utility functions for GitHub repository detection,
+ * project path handling, and CLI integration.
+ */
+
+import { execSync } from 'child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+
+/**
+ * Detect GitHub repository from git remote origin
+ * @param {string} projectPath - Project directory path
+ * @returns {string|null} Repository in format "owner/repo" or null if not found
+ */
+function detectGitHubRepository(projectPath) {
+  try {
+    const gitDir = path.join(projectPath, '.git');
+    if (!fs.existsSync(gitDir)) {
+      return null;
+    }
+
+    // Get remote origin URL
+    const remoteUrl = execSync('git remote get-url origin', {
+      cwd: projectPath,
+      encoding: 'utf8',
+    }).trim();
+
+    // Parse GitHub repository from various URL formats
+    const patterns = [
+      /github\.com[:/]([^/]+)\/([^/.]+)(?:\.git)?$/, // SSH or HTTPS
+      /github\.com\/([^/]+)\/([^/.]+)(?:\.git)?$/, // HTTPS
+    ];
+
+    for (const pattern of patterns) {
+      const match = remoteUrl.match(pattern);
+      if (match) {
+        return `${match[1]}/${match[2]}`;
+      }
+    }
+
+    return null;
+  } catch (error) {
+    console.warn(chalk.yellow(`Warning: Could not detect GitHub repository: ${error.message}`));
+    return null;
+  }
+}
+
+/**
+ * Get GitHub token from options or environment
+ * @param {Object} options - CLI options
+ * @returns {string|null} GitHub token or null if not found
+ */
+function getGitHubToken(options) {
+  return options.token || process.env.GITHUB_TOKEN || process.env.GH_TOKEN || null;
+}
+
+/**
+ * Resolve project path following the same strategy as embeddings.js
+ * @param {string} directory - Directory option from CLI
+ * @returns {string} Resolved project path
+ */
+function resolveProjectPath(directory) {
+  return directory ? path.resolve(directory) : process.cwd();
+}
+
+/**
+ * Validate GitHub repository format
+ * @param {string} repository - Repository string
+ * @returns {boolean} True if valid format
+ */
+function isValidRepositoryFormat(repository) {
+  if (!repository || typeof repository !== 'string') {
+    return false;
+  }
+
+  // Check for "owner/repo" format
+  const parts = repository.split('/');
+  return parts.length === 2 && parts[0].length > 0 && parts[1].length > 0;
+}
+
+/**
+ * Get repository and project path from CLI options
+ * @param {Object} options - CLI options
+ * @returns {Object} Object with repository and projectPath
+ */
+export function getRepositoryAndProjectPath(options) {
+  // Determine project path using the same strategy as embeddings.js
+  const projectPath = resolveProjectPath(options.directory);
+
+  // Determine repository
+  let repository = options.repository;
+  if (!repository) {
+    repository = detectGitHubRepository(projectPath);
+    if (!repository) {
+      throw new Error(
+        'Could not detect GitHub repository. Please specify repository with --repository option or ensure you are in a Git repository with GitHub remote.'
+      );
+    }
+    console.log(chalk.green(`Auto-detected repository: ${repository}`));
+  } else {
+    if (!isValidRepositoryFormat(repository)) {
+      throw new Error('Invalid repository format. Please use "owner/repo" format.');
+    }
+    console.log(chalk.cyan(`Using specified repository: ${repository}`));
+  }
+
+  return { repository, projectPath };
+}
+
+/**
+ * Validate GitHub token
+ * @param {Object} options - CLI options
+ * @returns {string} GitHub token
+ * @throws {Error} If token is not found
+ */
+export function validateGitHubToken(options) {
+  const token = getGitHubToken(options);
+  if (!token) {
+    throw new Error('GitHub token is required. Please provide token with --token option or set GITHUB_TOKEN environment variable.');
+  }
+  return token;
+}
+
+/**
+ * Display progress information
+ * @param {Object} progress - Progress object
+ * @param {boolean} verbose - Whether to show verbose output
+ */
+export function displayProgress(progress, verbose) {
+  if (verbose) {
+    console.log(chalk.blue(`[${progress.stage}] ${progress.message} (${progress.current}/${progress.total})`));
+  }
+}
+
+/**
+ * Display analysis results summary
+ * @param {Object} results - Analysis results
+ * @param {number} duration - Duration in seconds
+ */
+export function displayAnalysisResults(results, duration) {
+  console.log(chalk.green(`\nAnalysis completed in ${duration}s`));
+  console.log(chalk.green(`Repository: ${results.repository}`));
+  console.log(chalk.green(`Total PRs: ${results.total_prs}`));
+  console.log(chalk.green(`Total Comments: ${results.total_comments}`));
+
+  if (results.patterns && results.patterns.length > 0) {
+    console.log(chalk.blue('\nTop Patterns:'));
+    results.patterns.slice(0, 10).forEach((pattern) => {
+      console.log(chalk.cyan(`  ${pattern.type}: ${pattern.name} (${pattern.count} - ${pattern.percentage}%)`));
+    });
+  }
+
+  if (results.top_authors && results.top_authors.length > 0) {
+    console.log(chalk.blue('\nTop Authors:'));
+    results.top_authors.slice(0, 5).forEach((author) => {
+      console.log(chalk.cyan(`  ${author.author}: ${author.count} comments`));
+    });
+  }
+}
+
+/**
+ * Display status information
+ * @param {Object} status - Status object
+ */
+export function displayStatus(status) {
+  console.log(chalk.blue('\nAnalysis Status:'));
+  console.log(chalk.cyan(`Repository: ${status.repository}`));
+  console.log(chalk.cyan(`Status: ${status.status}`));
+
+  if (status.status !== 'not_started') {
+    console.log(chalk.cyan(`PRs: ${status.prs}`));
+    console.log(chalk.cyan(`Comments: ${status.comments}`));
+
+    if (status.failed_comments > 0) {
+      console.log(chalk.yellow(`Failed Comments: ${status.failed_comments}`));
+    }
+
+    if (status.errors > 0) {
+      console.log(chalk.red(`Errors: ${status.errors}`));
+    }
+
+    if (status.elapsed) {
+      console.log(chalk.cyan(`Elapsed Time: ${status.elapsed}`));
+    }
+  }
+}
+
+/**
+ * Display database statistics
+ * @param {Object} stats - Database statistics
+ * @param {boolean} hasComments - Whether comments exist in database
+ */
+export function displayDatabaseStats(stats, hasComments) {
+  if (hasComments) {
+    console.log(chalk.blue('\nStored Data:'));
+    console.log(chalk.cyan(`Total Comments in Database: ${stats.total_comments}`));
+    console.log(chalk.cyan(`Comment Types: ${Object.keys(stats.comment_types).join(', ')}`));
+  } else {
+    console.log(chalk.yellow('\nNo PR comments found in database for this repository.'));
+  }
+}