claude-git-hooks 2.14.4 → 2.16.0

package/lib/utils/version-manager.js

@@ -16,245 +16,627 @@ import { getRepoRoot } from './git-operations.js';
 import logger from './logger.js';
 
 /**
- * Project types supported by version manager
+ * Cache for discovery result
+ * Why: Store full discovery result for access by getDiscoveryResult()
  */
-const PROJECT_TYPES = {
-    NODE: 'node',
-    MAVEN: 'maven',
-    BOTH: 'both',
-    NONE: 'none'
-};
+let cachedDiscoveryResult = null;
 
 /**
- * Cache for discovered version file paths
- * Why: Avoid re-discovering paths on every operation
+ * Registry of supported version file types
+ * Why: Extensible system for multi-language version management
+ *
+ * Each entry defines:
+ * - filename: The file to search for
+ * - readVersion: Function to extract version from file
+ * - writeVersion: Function to update version in file
+ * - projectLabel: Human-readable project type label
  */
-let discoveredPaths = {
-    packageJson: null,
-    pomXml: null
+const VERSION_FILE_TYPES = {
+    'package.json': {
+        filename: 'package.json',
+        readVersion: (filePath) => {
+            try {
+                const content = fs.readFileSync(filePath, 'utf8');
+                const packageData = JSON.parse(content);
+                return packageData.version || null;
+            } catch (error) {
+                logger.debug('version-manager - VERSION_FILE_TYPES', 'Failed to read package.json', {
+                    filePath,
+                    error: error.message
+                });
+                return null;
+            }
+        },
+        writeVersion: (filePath, newVersion) => {
+            const content = fs.readFileSync(filePath, 'utf8');
+            const packageData = JSON.parse(content);
+            packageData.version = newVersion;
+            const updatedContent = `${JSON.stringify(packageData, null, 4)}\n`;
+            fs.writeFileSync(filePath, updatedContent, 'utf8');
+        },
+        projectLabel: 'Node.js'
+    },
+    'pom.xml': {
+        filename: 'pom.xml',
+        readVersion: (filePath) => {
+            try {
+                const content = fs.readFileSync(filePath, 'utf8');
+                const hasParent = /<parent>[\s\S]*?<\/parent>/.test(content);
+
+                if (hasParent) {
+                    const afterParentRegex = /<\/parent>[\s\S]*?<version>([^<]+)<\/version>/;
+                    const match = content.match(afterParentRegex);
+                    return match ? match[1].trim() : null;
+                } else {
+                    const projectVersionRegex = /<project[^>]*>[\s\S]*?<version>([^<]+)<\/version>/;
+                    const match = content.match(projectVersionRegex);
+                    return match ? match[1].trim() : null;
+                }
+            } catch (error) {
+                logger.debug('version-manager - VERSION_FILE_TYPES', 'Failed to read pom.xml', {
+                    filePath,
+                    error: error.message
+                });
+                return null;
+            }
+        },
+        writeVersion: (filePath, newVersion) => {
+            const content = fs.readFileSync(filePath, 'utf8');
+            const hasParent = /<parent>[\s\S]*?<\/parent>/.test(content);
+
+            let newContent;
+            if (hasParent) {
+                const afterParentRegex = /(<\/parent>[\s\S]*?<version>)[^<]+(<\/version>)/;
+                newContent = content.replace(afterParentRegex, `$1${newVersion}$2`);
+            } else {
+                const projectVersionRegex = /(<project[^>]*>[\s\S]*?<version>)[^<]+(<\/version>)/;
+                newContent = content.replace(projectVersionRegex, `$1${newVersion}$2`);
+            }
+
+            if (content === newContent) {
+                throw new Error('Could not find <version> tag in pom.xml');
+            }
+
+            fs.writeFileSync(filePath, newContent, 'utf8');
+        },
+        projectLabel: 'Maven'
+    },
+    'build.gradle': {
+        filename: 'build.gradle',
+        readVersion: readGradleVersion,
+        writeVersion: updateGradleVersion,
+        projectLabel: 'Gradle'
+    },
+    'build.gradle.kts': {
+        filename: 'build.gradle.kts',
+        readVersion: readGradleKtsVersion,
+        writeVersion: updateGradleKtsVersion,
+        projectLabel: 'Gradle (Kotlin)'
+    },
+    'pyproject.toml': {
+        filename: 'pyproject.toml',
+        readVersion: readPyprojectVersion,
+        writeVersion: updatePyprojectVersion,
+        projectLabel: 'Python'
+    },
+    'Cargo.toml': {
+        filename: 'Cargo.toml',
+        readVersion: readCargoVersion,
+        writeVersion: updateCargoVersion,
+        projectLabel: 'Rust'
+    },
+    'version.sbt': {
+        filename: 'version.sbt',
+        readVersion: readSbtVersion,
+        writeVersion: updateSbtVersion,
+        projectLabel: 'Scala/sbt'
+    }
 };
 
 /**
- * Discovers version files in repo root and one level deep
- * Why: Support monorepos with version files in subdirectories
+ * Discovers all version files recursively in repository
+ * Why: Support monorepos with multiple version files of same/different types
  *
- * @returns {Object} Discovered paths: { packageJson, pomXml }
+ * @param {Object} options - Discovery options
+ * @param {number} options.maxDepth - Maximum directory depth to search (default: 3)
+ * @param {string[]} options.fileTypes - File types to search for (default: all types in registry)
+ * @param {string[]} options.ignoreDirs - Additional directories to ignore
+ * @returns {Object} DiscoveryResult: { files, resolvedVersion, mismatch, types }
  */
-export function discoverVersionFiles() {
-    logger.debug('version-manager - discoverVersionFiles', 'Searching for version files');
+export function discoverVersionFiles(options = {}) {
+    const {
+        maxDepth = 3,
+        fileTypes = Object.keys(VERSION_FILE_TYPES),
+        ignoreDirs = []
+    } = options;
+
+    logger.debug('version-manager - discoverVersionFiles', 'Starting discovery', {
+        maxDepth,
+        fileTypes,
+        ignoreDirs
+    });
 
     const repoRoot = getRepoRoot();
-    const result = { packageJson: null, pomXml: null };
+    const discoveredFiles = [];
+
+    // Default ignore patterns
+    const defaultIgnore = [
+        '.git',
+        'node_modules',
+        'target',
+        'build',
+        'dist',
+        '__pycache__',
+        '.venv',
+        'vendor',
+        'out',
+        '.next',
+        '.nuxt',
+        'coverage'
+    ];
+    const ignoreSet = new Set([...defaultIgnore, ...ignoreDirs]);
+
+    /**
+     * Recursively walks directory tree
+     * @param {string} dir - Current directory path
+     * @param {number} depth - Current depth level
+     */
+    function walkDirectory(dir, depth) {
+        if (depth > maxDepth) {
+            return;
+        }
 
-    // First check root level
-    const rootPackageJson = path.join(repoRoot, 'package.json');
-    const rootPomXml = path.join(repoRoot, 'pom.xml');
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
 
-    if (fs.existsSync(rootPackageJson)) {
-        result.packageJson = rootPackageJson;
+            for (const entry of entries) {
+                // Skip hidden directories and ignored patterns
+                if (entry.name.startsWith('.') || ignoreSet.has(entry.name)) {
+                    continue;
+                }
+
+                const fullPath = path.join(dir, entry.name);
+
+                if (entry.isDirectory()) {
+                    // Recurse into subdirectory
+                    walkDirectory(fullPath, depth + 1);
+                } else if (entry.isFile()) {
+                    // Check if this file matches any registered type
+                    for (const fileType of fileTypes) {
+                        const registry = VERSION_FILE_TYPES[fileType];
+                        if (registry && entry.name === registry.filename) {
+                            // Read version from file
+                            const version = registry.readVersion(fullPath);
+
+                            // Create descriptor
+                            const descriptor = {
+                                path: fullPath,
+                                relativePath: path.relative(repoRoot, fullPath),
+                                type: fileType,
+                                projectLabel: registry.projectLabel,
+                                version,
+                                selected: true // Default: all files selected
+                            };
+
+                            discoveredFiles.push(descriptor);
+
+                            logger.debug('version-manager - discoverVersionFiles', 'Found version file', {
+                                relativePath: descriptor.relativePath,
+                                type: fileType,
+                                version
+                            });
+                        }
+                    }
+                }
+            }
+        } catch (error) {
+            logger.debug('version-manager - discoverVersionFiles', 'Error reading directory', {
+                dir,
+                error: error.message
+            });
+        }
     }
-    if (fs.existsSync(rootPomXml)) {
-        result.pomXml = rootPomXml;
+
+    // Start walking from repo root at depth 0
+    walkDirectory(repoRoot, 0);
+
+    // Sort results: root files first, then by depth, then alphabetically
+    discoveredFiles.sort((a, b) => {
+        const depthA = a.relativePath.split(path.sep).length;
+        const depthB = b.relativePath.split(path.sep).length;
+
+        if (depthA !== depthB) {
+            return depthA - depthB;
+        }
+
+        return a.relativePath.localeCompare(b.relativePath);
+    });
+
+    // Determine resolved version (prefer root-level file, then first found)
+    let resolvedVersion = null;
+    const rootFile = discoveredFiles.find(f => !f.relativePath.includes(path.sep));
+    if (rootFile && rootFile.version) {
+        resolvedVersion = rootFile.version;
+    } else if (discoveredFiles.length > 0) {
+        // Use first file's version as fallback
+        const firstWithVersion = discoveredFiles.find(f => f.version !== null);
+        resolvedVersion = firstWithVersion ? firstWithVersion.version : null;
     }
 
-    // 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;
+    // Check for version mismatch
+    const versions = discoveredFiles
+        .filter(f => f.version !== null)
+        .map(f => f.version);
+    const uniqueVersions = [...new Set(versions)];
+    const mismatch = uniqueVersions.length > 1;
+
+    // Collect unique types
+    const types = [...new Set(discoveredFiles.map(f => f.type))];
+
+    const result = {
+        files: discoveredFiles,
+        resolvedVersion,
+        mismatch,
+        types
+    };
+
+    // Cache the result
+    cachedDiscoveryResult = result;
+
+    logger.debug('version-manager - discoverVersionFiles', 'Discovery complete', {
+        filesFound: discoveredFiles.length,
+        resolvedVersion,
+        mismatch,
+        types
+    });
+
+    return result;
+}
+
+/**
+ * Gets cached discovery result
+ * Why: Allows access to full discovery result without re-scanning
+ *
+ * @returns {Object|null} Cached DiscoveryResult or null
+ */
+export function getDiscoveryResult() {
+    return cachedDiscoveryResult;
+}
+
+/**
+ * Reads version from any supported file type
+ * Why: Unified interface for reading versions
+ *
+ * @param {string} filePath - Path to version file
+ * @param {string} type - File type key from VERSION_FILE_TYPES
+ * @returns {string|null} Version string or null
+ */
+export function readVersionFromFile(filePath, type) {
+    logger.debug('version-manager - readVersionFromFile', 'Reading version', { filePath, type });
+
+    const registry = VERSION_FILE_TYPES[type];
+    if (!registry) {
+        throw new Error(`Unsupported file type: ${type}`);
     }
 
-    // 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')
-        );
+    return registry.readVersion(filePath);
+}
 
-        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
-                    });
-                }
-            }
+/**
+ * Writes version to any supported file type
+ * Why: Unified interface for writing versions
+ *
+ * @param {string} filePath - Path to version file
+ * @param {string} type - File type key from VERSION_FILE_TYPES
+ * @param {string} newVersion - New version string
+ */
+export function writeVersionToFile(filePath, type, newVersion) {
+    logger.debug('version-manager - writeVersionToFile', 'Writing version', {
+        filePath,
+        type,
+        newVersion
+    });
 
-            // 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
-                    });
-                }
-            }
+    const registry = VERSION_FILE_TYPES[type];
+    if (!registry) {
+        throw new Error(`Unsupported file type: ${type}`);
+    }
 
-            // Stop searching if both found
-            if (result.packageJson && result.pomXml) {
-                break;
+    registry.writeVersion(filePath, newVersion);
+}
+
+/**
+ * Updates version in selected files
+ * Why: Applies version update to specific VersionFileDescriptor[] subset
+ *
+ * @param {Array} files - Array of VersionFileDescriptor objects with selected=true
+ * @param {string} newVersion - New version string
+ */
+export function updateVersionFiles(files, newVersion) {
+    logger.debug('version-manager - updateVersionFiles', 'Updating version files', {
+        fileCount: files.length,
+        newVersion
+    });
+
+    // Validate version format first
+    parseVersion(newVersion); // Throws if invalid
+
+    // Validate per-file target versions
+    for (const file of files) {
+        if (file.targetVersion) {
+            parseVersion(file.targetVersion); // Throws if invalid
+        }
+    }
+
+    const errors = [];
+
+    for (const file of files) {
+        if (!file.selected) {
+            continue; // Skip unselected files
+        }
+
+        try {
+            // Verify file still exists
+            if (!fs.existsSync(file.path)) {
+                throw new Error(`File not found: ${file.path}`);
             }
+
+            // Use per-file target version if set, otherwise global newVersion
+            const targetVersion = file.targetVersion || newVersion;
+            writeVersionToFile(file.path, file.type, targetVersion);
+
+            logger.debug('version-manager - updateVersionFiles', 'File updated', {
+                path: file.relativePath,
+                type: file.type,
+                version: targetVersion
+            });
+
+        } catch (error) {
+            logger.error('version-manager - updateVersionFiles', 'Failed to update file', {
+                path: file.relativePath,
+                error: error.message
+            });
+            errors.push({ file: file.relativePath, error: error.message });
         }
-    } 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
+    if (errors.length > 0) {
+        const errorMsg = errors.map(e => `${e.file}: ${e.error}`).join(', ');
+        throw new Error(`Failed to update some files: ${errorMsg}`);
+    }
+
+    logger.debug('version-manager - updateVersionFiles', 'All files updated successfully');
+}
+
+/**
+ * Modifies version suffix without bumping version numbers
+ * Why: Support suffix-only operations (add/remove/replace SNAPSHOT, RC, etc.)
+ *
+ * @param {string} version - Current version string
+ * @param {Object} options - Modification options
+ * @param {boolean} options.remove - Remove existing suffix
+ * @param {string} options.set - Set/replace suffix with this value
+ * @returns {string} Modified version string
+ */
+export function modifySuffix(version, options = {}) {
+    logger.debug('version-manager - modifySuffix', 'Modifying suffix', { version, options });
+
+    const parsed = parseVersion(version);
+
+    let newVersion;
+
+    if (options.remove) {
+        // Remove suffix: 2.15.5-SNAPSHOT → 2.15.5
+        newVersion = `${parsed.major}.${parsed.minor}.${parsed.patch}`;
+    } else if (options.set) {
+        // Set/replace suffix: 2.15.5 → 2.15.5-SNAPSHOT or 2.15.5-RC1 → 2.15.5-RC2
+        newVersion = `${parsed.major}.${parsed.minor}.${parsed.patch}-${options.set}`;
+    } else {
+        // No-op: return original
+        newVersion = version;
+    }
+
+    logger.debug('version-manager - modifySuffix', 'Suffix modified', {
+        oldVersion: version,
+        newVersion
     });
 
-    return result;
+    return newVersion;
 }
 
 /**
- * Detects project type based on version files present
- * Why: Different projects require different version file handling
+ * Reads current version from build.gradle
+ * Why: Gradle projects store version in version = '...' or version '...'
  *
- * @returns {string} Project type: 'node' | 'maven' | 'both' | 'none'
+ * @param {string} filePath - Path to build.gradle
+ * @returns {string|null} Version string or null if not found
  */
-export function detectProjectType() {
-    logger.debug('version-manager - detectProjectType', 'Detecting project type');
+function readGradleVersion(filePath) {
+    logger.debug('version-manager - readGradleVersion', 'Reading version from build.gradle', { filePath });
 
     try {
-        // Discover version files (checks root and subdirectories)
-        discoveredPaths = discoverVersionFiles();
+        if (!fs.existsSync(filePath)) {
+            logger.debug('version-manager - readGradleVersion', 'build.gradle not found');
+            return null;
+        }
+
+        const content = fs.readFileSync(filePath, 'utf8');
 
-        const hasPackageJson = discoveredPaths.packageJson !== null;
-        const hasPomXml = discoveredPaths.pomXml !== null;
+        // Match: version = '...' or version '...' or version="..." or version "..."
+        const versionRegex = /version\s*=?\s*['"]([^'"]+)['"]/;
+        const match = content.match(versionRegex);
 
-        let projectType;
-        if (hasPackageJson && hasPomXml) {
-            projectType = PROJECT_TYPES.BOTH;
-        } else if (hasPackageJson) {
-            projectType = PROJECT_TYPES.NODE;
-        } else if (hasPomXml) {
-            projectType = PROJECT_TYPES.MAVEN;
-        } else {
-            projectType = PROJECT_TYPES.NONE;
+        if (!match) {
+            logger.debug('version-manager - readGradleVersion', 'Version not found in build.gradle');
+            return null;
         }
 
-        const repoRoot = getRepoRoot();
-        logger.debug('version-manager - detectProjectType', 'Project type detected', {
-            projectType,
-            packageJson: discoveredPaths.packageJson ? path.relative(repoRoot, discoveredPaths.packageJson) : null,
-            pomXml: discoveredPaths.pomXml ? path.relative(repoRoot, discoveredPaths.pomXml) : null
-        });
+        const version = match[1].trim();
+        logger.debug('version-manager - readGradleVersion', 'Version read', { version, path: filePath });
 
-        return projectType;
+        return version;
 
     } catch (error) {
-        logger.error('version-manager - detectProjectType', 'Failed to detect project type', error);
-        throw error;
+        logger.error('version-manager - readGradleVersion', 'Failed to read version', error);
+        throw new Error(`Failed to read build.gradle: ${error.message}`);
     }
 }
 
 /**
- * Reads current version from package.json
- * Why: Node.js projects store version in package.json
+ * Reads current version from build.gradle.kts (Kotlin DSL)
+ * Why: Gradle Kotlin DSL uses double quotes
  *
+ * @param {string} filePath - Path to build.gradle.kts
  * @returns {string|null} Version string or null if not found
  */
-function readPackageJsonVersion() {
-    logger.debug('version-manager - readPackageJsonVersion', 'Reading version from package.json');
+function readGradleKtsVersion(filePath) {
+    logger.debug('version-manager - readGradleKtsVersion', 'Reading version from build.gradle.kts', { filePath });
 
     try {
-        const packageJsonPath = discoveredPaths.packageJson;
-
-        if (!packageJsonPath || !fs.existsSync(packageJsonPath)) {
-            logger.debug('version-manager - readPackageJsonVersion', 'package.json not found');
+        if (!fs.existsSync(filePath)) {
+            logger.debug('version-manager - readGradleKtsVersion', 'build.gradle.kts not found');
             return null;
         }
 
-        const content = fs.readFileSync(packageJsonPath, 'utf8');
-        const packageData = JSON.parse(content);
-        const version = packageData.version || null;
+        const content = fs.readFileSync(filePath, 'utf8');
 
-        logger.debug('version-manager - readPackageJsonVersion', 'Version read', {
-            version,
-            path: packageJsonPath
-        });
+        // Match: version = "..."
+        const versionRegex = /version\s*=\s*"([^"]+)"/;
+        const match = content.match(versionRegex);
+
+        if (!match) {
+            logger.debug('version-manager - readGradleKtsVersion', 'Version not found in build.gradle.kts');
+            return null;
+        }
+
+        const version = match[1].trim();
+        logger.debug('version-manager - readGradleKtsVersion', 'Version read', { version, path: filePath });
 
         return version;
 
     } catch (error) {
-        logger.error('version-manager - readPackageJsonVersion', 'Failed to read version', error);
-        throw new Error(`Failed to read package.json: ${error.message}`);
+        logger.error('version-manager - readGradleKtsVersion', 'Failed to read version', error);
+        throw new Error(`Failed to read build.gradle.kts: ${error.message}`);
     }
 }
 
 /**
- * Reads current version from pom.xml
- * Why: Maven projects store version in pom.xml <project><version>
+ * Reads current version from pyproject.toml
+ * Why: Python projects use pyproject.toml with [project] or [tool.poetry] section
  *
- * 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>
+ * @param {string} filePath - Path to pyproject.toml
+ * @returns {string|null} Version string or null if not found
+ */
+function readPyprojectVersion(filePath) {
+    logger.debug('version-manager - readPyprojectVersion', 'Reading version from pyproject.toml', { filePath });
+
+    try {
+        if (!fs.existsSync(filePath)) {
+            logger.debug('version-manager - readPyprojectVersion', 'pyproject.toml not found');
+            return null;
+        }
+
+        const content = fs.readFileSync(filePath, 'utf8');
+
+        // Try [project] section first (PEP 621)
+        const projectSectionRegex = /\[project\][\s\S]*?version\s*=\s*["']([^"']+)["']/;
+        let match = content.match(projectSectionRegex);
+
+        // If not found, try [tool.poetry] section
+        if (!match) {
+            const poetrySectionRegex = /\[tool\.poetry\][\s\S]*?version\s*=\s*["']([^"']+)["']/;
+            match = content.match(poetrySectionRegex);
+        }
+
+        if (!match) {
+            logger.debug('version-manager - readPyprojectVersion', 'Version not found in pyproject.toml');
+            return null;
+        }
+
+        const version = match[1].trim();
+        logger.debug('version-manager - readPyprojectVersion', 'Version read', { version, path: filePath });
+
+        return version;
+
+    } catch (error) {
+        logger.error('version-manager - readPyprojectVersion', 'Failed to read version', error);
+        throw new Error(`Failed to read pyproject.toml: ${error.message}`);
+    }
+}
+
+/**
+ * Reads current version from Cargo.toml
+ * Why: Rust projects store version in [package] section
  *
+ * @param {string} filePath - Path to Cargo.toml
  * @returns {string|null} Version string or null if not found
  */
-function readPomXmlVersion() {
-    logger.debug('version-manager - readPomXmlVersion', 'Reading version from pom.xml');
+function readCargoVersion(filePath) {
+    logger.debug('version-manager - readCargoVersion', 'Reading version from Cargo.toml', { filePath });
 
     try {
-        const pomXmlPath = discoveredPaths.pomXml;
+        if (!fs.existsSync(filePath)) {
+            logger.debug('version-manager - readCargoVersion', 'Cargo.toml not found');
+            return null;
+        }
+
+        const content = fs.readFileSync(filePath, 'utf8');
 
-        if (!pomXmlPath || !fs.existsSync(pomXmlPath)) {
-            logger.debug('version-manager - readPomXmlVersion', 'pom.xml not found');
+        // Match version in [package] section
+        const versionRegex = /\[package\][\s\S]*?version\s*=\s*["']([^"']+)["']/;
+        const match = content.match(versionRegex);
+
+        if (!match) {
+            logger.debug('version-manager - readCargoVersion', 'Version not found in Cargo.toml');
             return null;
         }
 
-        const content = fs.readFileSync(pomXmlPath, 'utf8');
+        const version = match[1].trim();
+        logger.debug('version-manager - readCargoVersion', 'Version read', { version, path: filePath });
 
-        // Check if <parent> block exists
-        const hasParent = /<parent>[\s\S]*?<\/parent>/.test(content);
-        let version = null;
+        return version;
 
-        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();
-            }
+    } catch (error) {
+        logger.error('version-manager - readCargoVersion', 'Failed to read version', error);
+        throw new Error(`Failed to read Cargo.toml: ${error.message}`);
+    }
+}
+
+/**
+ * Reads current version from version.sbt
+ * Why: Scala/sbt projects store version in ThisBuild / version := "..." or version := "..."
+ *
+ * @param {string} filePath - Path to version.sbt
+ * @returns {string|null} Version string or null if not found
+ */
+function readSbtVersion(filePath) {
+    logger.debug('version-manager - readSbtVersion', 'Reading version from version.sbt', { filePath });
+
+    try {
+        if (!fs.existsSync(filePath)) {
+            logger.debug('version-manager - readSbtVersion', 'version.sbt not found');
+            return null;
         }
 
-        if (!version) {
-            logger.debug('version-manager - readPomXmlVersion', 'Version tag not found in pom.xml');
+        const content = fs.readFileSync(filePath, 'utf8');
+
+        // Match: ThisBuild / version := "..." or version := "..."
+        const versionRegex = /(?:ThisBuild\s*\/\s*)?version\s*:=\s*["']([^"']+)["']/;
+        const match = content.match(versionRegex);
+
+        if (!match) {
+            logger.debug('version-manager - readSbtVersion', 'Version not found in version.sbt');
             return null;
         }
 
-        logger.debug('version-manager - readPomXmlVersion', 'Version read', {
-            version,
-            path: pomXmlPath,
-            hasParent
-        });
+        const version = match[1].trim();
+        logger.debug('version-manager - readSbtVersion', 'Version read', { version, path: filePath });
 
         return version;
 
     } catch (error) {
-        logger.error('version-manager - readPomXmlVersion', 'Failed to read version', error);
-        throw new Error(`Failed to read pom.xml: ${error.message}`);
+        logger.error('version-manager - readSbtVersion', 'Failed to read version', error);
+        throw new Error(`Failed to read version.sbt: ${error.message}`);
     }
 }
 
@@ -315,57 +697,6 @@ function readChangelogVersion() {
     }
 }
 
-/**
- * Gets current version based on project type
- * Why: Abstracts version location from caller
- *
- * @param {string} projectType - Project type from detectProjectType()
- * @returns {Object} Version info: { packageJson, pomXml, resolved, mismatch }
- */
-export function getCurrentVersion(projectType) {
-    logger.debug('version-manager - getCurrentVersion', 'Getting current version', { projectType });
-
-    const versions = {
-        packageJson: null,
-        pomXml: null,
-        resolved: null,
-        mismatch: false
-    };
-
-    try {
-        if (projectType === PROJECT_TYPES.NODE || projectType === PROJECT_TYPES.BOTH) {
-            versions.packageJson = readPackageJsonVersion();
-        }
-
-        if (projectType === PROJECT_TYPES.MAVEN || projectType === PROJECT_TYPES.BOTH) {
-            versions.pomXml = readPomXmlVersion();
-        }
-
-        // Resolve version: use package.json if available, otherwise pom.xml
-        versions.resolved = versions.packageJson || versions.pomXml;
-
-        // Validate consistency in monorepos
-        if (projectType === PROJECT_TYPES.BOTH) {
-            if (versions.packageJson !== versions.pomXml) {
-                versions.mismatch = true;
-                logger.warning(
-                    'version-manager - getCurrentVersion',
-                    'Version mismatch in monorepo',
-                    { packageJson: versions.packageJson, pomXml: versions.pomXml }
-                );
-            }
-        }
-
-        logger.debug('version-manager - getCurrentVersion', 'Versions retrieved', versions);
-
-        return versions;
-
-    } catch (error) {
-        logger.error('version-manager - getCurrentVersion', 'Failed to get version', error);
-        throw error;
-    }
-}
-
 /**
  * Parses version string into components
  * Why: Enables version manipulation and comparison
@@ -452,129 +783,187 @@ export function incrementVersion(currentVersion, bumpType, suffix = null) {
 }
 
 /**
- * Updates version in package.json
- * Why: Writes new version to Node.js project file
+ * Updates version in build.gradle
+ * Why: Writes new version to Gradle project file
  *
+ * @param {string} filePath - Path to build.gradle
  * @param {string} newVersion - New version string
  */
-function updatePackageJsonVersion(newVersion) {
-    logger.debug('version-manager - updatePackageJsonVersion', 'Updating package.json', { newVersion });
+function updateGradleVersion(filePath, newVersion) {
+    logger.debug('version-manager - updateGradleVersion', 'Updating build.gradle', { filePath, newVersion });
 
     try {
-        const packageJsonPath = discoveredPaths.packageJson;
-
-        if (!packageJsonPath) {
-            throw new Error('package.json path not discovered');
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`build.gradle not found at ${filePath}`);
         }
 
-        const content = fs.readFileSync(packageJsonPath, 'utf8');
-        const packageData = JSON.parse(content);
+        const content = fs.readFileSync(filePath, 'utf8');
 
-        packageData.version = newVersion;
+        // Replace: version = '...' or version '...' or version="..." or version "..."
+        const versionRegex = /(version\s*=?\s*)['"]([^'"]+)['"]/;
+        const newContent = content.replace(versionRegex, `$1'${newVersion}'`);
 
-        // Write with 4-space indent to match existing format
-        const updatedContent = `${JSON.stringify(packageData, null, 4)}\n`;
-        fs.writeFileSync(packageJsonPath, updatedContent, 'utf8');
+        if (content === newContent) {
+            throw new Error('Could not find version property in build.gradle');
+        }
 
-        logger.debug('version-manager - updatePackageJsonVersion', 'package.json updated', {
-            path: packageJsonPath
-        });
+        fs.writeFileSync(filePath, newContent, 'utf8');
+
+        logger.debug('version-manager - updateGradleVersion', 'build.gradle updated', { path: filePath });
 
     } catch (error) {
-        logger.error('version-manager - updatePackageJsonVersion', 'Failed to update package.json', error);
-        throw new Error(`Failed to update package.json: ${error.message}`);
+        logger.error('version-manager - updateGradleVersion', 'Failed to update build.gradle', error);
+        throw new Error(`Failed to update build.gradle: ${error.message}`);
     }
 }
 
 /**
- * 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>
+ * Updates version in build.gradle.kts (Kotlin DSL)
+ * Why: Writes new version to Gradle Kotlin DSL project file
  *
+ * @param {string} filePath - Path to build.gradle.kts
  * @param {string} newVersion - New version string
  */
-function updatePomXmlVersion(newVersion) {
-    logger.debug('version-manager - updatePomXmlVersion', 'Updating pom.xml', { newVersion });
+function updateGradleKtsVersion(filePath, newVersion) {
+    logger.debug('version-manager - updateGradleKtsVersion', 'Updating build.gradle.kts', { filePath, newVersion });
 
     try {
-        const pomXmlPath = discoveredPaths.pomXml;
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`build.gradle.kts not found at ${filePath}`);
+        }
+
+        const content = fs.readFileSync(filePath, 'utf8');
+
+        // Replace: version = "..."
+        const versionRegex = /(version\s*=\s*)"([^"]+)"/;
+        const newContent = content.replace(versionRegex, `$1"${newVersion}"`);
+
+        if (content === newContent) {
+            throw new Error('Could not find version property in build.gradle.kts');
+        }
 
-        if (!pomXmlPath) {
-            throw new Error('pom.xml path not discovered');
+        fs.writeFileSync(filePath, newContent, 'utf8');
+
+        logger.debug('version-manager - updateGradleKtsVersion', 'build.gradle.kts updated', { path: filePath });
+
+    } catch (error) {
+        logger.error('version-manager - updateGradleKtsVersion', 'Failed to update build.gradle.kts', error);
+        throw new Error(`Failed to update build.gradle.kts: ${error.message}`);
+    }
+}
+
+/**
+ * Updates version in pyproject.toml
+ * Why: Writes new version to Python project file
+ *
+ * @param {string} filePath - Path to pyproject.toml
+ * @param {string} newVersion - New version string
+ */
+function updatePyprojectVersion(filePath, newVersion) {
+    logger.debug('version-manager - updatePyprojectVersion', 'Updating pyproject.toml', { filePath, newVersion });
+
+    try {
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`pyproject.toml not found at ${filePath}`);
         }
 
-        const content = fs.readFileSync(pomXmlPath, 'utf8');
+        const content = fs.readFileSync(filePath, 'utf8');
 
-        // Check if <parent> block exists
-        const hasParent = /<parent>[\s\S]*?<\/parent>/.test(content);
-        let newContent;
+        // Try to replace in [project] section first
+        let newContent = content.replace(
+            /(\[project\][\s\S]*?version\s*=\s*)["']([^"']+)["']/,
+            `$1"${newVersion}"`
+        );
 
-        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 not found, try [tool.poetry] section
+        if (content === newContent) {
+            newContent = content.replace(
+                /(\[tool\.poetry\][\s\S]*?version\s*=\s*)["']([^"']+)["']/,
+                `$1"${newVersion}"`
+            );
         }
 
         if (content === newContent) {
-            logger.warning('version-manager - updatePomXmlVersion', 'No version tag found to update');
-            throw new Error('Could not find <version> tag in pom.xml');
+            throw new Error('Could not find version in pyproject.toml');
         }
 
-        fs.writeFileSync(pomXmlPath, newContent, 'utf8');
+        fs.writeFileSync(filePath, newContent, 'utf8');
 
-        logger.debug('version-manager - updatePomXmlVersion', 'pom.xml updated', {
-            path: pomXmlPath,
-            hasParent
-        });
+        logger.debug('version-manager - updatePyprojectVersion', 'pyproject.toml updated', { path: filePath });
 
     } catch (error) {
-        logger.error('version-manager - updatePomXmlVersion', 'Failed to update pom.xml', error);
-        throw new Error(`Failed to update pom.xml: ${error.message}`);
+        logger.error('version-manager - updatePyprojectVersion', 'Failed to update pyproject.toml', error);
+        throw new Error(`Failed to update pyproject.toml: ${error.message}`);
     }
 }
 
 /**
- * Updates version in project files
- * Why: Applies new version to all relevant files atomically
+ * Updates version in Cargo.toml
+ * Why: Writes new version to Rust project file
  *
- * @param {string} projectType - Project type from detectProjectType()
+ * @param {string} filePath - Path to Cargo.toml
  * @param {string} newVersion - New version string
  */
-export function updateVersion(projectType, newVersion) {
-    logger.debug('version-manager - updateVersion', 'Updating version in files', {
-        projectType,
-        newVersion
-    });
+function updateCargoVersion(filePath, newVersion) {
+    logger.debug('version-manager - updateCargoVersion', 'Updating Cargo.toml', { filePath, newVersion });
 
     try {
-        // Validate version format first
-        parseVersion(newVersion); // Throws if invalid
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`Cargo.toml not found at ${filePath}`);
+        }
+
+        const content = fs.readFileSync(filePath, 'utf8');
 
-        if (projectType === PROJECT_TYPES.NODE || projectType === PROJECT_TYPES.BOTH) {
-            updatePackageJsonVersion(newVersion);
+        // Replace version in [package] section
+        const versionRegex = /(\[package\][\s\S]*?version\s*=\s*)["']([^"']+)["']/;
+        const newContent = content.replace(versionRegex, `$1"${newVersion}"`);
+
+        if (content === newContent) {
+            throw new Error('Could not find version in Cargo.toml [package] section');
         }
 
-        if (projectType === PROJECT_TYPES.MAVEN || projectType === PROJECT_TYPES.BOTH) {
-            updatePomXmlVersion(newVersion);
+        fs.writeFileSync(filePath, newContent, 'utf8');
+
+        logger.debug('version-manager - updateCargoVersion', 'Cargo.toml updated', { path: filePath });
+
+    } catch (error) {
+        logger.error('version-manager - updateCargoVersion', 'Failed to update Cargo.toml', error);
+        throw new Error(`Failed to update Cargo.toml: ${error.message}`);
+    }
+}
+
+/**
+ * Updates version in version.sbt
+ * Why: Writes new version to Scala/sbt project file
+ *
+ * @param {string} filePath - Path to version.sbt
+ * @param {string} newVersion - New version string
+ */
+function updateSbtVersion(filePath, newVersion) {
+    logger.debug('version-manager - updateSbtVersion', 'Updating version.sbt', { filePath, newVersion });
+
+    try {
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`version.sbt not found at ${filePath}`);
         }
 
-        if (projectType === PROJECT_TYPES.NONE) {
-            throw new Error('No version files found (package.json or pom.xml)');
+        const content = fs.readFileSync(filePath, 'utf8');
+
+        // Replace: ThisBuild / version := "..." or version := "..."
+        const versionRegex = /((?:ThisBuild\s*\/\s*)?version\s*:=\s*)["']([^"']+)["']/;
+        const newContent = content.replace(versionRegex, `$1"${newVersion}"`);
+
+        if (content === newContent) {
+            throw new Error('Could not find version in version.sbt');
         }
 
-        logger.debug('version-manager - updateVersion', 'Version updated successfully');
+        fs.writeFileSync(filePath, newContent, 'utf8');
+
+        logger.debug('version-manager - updateSbtVersion', 'version.sbt updated', { path: filePath });
 
     } catch (error) {
-        logger.error('version-manager - updateVersion', 'Failed to update version', error);
-        throw error;
+        logger.error('version-manager - updateSbtVersion', 'Failed to update version.sbt', error);
+        throw new Error(`Failed to update version.sbt: ${error.message}`);
     }
 }
 
@@ -661,8 +1050,8 @@ export async function validateVersionAlignment() {
     logger.debug('version-manager - validateVersionAlignment', 'Validating version alignment');
 
     try {
-        const projectType = detectProjectType();
-        const versions = getCurrentVersion(projectType);
+        // Discover all version files
+        const discovery = discoverVersionFiles();
 
         // Get git tag version (parseTagVersion returns null for non-semver tags)
         const { getLatestLocalTag, parseTagVersion } = await import('./git-tag-manager.js');
@@ -681,14 +1070,14 @@ export async function validateVersionAlignment() {
         const localVersions = [];
         const issues = [];
 
-        if (versions.packageJson) {
-            localVersions.push(versions.packageJson);
-            issues.push({ source: 'package.json', version: versions.packageJson });
-        }
-        if (versions.pomXml) {
-            localVersions.push(versions.pomXml);
-            issues.push({ source: 'pom.xml', version: versions.pomXml });
+        // Add versions from discovered files
+        for (const file of discovery.files) {
+            if (file.version) {
+                localVersions.push(file.version);
+                issues.push({ source: file.relativePath, version: file.version });
+            }
         }
+
         if (changelogVersion) {
             localVersions.push(changelogVersion);
             issues.push({ source: 'CHANGELOG.md', version: changelogVersion });
@@ -739,12 +1128,3 @@ 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 };
-}