codecritique 1.0.0 → 1.1.0

package/src/utils/document-detection.js

@@ -1,105 +0,0 @@
-/**
- * Document Detection Module
- *
- * This module provides utilities for detecting different types of documents,
- * particularly focusing on generic documentation files and their classification.
- */
-
-import path from 'path';
-import { GENERIC_DOC_REGEX } from './constants.js';
-
-/**
- * Check if a document is a generic documentation file (README, RUNBOOK, etc.)
- *
- * @param {string} docPath - Document file path
- * @param {string} docH1 - Document H1 title (optional)
- * @returns {boolean} True if document is generic documentation, false otherwise
- *
- * @example
- * const isGeneric = isGenericDocument('README.md');
- * // Returns: true
- *
- * const isGeneric2 = isGenericDocument('docs/api-guide.md', 'API Guide');
- * // Returns: false
- */
-export function isGenericDocument(docPath, docH1 = null) {
-  if (!docPath) return false;
-
-  // Check filename pattern
-  if (GENERIC_DOC_REGEX.test(docPath)) {
-    return true;
-  }
-
-  // Check H1 title if provided
-  if (docH1) {
-    const lowerH1 = docH1.toLowerCase();
-    const genericTitlePatterns = ['readme', 'runbook', 'changelog', 'contributing', 'license', 'setup', 'installation', 'getting started'];
-
-    return genericTitlePatterns.some((pattern) => lowerH1.includes(pattern));
-  }
-
-  return false;
-}
-
-/**
- * Get pre-computed context for generic documents to avoid expensive inference
- *
- * @param {string} docPath - Document file path
- * @returns {Object} Pre-computed generic document context with area, tech, and metadata
- *
- * @example
- * const context = getGenericDocumentContext('README.md');
- * // Returns: { area: 'Documentation', dominantTech: ['markdown', 'documentation'], ... }
- */
-export function getGenericDocumentContext(docPath) {
-  const fileName = path.basename(docPath).toLowerCase();
-
-  const baseContext = {
-    area: 'General',
-    dominantTech: [],
-    isGeneralPurposeReadmeStyle: true,
-    fastPath: true, // Mark as optimized fast-path
-    docPath: docPath,
-  };
-
-  // Customize context based on document type
-  if (fileName.includes('readme')) {
-    return {
-      ...baseContext,
-      area: 'Documentation',
-      dominantTech: ['markdown', 'documentation'],
-    };
-  } else if (fileName.includes('runbook')) {
-    return {
-      ...baseContext,
-      area: 'Operations',
-      dominantTech: ['operations', 'deployment', 'devops'],
-    };
-  } else if (fileName.includes('changelog')) {
-    return {
-      ...baseContext,
-      area: 'Documentation',
-      dominantTech: ['versioning', 'releases'],
-    };
-  } else if (fileName.includes('contributing')) {
-    return {
-      ...baseContext,
-      area: 'Development',
-      dominantTech: ['git', 'development', 'contribution'],
-    };
-  } else if (fileName.includes('license')) {
-    return {
-      ...baseContext,
-      area: 'Legal',
-      dominantTech: ['licensing'],
-    };
-  } else if (fileName.includes('setup') || fileName.includes('install')) {
-    return {
-      ...baseContext,
-      area: 'Setup',
-      dominantTech: ['installation', 'setup', 'configuration'],
-    };
-  }
-
-  return baseContext;
-}

package/src/utils/file-validation.js

@@ -1,271 +0,0 @@
-/**
- * File Validation Module
- *
- * This module provides utilities for validating, filtering, and determining
- * if files should be processed based on various criteria such as file type,
- * size, patterns, and gitignore rules.
- */
-
-import fs from 'fs';
-import path from 'path';
-import { minimatch } from 'minimatch';
-import { execGitSafe } from './command.js';
-import {
-  CODE_EXTENSIONS,
-  DOCUMENTATION_EXTENSIONS,
-  BINARY_EXTENSIONS,
-  SKIP_DIRECTORIES,
-  SKIP_FILENAMES,
-  SKIP_FILE_PATTERNS,
-} from './constants.js';
-
-/**
- * Checks if a file path looks like a test file based on common patterns.
- * Tries to be relatively language/framework agnostic.
- *
- * @param {string} filePath - Path to the file.
- * @returns {boolean} True if the path matches test patterns, false otherwise.
- *
- * @example
- * isTestFile('src/components/__tests__/Button.test.js'); // true
- * isTestFile('test/unit/validator.spec.js'); // true
- * isTestFile('src/utils.js'); // false
- */
-export function isTestFile(filePath) {
-  if (!filePath) return false;
-  const lowerPath = filePath.toLowerCase();
-  // Common patterns: /__tests__/, /tests/, /specs/, _test., _spec., .test., .spec.
-  // Ensure delimiters are present or it's in a specific test directory.
-  // Checks for directory names or common patterns immediately preceding the file extension.
-  const testPattern = /(\/__tests__\/|\/tests?\/|\/specs?\/|_test\.|_spec\.|\.test\.|\.spec\.)/i;
-  return testPattern.test(lowerPath);
-}
-
-/**
- * Checks if a file is a documentation file based on extension, path patterns, and filename
- *
- * @param {string} filePath - Path to the file
- * @returns {boolean} True if the file is documentation, false otherwise
- *
- * @example
- * isDocumentationFile('README.md'); // true
- * isDocumentationFile('docs/api.md'); // true
- * isDocumentationFile('src/utils.js'); // false
- */
-export function isDocumentationFile(filePath) {
-  const lowerPath = filePath.toLowerCase();
-  const filename = lowerPath.split('/').pop();
-  const extension = path.extname(lowerPath);
-
-  // 1. Explicitly identify common code file extensions as NOT documentation
-  if (CODE_EXTENSIONS.includes(extension)) {
-    return false;
-  }
-
-  // 2. Check for specific documentation extensions
-  if (DOCUMENTATION_EXTENSIONS.includes(extension)) {
-    return true;
-  }
-
-  // 3. Check for universally accepted file names (case-insensitive)
-  const docFilenames = ['readme', 'license', 'contributing', 'changelog', 'copying'];
-  const filenameWithoutExt = filename.substring(0, filename.length - (extension.length || 0));
-  if (docFilenames.includes(filenameWithoutExt)) {
-    return true;
-  }
-
-  // 4. Check for common documentation directories (less reliable but useful)
-  const docDirs = ['/docs/', '/documentation/', '/doc/', '/wiki/', '/examples/', '/guides/'];
-  if (docDirs.some((dir) => lowerPath.includes(dir))) {
-    return true;
-  }
-
-  // 5. Check for other common documentation terms in filename (lowest priority)
-  const docTerms = ['guide', 'tutorial', 'manual', 'howto'];
-  if (docTerms.some((term) => filename.includes(term))) {
-    return true;
-  }
-
-  // 6. Special case for plain text files that look like docs
-  if (extension === '.txt') {
-    if (docFilenames.includes(filenameWithoutExt) || docTerms.some((term) => filename.includes(term))) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Check if a file should be processed based on its path and content
- *
- * @param {string} filePath - Path to the file
- * @param {string} content - Content of the file (optional, unused but kept for API compatibility)
- * @param {Object} options - Additional options
- * @param {Array<string>} options.excludePatterns - Patterns to exclude
- * @param {boolean} options.respectGitignore - Whether to respect .gitignore files
- * @param {string} options.baseDir - Base directory for relative paths
- * @param {Map<string, boolean>} options.gitignoreCache - Optional cache for gitignore results
- * @param {fs.Stats} options.fileStats - Optional pre-computed file stats to avoid re-reading
- * @returns {boolean} Whether the file should be processed
- *
- * @example
- * const shouldProcess = shouldProcessFile('src/utils.js', '', {
- *   excludePatterns: ['*.test.js'],
- *   respectGitignore: true
- * });
- */
-export function shouldProcessFile(filePath, _, options = {}) {
-  const { excludePatterns = [], respectGitignore = true, baseDir = process.cwd(), gitignoreCache = null, fileStats = null } = options;
-
-  // Skip files that are too large (>1MB) - use provided stats if available
-  if (fileStats) {
-    if (fileStats.size > 1024 * 1024) {
-      return false;
-    }
-  } else {
-    try {
-      const stats = fs.statSync(filePath);
-      if (stats.size > 1024 * 1024) {
-        return false;
-      }
-    } catch {
-      // If we can't get file stats, assume it's processable
-    }
-  }
-
-  // Skip binary files
-  const extension = path.extname(filePath).toLowerCase();
-  if (BINARY_EXTENSIONS.includes(extension)) {
-    return false;
-  }
-
-  // Skip node_modules, dist, build directories
-  if (SKIP_DIRECTORIES.some((dir) => filePath.includes(`/${dir}/`))) {
-    return false;
-  }
-
-  // Skip specific filenames like lock files
-  if (SKIP_FILENAMES.includes(path.basename(filePath))) {
-    return false;
-  }
-
-  // Skip files that are likely to be generated
-  if (SKIP_FILE_PATTERNS.some((pattern) => pattern.test(filePath))) {
-    return false;
-  }
-
-  // Check custom exclude patterns
-  if (excludePatterns.length > 0) {
-    const relativePath = path.relative(baseDir, filePath);
-    if (excludePatterns.some((pattern) => minimatch(relativePath, pattern, { dot: true }))) {
-      return false;
-    }
-  }
-
-  // Check gitignore patterns if enabled
-  if (respectGitignore) {
-    const relativePath = path.relative(baseDir, filePath);
-
-    // Use cache if provided
-    if (gitignoreCache && gitignoreCache.has(relativePath)) {
-      return !gitignoreCache.get(relativePath); // Cache stores isIgnored, we return shouldProcess
-    }
-
-    // Fallback to individual check (slow path)
-    try {
-      // Use git check-ignore to determine if a file is ignored
-      // This is the most accurate way to check as it uses Git's own ignore logic
-      // Use baseDir as cwd to ensure git runs in the correct context
-      execGitSafe('git check-ignore', ['-q', relativePath], {
-        stdio: 'ignore',
-        cwd: baseDir,
-      });
-
-      // If we get here, the file is ignored by git
-      if (gitignoreCache) gitignoreCache.set(relativePath, true);
-      return false;
-    } catch {
-      // If git check-ignore exits with non-zero status, the file is not ignored
-      // This is expected behavior, so we continue processing
-      if (gitignoreCache) gitignoreCache.set(relativePath, false);
-    }
-  }
-
-  return true;
-}
-
-/**
- * Batch check multiple files against gitignore in a single git command
- * This is much faster than calling git check-ignore for each file individually
- *
- * @param {string[]} filePaths - Array of file paths to check
- * @param {string} baseDir - Base directory for git operations
- * @returns {Promise<Map<string, boolean>>} Map of relative paths to isIgnored boolean
- */
-export async function batchCheckGitignore(filePaths, baseDir = process.cwd()) {
-  const resultMap = new Map();
-
-  if (filePaths.length === 0) {
-    return resultMap;
-  }
-
-  // Convert to relative paths
-  const relativePaths = filePaths.map((fp) => path.relative(baseDir, fp));
-
-  try {
-    // Use --stdin flag for batch checking
-    // git check-ignore exits with:
-    //   0 = at least one path is ignored (outputs ignored paths)
-    //   1 = no paths are ignored (outputs nothing) - this is NOT an error
-    //   128 = fatal error
-    // execSync throws on non-zero exit, so we need to catch exit code 1
-    const stdout = execGitSafe('git check-ignore', ['--stdin'], {
-      stdio: ['pipe', 'pipe', 'ignore'],
-      cwd: baseDir,
-      input: relativePaths.join('\n'),
-      encoding: 'utf8',
-    });
-
-    // If we get here, exit code was 0 - some files are ignored
-    const stdoutStr = typeof stdout === 'string' ? stdout : stdout?.toString('utf8') || '';
-    const ignoredFiles = stdoutStr
-      .trim()
-      .split('\n')
-      .filter((line) => line.length > 0);
-    const ignoredSet = new Set(ignoredFiles);
-
-    // Build result map
-    for (const relPath of relativePaths) {
-      resultMap.set(relPath, ignoredSet.has(relPath));
-    }
-
-    // Log ignored files
-    if (ignoredFiles.length > 0) {
-      console.log(`  ℹ️  Found ${ignoredFiles.length} gitignored files to exclude`);
-      const ignoredSample = ignoredFiles.slice(0, 5);
-      ignoredSample.forEach((f) => console.log(`      - ${f}`));
-      if (ignoredFiles.length > 5) {
-        console.log(`      ... and ${ignoredFiles.length - 5} more`);
-      }
-    }
-  } catch (error) {
-    // Check if this is just "no files ignored" (exit code 1) vs actual error
-    // Exit code 1 from git check-ignore means no paths matched - this is normal
-    if (error.status === 1) {
-      // No files in this batch are ignored - mark all as not ignored
-      for (const relPath of relativePaths) {
-        resultMap.set(relPath, false);
-      }
-    } else {
-      // Actual error (exit code 128 or other) - log and fall back
-      console.warn(`⚠️ Batch gitignore check failed: ${error.message}`);
-      console.warn('  Falling back to individual checks (may be slower)');
-      for (const relPath of relativePaths) {
-        resultMap.set(relPath, false);
-      }
-    }
-  }
-
-  return resultMap;
-}

package/src/utils/git.js

@@ -1,232 +0,0 @@
-/**
- * Git Operations Module
- *
- * This module provides utilities for git operations including branch management,
- * diff analysis, and content retrieval from different branches or commits.
- */
-
-import { execSync } from 'child_process';
-import path from 'path';
-import chalk from 'chalk';
-import { execGitSafe } from './command.js';
-
-/**
- * Check if a git branch exists locally
- *
- * @param {string} branchName - The name of the branch to check
- * @param {string} workingDir - Directory to run git commands in (optional, defaults to cwd)
- * @returns {boolean} True if the branch exists, false otherwise
- *
- * @example
- * const exists = checkBranchExists('feature-branch');
- * if (exists) {
- *   console.log('Branch exists locally');
- * }
- */
-function checkBranchExists(branchName, workingDir = process.cwd()) {
-  try {
-    execGitSafe('git show-ref', ['--verify', '--quiet', `refs/heads/${branchName}`], { cwd: workingDir });
-    return true;
-  } catch {
-    // Command returns non-zero exit code if branch doesn't exist
-    return false;
-  }
-}
-
-/**
- * Ensure a branch exists locally, fetching from remote if necessary
- *
- * @param {string} branchName - The name of the branch to ensure exists
- * @param {string} workingDir - Directory to run git commands in (optional, defaults to cwd)
- *
- * @example
- * await ensureBranchExists('main');
- * // Branch is now available locally for operations
- */
-export function ensureBranchExists(branchName, workingDir = process.cwd()) {
-  try {
-    // Check if branch exists locally
-    if (checkBranchExists(branchName, workingDir)) {
-      console.log(chalk.gray(`Branch '${branchName}' exists locally`));
-      return;
-    }
-
-    console.log(chalk.yellow(`Branch '${branchName}' not found locally, attempting to fetch...`));
-
-    // Try to fetch the branch from origin
-    try {
-      execGitSafe('git fetch', ['origin', `${branchName}:${branchName}`], { stdio: 'pipe', cwd: workingDir });
-      console.log(chalk.green(`Successfully fetched branch '${branchName}' from origin`));
-    } catch {
-      // If direct fetch fails, try fetching all branches and then checking
-      console.log(chalk.yellow(`Direct fetch failed, trying to fetch all branches...`));
-      execSync('git fetch origin', { stdio: 'pipe', cwd: workingDir });
-
-      // Check if branch exists on remote
-      try {
-        execGitSafe('git show-ref', ['--verify', '--quiet', `refs/remotes/origin/${branchName}`], { cwd: workingDir });
-        // Create local tracking branch
-        execGitSafe('git checkout', ['-b', branchName, `origin/${branchName}`], { stdio: 'pipe', cwd: workingDir });
-        console.log(chalk.green(`Successfully created local branch '${branchName}' tracking origin/${branchName}`));
-      } catch {
-        throw new Error(`Branch '${branchName}' not found locally or on remote origin`);
-      }
-    }
-  } catch (error) {
-    console.error(chalk.red(`Error ensuring branch '${branchName}' exists:`), error.message);
-    throw error;
-  }
-}
-
-/**
- * Find the base branch (main or master) that exists in the repository
- *
- * @param {string} workingDir - Directory to run git commands in (optional, defaults to cwd)
- * @returns {string} The name of the base branch (main, master, or develop)
- *
- * @example
- * const baseBranch = findBaseBranch();
- * console.log(`Using base branch: ${baseBranch}`);
- */
-export function findBaseBranch(workingDir = process.cwd()) {
-  const candidateBranches = ['main', 'master', 'develop'];
-
-  for (const branch of candidateBranches) {
-    if (checkBranchExists(branch, workingDir)) {
-      return branch;
-    }
-
-    // Also check if it exists on remote
-    try {
-      execGitSafe('git show-ref', ['--verify', '--quiet', `refs/remotes/origin/${branch}`], { cwd: workingDir });
-      return branch;
-    } catch {
-      // Branch doesn't exist on remote either, continue to next candidate
-    }
-  }
-
-  // Fallback to HEAD~1 if no standard base branch found
-  console.warn(chalk.yellow('No standard base branch (main/master/develop) found, using HEAD~1 as fallback'));
-  return 'HEAD~1';
-}
-
-/**
- * Get git diff content for a specific file between two branches/commits
- *
- * @param {string} filePath - Path to the file
- * @param {string} baseBranch - Base branch (e.g., 'main', 'master')
- * @param {string} targetBranch - Target branch (e.g., 'feature-branch')
- * @param {string} workingDir - Working directory for git commands
- * @returns {string} Git diff content for the file
- *
- * @example
- * const diff = getFileDiff('src/utils.js', 'main', 'feature-branch');
- * console.log('Changes:', diff);
- */
-function getFileDiff(filePath, baseBranch, targetBranch, workingDir = process.cwd()) {
-  try {
-    // Use git diff to get changes for the specific file
-    // Format: git diff base...target -- filepath
-    const gitCommand = `git diff ${baseBranch}...${targetBranch} -- "${filePath}"`;
-    const diffOutput = execSync(gitCommand, { cwd: workingDir, encoding: 'utf8' });
-
-    return diffOutput;
-  } catch (error) {
-    console.error(chalk.red(`Error getting git diff for ${filePath}: ${error.message}`));
-    return '';
-  }
-}
-
-/**
- * Get changed lines info for a file between two branches
- *
- * @param {string} filePath - Path to the file
- * @param {string} baseBranch - Base branch
- * @param {string} targetBranch - Target branch
- * @param {string} workingDir - Working directory for git commands
- * @returns {Object} Object with added/removed lines info
- *
- * @example
- * const changes = getChangedLinesInfo('src/utils.js', 'main', 'feature-branch');
- * console.log(`Added ${changes.addedLines.length} lines, removed ${changes.removedLines.length} lines`);
- */
-export function getChangedLinesInfo(filePath, baseBranch, targetBranch, workingDir = process.cwd()) {
-  try {
-    const diffOutput = getFileDiff(filePath, baseBranch, targetBranch, workingDir);
-
-    if (!diffOutput) {
-      return { hasChanges: false, addedLines: [], removedLines: [], contextLines: [] };
-    }
-
-    const lines = diffOutput.split('\n');
-    const addedLines = [];
-    const removedLines = [];
-    const contextLines = [];
-
-    let currentLineNumber = 0;
-
-    for (const line of lines) {
-      if (line.startsWith('@@')) {
-        // Parse line numbers from diff header like "@@ -10,7 +10,8 @@"
-        const match = line.match(/@@ -(\d+),?\d* \+(\d+),?\d* @@/);
-        if (match) {
-          currentLineNumber = parseInt(match[2]);
-        }
-      } else if (line.startsWith('+') && !line.startsWith('+++')) {
-        addedLines.push({ lineNumber: currentLineNumber, content: line.substring(1) });
-        currentLineNumber++;
-      } else if (line.startsWith('-') && !line.startsWith('---')) {
-        removedLines.push({ content: line.substring(1) });
-      } else if (line.startsWith(' ')) {
-        contextLines.push({ lineNumber: currentLineNumber, content: line.substring(1) });
-        currentLineNumber++;
-      }
-    }
-
-    return {
-      hasChanges: addedLines.length > 0 || removedLines.length > 0,
-      addedLines,
-      removedLines,
-      contextLines,
-      fullDiff: diffOutput,
-    };
-  } catch (error) {
-    console.error(chalk.red(`Error parsing diff for ${filePath}: ${error.message}`));
-    return { hasChanges: false, addedLines: [], removedLines: [], contextLines: [] };
-  }
-}
-
-/**
- * Get the content of a file from a specific git branch/commit without checking it out
- *
- * @param {string} filePath - Absolute path to the file in the repository
- * @param {string} branchOrCommit - The branch or commit hash to get the file from
- * @param {string} workingDir - The git repository directory
- * @returns {string} The content of the file
- *
- * @example
- * const content = getFileContentFromGit('/path/to/file.js', 'main', '/repo');
- * console.log('File content from main branch:', content);
- */
-export function getFileContentFromGit(filePath, branchOrCommit, workingDir) {
-  try {
-    const gitRoot = execSync('git rev-parse --show-toplevel', { cwd: workingDir }).toString().trim();
-    const relativePath = path.relative(gitRoot, filePath);
-    // Use forward slashes for git path
-    const gitPath = relativePath.split(path.sep).join('/');
-
-    // Command: git show <branch>:<path>
-    // Use safe execution to prevent command injection
-    return execGitSafe('git show', [`${branchOrCommit}:${gitPath}`], { cwd: workingDir, encoding: 'utf8' });
-  } catch (error) {
-    // Handle cases where the file might not exist in that commit (e.g., a new file in a feature branch)
-    if (error.stderr && error.stderr.includes('exists on disk, but not in')) {
-      // This case can be ignored if we are sure the file is new.
-      // For a robust solution, you might need to check file status (new, modified, deleted).
-      // For now, we return an empty string, assuming it's a new file not yet in the base.
-      return '';
-    }
-    // Re-throw other errors
-    throw new Error(`Failed to get content of ${filePath} from ${branchOrCommit}: ${error.message}`);
-  }
-}