claude-git-hooks 2.12.0 → 2.14.1

package/lib/utils/resolution-prompt.js

@@ -35,60 +35,65 @@ class ResolutionPromptError extends Error {
 }
 
 /**
- * Formats blocking issues for resolution prompt
+ * Formats issues for resolution prompt
  * Why: Structures issues in readable markdown format for AI processing
  *
- * @param {Array<Object>} blockingIssues - Array of blocking issues
+ * @param {Array<Object>} issues - Array of issues (blocking or detailed)
  * @returns {string} Formatted markdown
  *
- * Issue object structure:
- * {
- *   description: string,    // Human-readable description
- *   file: string,          // Relative file path
- *   line: number,          // Line number
- *   method: string,        // Method or class name
- *   severity: string       // 'blocker' | 'critical'
- * }
+ * Supports both blocking issue format and detailed issue format:
+ * Blocking: { description, file, line, method, severity }
+ * Detailed: { message, file, line, method, severity, type, rule }
  */
-const formatBlockingIssues = (blockingIssues) => {
+const formatBlockingIssues = (issues) => {
     logger.debug(
         'resolution-prompt - formatBlockingIssues',
-        'Formatting blocking issues',
-        { issueCount: blockingIssues.length }
+        'Formatting issues',
+        { issueCount: issues?.length || 0 }
     );
 
-    if (!Array.isArray(blockingIssues) || blockingIssues.length === 0) {
-        return 'No blocking issues found.';
+    if (!Array.isArray(issues) || issues.length === 0) {
+        return 'No issues found.';
     }
 
-    return blockingIssues
+    return issues
         .map((issue, index) => {
             const issueNum = index + 1;
             const severity = (issue.severity || 'unknown').toUpperCase();
+            // Support both 'description' (blocking) and 'message' (detailed) formats
+            const description = issue.description || issue.message || 'No description';
+            const type = issue.type ? ` - ${issue.type}` : '';
 
-            return `### Issue #${issueNum} [${severity}]
-**Description:** ${issue.description || 'No description'}
-**Location:** ${issue.file || 'unknown'}:${issue.line || '?'}
-**Method/Class:** ${issue.method || 'unknown'}
-`;
+            let formatted = `### Issue #${issueNum} [${severity}]${type}
+**Description:** ${description}
+**Location:** ${issue.file || 'unknown'}:${issue.line || '?'}`;
+
+            if (issue.method) {
+                formatted += `\n**Method/Class:** ${issue.method}`;
+            }
+            if (issue.rule) {
+                formatted += `\n**Rule:** ${issue.rule}`;
+            }
+
+            return `${formatted}\n`;
         })
         .join('\n');
 };
 
 /**
- * Gets unique file paths from blocking issues
+ * Gets unique file paths from issues
  * Why: Need to include full content of affected files
  *
- * @param {Array<Object>} blockingIssues - Array of blocking issues
+ * @param {Array<Object>} issues - Array of issues (blocking or detailed)
  * @returns {Array<string>} Unique file paths
  */
-const getAffectedFiles = (blockingIssues) => {
-    if (!Array.isArray(blockingIssues)) {
+const getAffectedFiles = (issues) => {
+    if (!Array.isArray(issues)) {
         return [];
     }
 
     // Extract unique file paths
-    const filePaths = blockingIssues
+    const filePaths = issues
         .map(issue => issue.file)
         .filter(file => file && typeof file === 'string');
 
@@ -97,7 +102,7 @@ const getAffectedFiles = (blockingIssues) => {
     logger.debug(
         'resolution-prompt - getAffectedFiles',
         'Extracted affected files',
-        { totalIssues: blockingIssues.length, uniqueFiles: uniqueFiles.length }
+        { totalIssues: issues.length, uniqueFiles: uniqueFiles.length }
     );
 
     return uniqueFiles;
@@ -195,6 +200,12 @@ const generateResolutionPrompt = async (
     const absoluteOutputPath = path.join(repoRoot, finalOutputPath);
     const absoluteTemplatePath = path.join(repoRoot, templatePath);
 
+    // Use details array (all issues) if available, fallback to blockingIssues
+    // Why: analyze command provides full details, pre-commit may only have blockingIssues
+    const allIssues = (Array.isArray(analysisResult.details) && analysisResult.details.length > 0)
+        ? analysisResult.details
+        : (analysisResult.blockingIssues || []);
+
     logger.debug(
         'resolution-prompt - generateResolutionPrompt',
         'Generating resolution prompt',
@@ -202,7 +213,8 @@ const generateResolutionPrompt = async (
             repoRoot,
             outputPath: absoluteOutputPath,
             templatePath: absoluteTemplatePath,
-            blockingIssuesCount: analysisResult.blockingIssues?.length || 0
+            issueCount: allIssues.length,
+            usingDetails: Array.isArray(analysisResult.details) && analysisResult.details.length > 0
         }
     );
 
@@ -215,11 +227,11 @@ const generateResolutionPrompt = async (
         const branchName = getCurrentBranch();
         const commitSha = 'pending';
 
-        // Format blocking issues
-        const issuesFormatted = formatBlockingIssues(analysisResult.blockingIssues || []);
+        // Format all issues
+        const issuesFormatted = formatBlockingIssues(allIssues);
 
         // Get and format affected files
-        const affectedFiles = getAffectedFiles(analysisResult.blockingIssues || []);
+        const affectedFiles = getAffectedFiles(allIssues);
         const fileContentsFormatted = await formatFileContents(affectedFiles);
 
         // Replace placeholders
@@ -232,6 +244,13 @@ const generateResolutionPrompt = async (
             .replace(/{{BLOCKING_ISSUES}}/g, issuesFormatted)
             .replace(/{{FILE_CONTENTS}}/g, fileContentsFormatted);
 
+        // Prepend false positive check instructions
+        const falsePositiveCheck = `FIRST STEP: Analyze each issue below. Classify into FALSE POSITIVE or TRUE ISSUE. Fix TRUE ISSUES only.
+
+`;
+
+        prompt = falsePositiveCheck + prompt;
+
         // Ensure output directory exists
         const outputDir = path.dirname(absoluteOutputPath);
         await fs.mkdir(outputDir, { recursive: true });
@@ -270,7 +289,7 @@ const generateResolutionPrompt = async (
 
 /**
  * Checks if resolution prompt should be generated
- * Why: Only generate when there are actual blocking issues
+ * Why: Generate when there are any issues (blocking or non-blocking)
  *
  * @param {Object} analysisResult - Analysis result
  * @returns {boolean} True if should generate prompt
@@ -278,17 +297,21 @@ const generateResolutionPrompt = async (
 const shouldGeneratePrompt = (analysisResult) => {
     const hasBlockingIssues = Array.isArray(analysisResult.blockingIssues) &&
                               analysisResult.blockingIssues.length > 0;
+    const hasDetailedIssues = Array.isArray(analysisResult.details) &&
+                              analysisResult.details.length > 0;
 
     logger.debug(
         'resolution-prompt - shouldGeneratePrompt',
         'Checking if resolution prompt needed',
         {
             hasBlockingIssues,
-            blockingIssuesCount: analysisResult.blockingIssues?.length || 0
+            hasDetailedIssues,
+            blockingIssuesCount: analysisResult.blockingIssues?.length || 0,
+            detailedIssuesCount: analysisResult.details?.length || 0
         }
     );
 
-    return hasBlockingIssues;
+    return hasBlockingIssues || hasDetailedIssues;
 };
 
 export {

package/lib/utils/version-manager.js

@@ -5,7 +5,7 @@
  * Handles version operations for:
  * - package.json (Node.js projects)
  * - pom.xml (Maven projects)
- * - Mixed monorepos (both files)
+ * - Mixed monorepos (both files, including in subdirectories)
  *
  * Supports semantic versioning with optional suffixes (SNAPSHOT, RC, etc.)
  */
@@ -25,6 +25,100 @@ const PROJECT_TYPES = {
     NONE: 'none'
 };
 
+/**
+ * Cache for discovered version file paths
+ * Why: Avoid re-discovering paths on every operation
+ */
+let discoveredPaths = {
+    packageJson: null,
+    pomXml: null
+};
+
+/**
+ * Discovers version files in repo root and one level deep
+ * Why: Support monorepos with version files in subdirectories
+ *
+ * @returns {Object} Discovered paths: { packageJson, pomXml }
+ */
+export function discoverVersionFiles() {
+    logger.debug('version-manager - discoverVersionFiles', 'Searching for version files');
+
+    const repoRoot = getRepoRoot();
+    const result = { packageJson: null, pomXml: null };
+
+    // First check root level
+    const rootPackageJson = path.join(repoRoot, 'package.json');
+    const rootPomXml = path.join(repoRoot, 'pom.xml');
+
+    if (fs.existsSync(rootPackageJson)) {
+        result.packageJson = rootPackageJson;
+    }
+    if (fs.existsSync(rootPomXml)) {
+        result.pomXml = rootPomXml;
+    }
+
+    // If both found at root, we're done
+    if (result.packageJson && result.pomXml) {
+        logger.debug('version-manager - discoverVersionFiles', 'Found both at root', result);
+        return result;
+    }
+
+    // Search one level deep in subdirectories
+    try {
+        const entries = fs.readdirSync(repoRoot, { withFileTypes: true });
+        const subdirs = entries.filter(e =>
+            e.isDirectory() &&
+            !e.name.startsWith('.') &&
+            !e.name.startsWith('node_modules') &&
+            !e.name.startsWith('target') &&
+            !e.name.startsWith('build') &&
+            !e.name.startsWith('dist')
+        );
+
+        for (const subdir of subdirs) {
+            const subdirPath = path.join(repoRoot, subdir.name);
+
+            // Check for package.json if not found yet
+            if (!result.packageJson) {
+                const packageJsonPath = path.join(subdirPath, 'package.json');
+                if (fs.existsSync(packageJsonPath)) {
+                    result.packageJson = packageJsonPath;
+                    logger.debug('version-manager - discoverVersionFiles', 'Found package.json in subdir', {
+                        subdir: subdir.name
+                    });
+                }
+            }
+
+            // Check for pom.xml if not found yet
+            if (!result.pomXml) {
+                const pomXmlPath = path.join(subdirPath, 'pom.xml');
+                if (fs.existsSync(pomXmlPath)) {
+                    result.pomXml = pomXmlPath;
+                    logger.debug('version-manager - discoverVersionFiles', 'Found pom.xml in subdir', {
+                        subdir: subdir.name
+                    });
+                }
+            }
+
+            // Stop searching if both found
+            if (result.packageJson && result.pomXml) {
+                break;
+            }
+        }
+    } catch (error) {
+        logger.debug('version-manager - discoverVersionFiles', 'Error searching subdirs', {
+            error: error.message
+        });
+    }
+
+    logger.debug('version-manager - discoverVersionFiles', 'Discovery complete', {
+        packageJson: result.packageJson ? path.relative(repoRoot, result.packageJson) : null,
+        pomXml: result.pomXml ? path.relative(repoRoot, result.pomXml) : null
+    });
+
+    return result;
+}
+
 /**
  * Detects project type based on version files present
  * Why: Different projects require different version file handling
@@ -35,12 +129,11 @@ export function detectProjectType() {
     logger.debug('version-manager - detectProjectType', 'Detecting project type');
 
     try {
-        const repoRoot = getRepoRoot();
-        const packageJsonPath = path.join(repoRoot, 'package.json');
-        const pomXmlPath = path.join(repoRoot, 'pom.xml');
+        // Discover version files (checks root and subdirectories)
+        discoveredPaths = discoverVersionFiles();
 
-        const hasPackageJson = fs.existsSync(packageJsonPath);
-        const hasPomXml = fs.existsSync(pomXmlPath);
+        const hasPackageJson = discoveredPaths.packageJson !== null;
+        const hasPomXml = discoveredPaths.pomXml !== null;
 
         let projectType;
         if (hasPackageJson && hasPomXml) {
@@ -53,10 +146,11 @@ export function detectProjectType() {
             projectType = PROJECT_TYPES.NONE;
         }
 
+        const repoRoot = getRepoRoot();
         logger.debug('version-manager - detectProjectType', 'Project type detected', {
             projectType,
-            hasPackageJson,
-            hasPomXml
+            packageJson: discoveredPaths.packageJson ? path.relative(repoRoot, discoveredPaths.packageJson) : null,
+            pomXml: discoveredPaths.pomXml ? path.relative(repoRoot, discoveredPaths.pomXml) : null
         });
 
         return projectType;
@@ -77,10 +171,9 @@ function readPackageJsonVersion() {
     logger.debug('version-manager - readPackageJsonVersion', 'Reading version from package.json');
 
     try {
-        const repoRoot = getRepoRoot();
-        const packageJsonPath = path.join(repoRoot, 'package.json');
+        const packageJsonPath = discoveredPaths.packageJson;
 
-        if (!fs.existsSync(packageJsonPath)) {
+        if (!packageJsonPath || !fs.existsSync(packageJsonPath)) {
             logger.debug('version-manager - readPackageJsonVersion', 'package.json not found');
             return null;
         }
@@ -89,7 +182,10 @@ function readPackageJsonVersion() {
         const packageData = JSON.parse(content);
         const version = packageData.version || null;
 
-        logger.debug('version-manager - readPackageJsonVersion', 'Version read', { version });
+        logger.debug('version-manager - readPackageJsonVersion', 'Version read', {
+            version,
+            path: packageJsonPath
+        });
 
         return version;
 
@@ -103,34 +199,56 @@ function readPackageJsonVersion() {
  * Reads current version from pom.xml
  * Why: Maven projects store version in pom.xml <project><version>
  *
+ * Strategy: Find <version> at nesting level 1 (direct child of <project>)
+ * - If <parent> block exists, look for <version> after </parent>
+ * - If no <parent> block, look for first <version> after <project>
+ *
  * @returns {string|null} Version string or null if not found
  */
 function readPomXmlVersion() {
     logger.debug('version-manager - readPomXmlVersion', 'Reading version from pom.xml');
 
     try {
-        const repoRoot = getRepoRoot();
-        const pomXmlPath = path.join(repoRoot, 'pom.xml');
+        const pomXmlPath = discoveredPaths.pomXml;
 
-        if (!fs.existsSync(pomXmlPath)) {
+        if (!pomXmlPath || !fs.existsSync(pomXmlPath)) {
             logger.debug('version-manager - readPomXmlVersion', 'pom.xml not found');
             return null;
         }
 
         const content = fs.readFileSync(pomXmlPath, 'utf8');
 
-        // Extract version from <project><version>X.Y.Z</version>
-        // Why: Match only the project version, not parent or dependencies
-        const projectVersionRegex = /<project[^>]*>[\s\S]*?<version>([^<]+)<\/version>/;
-        const match = content.match(projectVersionRegex);
+        // Check if <parent> block exists
+        const hasParent = /<parent>[\s\S]*?<\/parent>/.test(content);
+        let version = null;
+
+        if (hasParent) {
+            // Find <version> after </parent> closing tag (project's direct version)
+            // Why: Parent's <version> is inside <parent>, project's <version> is after </parent>
+            const afterParentRegex = /<\/parent>[\s\S]*?<version>([^<]+)<\/version>/;
+            const match = content.match(afterParentRegex);
+            if (match) {
+                version = match[1].trim();
+            }
+        } else {
+            // No parent block - find first <version> after <project>
+            const projectVersionRegex = /<project[^>]*>[\s\S]*?<version>([^<]+)<\/version>/;
+            const match = content.match(projectVersionRegex);
+            if (match) {
+                version = match[1].trim();
+            }
+        }
 
-        if (!match) {
+        if (!version) {
             logger.debug('version-manager - readPomXmlVersion', 'Version tag not found in pom.xml');
             return null;
         }
 
-        const version = match[1].trim();
-        logger.debug('version-manager - readPomXmlVersion', 'Version read', { version });
+        logger.debug('version-manager - readPomXmlVersion', 'Version read', {
+            version,
+            path: pomXmlPath,
+            hasParent
+        });
 
         return version;
 
@@ -303,20 +421,20 @@ export function incrementVersion(currentVersion, bumpType, suffix = null) {
 
     // Increment based on type
     switch (bumpType.toLowerCase()) {
-        case 'major':
-            parsed.major += 1;
-            parsed.minor = 0;
-            parsed.patch = 0;
-            break;
-        case 'minor':
-            parsed.minor += 1;
-            parsed.patch = 0;
-            break;
-        case 'patch':
-            parsed.patch += 1;
-            break;
-        default:
-            throw new Error(`Invalid bump type: ${bumpType}. Use major, minor, or patch.`);
+    case 'major':
+        parsed.major += 1;
+        parsed.minor = 0;
+        parsed.patch = 0;
+        break;
+    case 'minor':
+        parsed.minor += 1;
+        parsed.patch = 0;
+        break;
+    case 'patch':
+        parsed.patch += 1;
+        break;
+    default:
+        throw new Error(`Invalid bump type: ${bumpType}. Use major, minor, or patch.`);
     }
 
     // Construct new version
@@ -343,8 +461,11 @@ function updatePackageJsonVersion(newVersion) {
     logger.debug('version-manager - updatePackageJsonVersion', 'Updating package.json', { newVersion });
 
     try {
-        const repoRoot = getRepoRoot();
-        const packageJsonPath = path.join(repoRoot, 'package.json');
+        const packageJsonPath = discoveredPaths.packageJson;
+
+        if (!packageJsonPath) {
+            throw new Error('package.json path not discovered');
+        }
 
         const content = fs.readFileSync(packageJsonPath, 'utf8');
         const packageData = JSON.parse(content);
@@ -352,10 +473,12 @@ function updatePackageJsonVersion(newVersion) {
         packageData.version = newVersion;
 
         // Write with 4-space indent to match existing format
-        const updatedContent = JSON.stringify(packageData, null, 4) + '\n';
+        const updatedContent = `${JSON.stringify(packageData, null, 4)}\n`;
         fs.writeFileSync(packageJsonPath, updatedContent, 'utf8');
 
-        logger.debug('version-manager - updatePackageJsonVersion', 'package.json updated successfully');
+        logger.debug('version-manager - updatePackageJsonVersion', 'package.json updated', {
+            path: packageJsonPath
+        });
 
     } catch (error) {
         logger.error('version-manager - updatePackageJsonVersion', 'Failed to update package.json', error);
@@ -367,21 +490,38 @@ function updatePackageJsonVersion(newVersion) {
  * Updates version in pom.xml
  * Why: Writes new version to Maven project file
  *
+ * Strategy: Update <version> at nesting level 1 (direct child of <project>)
+ * - If <parent> block exists, update <version> after </parent>
+ * - If no <parent> block, update first <version> after <project>
+ *
  * @param {string} newVersion - New version string
  */
 function updatePomXmlVersion(newVersion) {
     logger.debug('version-manager - updatePomXmlVersion', 'Updating pom.xml', { newVersion });
 
     try {
-        const repoRoot = getRepoRoot();
-        const pomXmlPath = path.join(repoRoot, 'pom.xml');
+        const pomXmlPath = discoveredPaths.pomXml;
 
-        let content = fs.readFileSync(pomXmlPath, 'utf8');
+        if (!pomXmlPath) {
+            throw new Error('pom.xml path not discovered');
+        }
 
-        // Replace version in <project><version>X.Y.Z</version>
-        // Why: Only update project version, not parent or dependencies
-        const projectVersionRegex = /(<project[^>]*>[\s\S]*?<version>)[^<]+(<\/version>)/;
-        const newContent = content.replace(projectVersionRegex, `$1${newVersion}$2`);
+        const content = fs.readFileSync(pomXmlPath, 'utf8');
+
+        // Check if <parent> block exists
+        const hasParent = /<parent>[\s\S]*?<\/parent>/.test(content);
+        let newContent;
+
+        if (hasParent) {
+            // Replace <version> after </parent> closing tag (project's direct version)
+            // Why: Parent's <version> is inside <parent>, project's <version> is after </parent>
+            const afterParentRegex = /(<\/parent>[\s\S]*?<version>)[^<]+(<\/version>)/;
+            newContent = content.replace(afterParentRegex, `$1${newVersion}$2`);
+        } else {
+            // No parent block - replace first <version> after <project>
+            const projectVersionRegex = /(<project[^>]*>[\s\S]*?<version>)[^<]+(<\/version>)/;
+            newContent = content.replace(projectVersionRegex, `$1${newVersion}$2`);
+        }
 
         if (content === newContent) {
             logger.warning('version-manager - updatePomXmlVersion', 'No version tag found to update');
@@ -390,7 +530,10 @@ function updatePomXmlVersion(newVersion) {
 
         fs.writeFileSync(pomXmlPath, newContent, 'utf8');
 
-        logger.debug('version-manager - updatePomXmlVersion', 'pom.xml updated successfully');
+        logger.debug('version-manager - updatePomXmlVersion', 'pom.xml updated', {
+            path: pomXmlPath,
+            hasParent
+        });
 
     } catch (error) {
         logger.error('version-manager - updatePomXmlVersion', 'Failed to update pom.xml', error);
@@ -460,11 +603,20 @@ export function validateVersionFormat(version) {
  *
  * @param {string} version1 - First version
  * @param {string} version2 - Second version
- * @returns {number} 1 if v1 > v2, -1 if v1 < v2, 0 if equal
+ * @returns {number} 1 if v1 > v2, -1 if v1 < v2, 0 if equal or invalid
  */
 export function compareVersions(version1, version2) {
     logger.debug('version-manager - compareVersions', 'Comparing versions', { version1, version2 });
 
+    // Handle null/undefined versions gracefully
+    if (!version1 || !version2) {
+        logger.debug('version-manager - compareVersions', 'Missing version, returning 0', {
+            version1,
+            version2
+        });
+        return 0;
+    }
+
     try {
         const v1 = parseVersion(version1);
         const v2 = parseVersion(version2);
@@ -489,7 +641,12 @@ export function compareVersions(version1, version2) {
         return 0;
 
     } catch (error) {
-        logger.error('version-manager - compareVersions', 'Failed to compare versions', error);
+        // Log at debug level instead of error - non-semver versions are expected
+        logger.debug('version-manager - compareVersions', 'Cannot compare versions (not semver)', {
+            version1,
+            version2,
+            error: error.message
+        });
         return 0;
     }
 }
@@ -507,7 +664,7 @@ export async function validateVersionAlignment() {
         const projectType = detectProjectType();
         const versions = getCurrentVersion(projectType);
 
-        // Get git tag version
+        // Get git tag version (parseTagVersion returns null for non-semver tags)
         const { getLatestLocalTag, parseTagVersion } = await import('./git-tag-manager.js');
         const latestTag = getLatestLocalTag();
         const tagVersion = latestTag ? parseTagVersion(latestTag) : null;
@@ -515,7 +672,7 @@ export async function validateVersionAlignment() {
         // Get CHANGELOG version
         const changelogVersion = readChangelogVersion();
 
-        // Get remote tag version
+        // Get remote tag version (parseTagVersion returns null for non-semver tags)
         const { getLatestRemoteTag } = await import('./git-tag-manager.js');
         const latestRemoteTag = await getLatestRemoteTag();
         const remoteVersion = latestRemoteTag ? parseTagVersion(latestRemoteTag) : null;
@@ -581,3 +738,13 @@ export async function validateVersionAlignment() {
         };
     }
 }
+
+/**
+ * Gets discovered version file paths
+ * Why: Allows callers to display which files will be updated
+ *
+ * @returns {Object} Discovered paths: { packageJson, pomXml }
+ */
+export function getDiscoveredPaths() {
+    return { ...discoveredPaths };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-git-hooks",
-    "version": "2.12.0",
+    "version": "2.14.1",
     "description": "Git hooks with Claude CLI for code analysis and automatic commit messages",
     "type": "module",
     "bin": {