MokoCLI/cli/version_bump.php

#!/usr/bin/env php
<?php

/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 * FILE INFORMATION
<<<<<<< HEAD
 * DEFGROUP: MokoCLI.CLI
 * INGROUP: MokoCLI
 * REPO: https://git.mokoconsulting.tech/MokoConsulting/mokocli
=======
 * DEFGROUP: mokoplatform.CLI
 * INGROUP: mokoplatform
 * REPO: https://git.mokoconsulting.tech/MokoConsulting/mokoplatform
>>>>>>> main
 * PATH: /cli/version_bump.php
 * BRIEF: Auto-increment version -- manifest.xml is canonical, cascades to all XML and MD files
 */

declare(strict_types=1);

require_once __DIR__ . '/../lib/Enterprise/CliFramework.php';

use MokoCli\{CliFramework, SourceResolver};

class VersionBumpCli extends CliFramework
{
    protected function configure(): void
    {
        $this->setDescription('Auto-increment version -- manifest.xml is canonical, cascades to all XML and MD files');
        $this->addArgument('--path', 'Repository root', '.');
        $this->addArgument('--minor', 'Bump minor version', false);
        $this->addArgument('--major', 'Bump major version', false);
        $this->addArgument('--min-version', 'Minimum base version (ensures bump is above this)', '');
    }

    protected function run(): int
    {
        $path = $this->getArgument('--path');
        $type = 'patch';
        if ($this->getArgument('--minor')) {
            $type = 'minor';
        }
        if ($this->getArgument('--major')) {
            $type = 'major';
        }
        $root = realpath($path) ?: $path;
        $mokoVersion = null;
        $existingSuffix = '';
        $versionPrefix = '';
        $mokoManifest = "{$root}/.mokogitea/manifest.xml";
        $mokoContent = '';
        if (file_exists($mokoManifest)) {
            $mokoContent = file_get_contents($mokoManifest);
            if (preg_match('#<version>(\d{2}\.\d{2}\.\d{2})((?:-(?:dev|alpha|beta|rc))+)?</version>#', $mokoContent, $m)) {
                $mokoVersion = $m[1];
                $existingSuffix = $m[2] ?? '';
            }
            // Read version_prefix from manifest.xml (supports nested and flat structure)
            $xml = @simplexml_load_file($mokoManifest);
            if ($xml !== false) {
                $prefix = (string)($xml->identity->version_prefix ?? '');
                if ($prefix === '') {
                    $prefix = (string)($xml->version_prefix ?? '');
                }
                $versionPrefix = $prefix;
            }
        }
        $readmeVersion = null;
        $readme = "{$root}/README.md";
        $readmeContent = '';
        if (file_exists($readme)) {
            $readmeContent = file_get_contents($readme);
            if (!empty($versionPrefix)) {
                // Prefix-aware README scan
                $prefixPattern = preg_quote($versionPrefix, '/');
                if (preg_match('/' . $prefixPattern . '(\d{2}\.\d{2}\.\d{2})/m', $readmeContent, $m)) {
                    $readmeVersion = $m[1];
                }
            }
            if ($readmeVersion === null && preg_match('/VERSION:\s*(\d{2}\.\d{2}\.\d{2})/m', $readmeContent, $m)) {
                $readmeVersion = $m[1];
            }
        }
        $manifestVersion = null;
        SourceResolver::warnIfLegacy($root);
        $manifestFiles = array_merge(
            SourceResolver::globSource($root, 'pkg_*.xml'),
            SourceResolver::globSource($root, '*.xml'),
            SourceResolver::globSource($root, 'packages/*/mokowaas.xml'),
            SourceResolver::globSource($root, 'packages/*/*.xml'),
            glob("{$root}/*.xml") ?: []
        );
        foreach ($manifestFiles as $xmlFile) {
            $xmlContent = file_get_contents($xmlFile);
            if (strpos($xmlContent, '<extension') === false && strpos($xmlContent, '<version>') === false) {
                continue;
            }
            if (!empty($versionPrefix)) {
                // Prefix-aware: look for <version>prefix + XX.YY.ZZ</version>
                $prefixPattern = preg_quote($versionPrefix, '#');
                if (preg_match('#<version>' . $prefixPattern . '(\d{2}\.\d{2}\.\d{2})</version>#', $xmlContent, $xm)) {
                    $candidate = $xm[1];
                    if ($manifestVersion === null || version_compare($candidate, $manifestVersion, '>')) {
                        $manifestVersion = $candidate;
                    }
                    continue;
                }
            }
            if (preg_match('#<version>(\d{2}\.\d{2}\.\d{2})((?:-(?:dev|alpha|beta|rc))+)?</version>#', $xmlContent, $xm)) {
                $candidate = $xm[1];
                if ($manifestVersion === null || version_compare($candidate, $manifestVersion, '>')) {
                    $manifestVersion = $candidate;
                }
            }
        }
        $baseVersion = null;
        $candidates = array_filter([$mokoVersion, $readmeVersion, $manifestVersion]);
        foreach ($candidates as $v) {
            if ($baseVersion === null || version_compare($v, $baseVersion, '>')) {
                $baseVersion = $v;
            }
        }

        // Check --min-version: ensures dev never falls behind stable
        $minVersion = $this->getArgument('--min-version');
        if (!empty($minVersion)) {
            $minVersion = preg_replace('/-(?:dev|alpha|beta|rc)$/', '', $minVersion);
            if (preg_match('/^\d{2}\.\d{2}\.\d{2}$/', $minVersion)) {
                if ($baseVersion === null || version_compare($minVersion, $baseVersion, '>')) {
                    $this->log('INFO', "Using --min-version {$minVersion} (higher than manifest {$baseVersion})");
                    $baseVersion = $minVersion;
                }
            }
        }

        // Auto-detect: scan git tags for higher versions from other channels
        if ($baseVersion !== null) {
            $gitTagVersion = $this->getHighestGitTagVersion($root);
            if ($gitTagVersion !== null && version_compare($gitTagVersion, $baseVersion, '>')) {
                $this->log('INFO', "Git tag version {$gitTagVersion} is higher than manifest {$baseVersion} — using as base");
                $baseVersion = $gitTagVersion;
            }
        }

        if ($baseVersion === null) {
            $this->log('ERROR', "No version found in manifest.xml, README.md, or Joomla XML");
            return 1;
        }
        if (!preg_match('/^(\d{2})\.(\d{2})\.(\d{2})$/', $baseVersion, $parts)) {
            $this->log('ERROR', "Invalid version format: {$baseVersion}");
            return 1;
        }
        $major = (int)$parts[1];
        $minor = (int)$parts[2];
        $patch = (int)$parts[3];
        $old = sprintf('%02d.%02d.%02d', $major, $minor, $patch);
        switch ($type) {
            case 'major':
                $major++;
                $minor = 0;
                $patch = 0;
                break;
            case 'minor':
                $minor++;
                $patch = 0;
                break;
            default:
                $patch++;
                if ($patch > 99) {
                    $minor++;
                    $patch = 0;
                } if ($minor > 99) {
                    $major++;
                    $minor = 0;
                }
                break;
        }
        $newBase = sprintf('%02d.%02d.%02d', $major, $minor, $patch);
        $newFull = $newBase . $existingSuffix;
        if (file_exists($mokoManifest) && !empty($mokoContent)) {
            $pattern = '#<version>\d{2}\.\d{2}\.\d{2}'
                . '(?:(?:-(?:dev|alpha|beta|rc))+)?</version>#';
            $updated = preg_replace(
                $pattern,
                "<version>{$newFull}</version>",
                $mokoContent,
                1
            );
            if ($updated !== null) {
                file_put_contents($mokoManifest, $updated);
            }
        }
        if (file_exists($readme) && !empty($readmeContent)) {
            if (!empty($versionPrefix)) {
                // Prefix-aware README replacement: preserve prefix, replace only version part
                $prefixPattern = preg_quote($versionPrefix, '/');
                $updated = preg_replace('/(' . $prefixPattern . ')\d{2}\.\d{2}\.\d{2}/m', '${1}' . $newBase, $readmeContent, 1);
            } else {
                $updated = preg_replace('/(VERSION:\s*)\d{2}\.\d{2}\.\d{2}(?:(?:-(?:dev|alpha|beta|rc))+)?/m', '${1}' . $newBase, $readmeContent, 1);
            }
            if ($updated !== null) {
                file_put_contents($readme, $updated);
            }
        }
        $updatedFiles = [];
        $srcName = SourceResolver::resolve($root);
        foreach (["{$root}/{$srcName}/pkg_*.xml", "{$root}/{$srcName}/*.xml", "{$root}/{$srcName}/packages/*/*.xml", "{$root}/*.xml"] as $pattern) {
            foreach (glob($pattern) ?: [] as $xmlFile) {
                $content = file_get_contents($xmlFile);
                if (strpos($content, '<extension') === false) {
                    continue;
                }
                if (!empty($versionPrefix)) {
                    // Prefix-aware: preserve prefix, replace only the Moko version part
                    $prefixPattern = preg_quote($versionPrefix, '#');
                    $xmlPattern = '#(<version>' . $prefixPattern . ')\d{2}\.\d{2}\.\d{2}</version>#';
                    $newContent = preg_replace(
                        $xmlPattern,
                        '${1}' . $newBase . '</version>',
                        $content
                    );
                } else {
                    $xmlPattern = '#<version>\d{2}\.\d{2}\.\d{2}'
                        . '(?:(?:-(?:dev|alpha|beta|rc))+)?</version>#';
                    $newContent = preg_replace(
                        $xmlPattern,
                        "<version>{$newFull}</version>",
                        $content
                    );
                }
                if ($newContent !== null && $newContent !== $content) {
                    file_put_contents($xmlFile, $newContent);
                    $updatedFiles[] = substr($xmlFile, strlen($root) + 1);
                }
            }
        }
        if (!empty($updatedFiles)) {
            fwrite(STDERR, "Updated " . count($updatedFiles) . " Joomla manifest(s): " . implode(', ', $updatedFiles) . "\n");
        }
        $packageJsonFile = "{$root}/package.json";
        if (file_exists($packageJsonFile)) {
            $pkgContent = file_get_contents($packageJsonFile);
            if (!empty($versionPrefix)) {
                // Prefix-aware package.json replacement
                $prefixPattern = preg_quote($versionPrefix, '/');
                $pkgPattern = '/("version"\s*:\s*")' . $prefixPattern . '\d{2}\.\d{2}\.\d{2}(")/m';
                $updatedPkg = preg_replace(
                    $pkgPattern,
                    '${1}' . $versionPrefix . $newBase . '${2}',
                    $pkgContent
                );
            } else {
                $pkgPattern = '/("version"\s*:\s*")\d{2}\.\d{2}\.\d{2}'
                    . '(?:(?:-(?:dev|alpha|beta|rc))+)?(")/m';
                $updatedPkg = preg_replace(
                    $pkgPattern,
                    '${1}' . $newFull . '${2}',
                    $pkgContent
                );
            }
            if ($updatedPkg !== $pkgContent && $updatedPkg !== null) {
                file_put_contents($packageJsonFile, $updatedPkg);
                fwrite(STDERR, "Updated package.json\n");
            } elseif (preg_match('/("version"\s*:\s*")(\d+)\.(\d+)\.(\d+)(")/m', $pkgContent, $semM)) {
                // Semver fallback: bump standard x.y.z version when XX.YY.ZZ pattern didn't match
                $sMajor = (int)$semM[2];
                $sMinor = (int)$semM[3];
                $sPatch = (int)$semM[4];
                switch ($type) {
                    case 'major': $sMajor++; $sMinor = 0; $sPatch = 0; break;
                    case 'minor': $sMinor++; $sPatch = 0; break;
                    default: $sPatch++; break;
                }
                $semNew = "{$sMajor}.{$sMinor}.{$sPatch}";
                $semUpdated = preg_replace('/("version"\s*:\s*")\d+\.\d+\.\d+(")/m', '${1}' . $semNew . '${2}', $pkgContent);
                if ($semUpdated !== $pkgContent) {
                    file_put_contents($packageJsonFile, $semUpdated);
                    fwrite(STDERR, "Updated package.json (semver: {$semM[2]}.{$semM[3]}.{$semM[4]} -> $semNew)\n");
                }
            }
        }
        $pyprojectFile = "{$root}/pyproject.toml";
        if (file_exists($pyprojectFile)) {
            $pyContent = file_get_contents($pyprojectFile);
            if (!empty($versionPrefix)) {
                // Prefix-aware pyproject.toml replacement
                $prefixPattern = preg_quote($versionPrefix, '/');
                $pyPattern = '/^(version\s*=\s*")' . $prefixPattern . '\d{2}\.\d{2}\.\d{2}(")/m';
                $updatedPy = preg_replace(
                    $pyPattern,
                    '${1}' . $versionPrefix . $newBase . '${2}',
                    $pyContent
                );
            } else {
                $pyPattern = '/^(version\s*=\s*")\d{2}\.\d{2}\.\d{2}'
                    . '(?:(?:-(?:dev|alpha|beta|rc))+)?(")/m';
                $updatedPy = preg_replace(
                    $pyPattern,
                    '${1}' . $newFull . '${2}',
                    $pyContent
                );
            }
            if ($updatedPy !== $pyContent) {
                file_put_contents($pyprojectFile, $updatedPy);
                fwrite(STDERR, "Updated pyproject.toml\n");
            }
        }
        $changelogFile = "{$root}/CHANGELOG.md";
        if (file_exists($changelogFile)) {
            $clContent = file_get_contents($changelogFile);
            $updatedCl = preg_replace('/(VERSION:\s*)\d{2}\.\d{2}\.\d{2}(?:(?:-(?:dev|alpha|beta|rc))+)?/m', '${1}' . $newBase, $clContent);
            if ($updatedCl !== null && $updatedCl !== $clContent) {
                file_put_contents($changelogFile, $updatedCl);
                fwrite(STDERR, "Updated CHANGELOG.md\n");
            }
        }
        $scanExtensions = ['php', 'yml', 'yaml', 'md', 'txt', 'xml', 'sh', 'toml', 'ini', 'css', 'js'];
        $excludeDirs = ['.git', 'vendor', 'node_modules', 'build', 'dist', '.claude'];
        // Build the generic VERSION: pattern — prefix-aware if configured
        if (!empty($versionPrefix)) {
            $prefixPatternGeneric = preg_quote($versionPrefix, '/');
            $versionPattern = '/(' . $prefixPatternGeneric . ')\d{2}\.\d{2}\.\d{2}/m';
        } else {
            $versionPattern = '/(VERSION:\s*)\d{2}\.\d{2}\.\d{2}/m';
        }
        $directory = new RecursiveDirectoryIterator($root, RecursiveDirectoryIterator::SKIP_DOTS);
        $filter = new RecursiveCallbackFilterIterator($directory, function ($current, $key, $iterator) use ($excludeDirs) {
            if ($current->isDir() && in_array($current->getFilename(), $excludeDirs, true)) {
                return false;
            } return true;
        });
        $iterator = new RecursiveIteratorIterator($filter);
        $genericUpdated = [];
        foreach ($iterator as $fileInfo) {
            if ($fileInfo->isDir()) {
                continue;
            }
            $ext = strtolower($fileInfo->getExtension());
            if (!in_array($ext, $scanExtensions, true)) {
                continue;
            }
            $filePath = $fileInfo->getPathname();
            $relPath = str_replace([$root . '/', $root . '\\'], '', $filePath);
            if (in_array($relPath, ['README.md', 'CHANGELOG.md', 'package.json', 'pyproject.toml'], true)) {
                continue;
            }
            if (in_array($relPath, $updatedFiles ?? [], true)) {
                continue;
            }
            if (strpos($relPath, '.mokogitea/manifest.xml') !== false) {
                continue;
            }
            $content = @file_get_contents($filePath);
            if ($content === false) {
                continue;
            }
            if (preg_match('/^#\s*REPO:\s*https?:\/\//m', $content)) {
                continue;
            }
            $updated = preg_replace($versionPattern, '${1}' . $newBase, $content);
            if ($updated !== null && $updated !== $content) {
                file_put_contents($filePath, $updated);
                $genericUpdated[] = $relPath;
            }
        }
        if (!empty($genericUpdated)) {
            fwrite(STDERR, "Updated VERSION: in " . count($genericUpdated) . " file(s): " . implode(', ', $genericUpdated) . "\n");
        }
        echo "{$old} -> {$newFull}\n";
        return 0;
    }

    /**
     * Scan git release tags for the highest version across all channels.
     *
     * Checks release names like "MokoSuiteClient (VERSION: 02.45.00)" in
     * git tags (stable, release-candidate, development, etc.) to find the
     * highest version that has been released on any channel.
     */
    private function getHighestGitTagVersion(string $root): ?string
    {
        $highest = null;

        // Method 1: Parse version from git tag annotations / release commit messages
        $output = [];
        exec("cd " . escapeshellarg($root) . " && git log --all --oneline --grep='chore(version)' --grep='chore(release)' --format='%s' -20 2>/dev/null", $output);

        foreach ($output as $line) {
            if (preg_match('/(\d{2}\.\d{2}\.\d{2})/', $line, $m)) {
                $v = preg_replace('/-(?:dev|alpha|beta|rc)$/', '', $m[1]);
                if ($highest === null || version_compare($v, $highest, '>')) {
                    $highest = $v;
                }
            }
        }

        // Method 2: Check version in remote branches' manifest files
        $branches = ['origin/main', 'origin/rc', 'origin/dev'];
        $manifestPaths = ['source/pkg_*.xml', 'pkg_*.xml'];

        foreach ($branches as $branch) {
            foreach ($manifestPaths as $pattern) {
                $files = [];
                exec("cd " . escapeshellarg($root) . " && git ls-tree --name-only {$branch} -- '{$pattern}' 2>/dev/null", $files);

                foreach ($files as $file) {
                    $content = shell_exec("cd " . escapeshellarg($root) . " && git show {$branch}:{$file} 2>/dev/null");
                    if ($content && preg_match('#<version>(\d{2}\.\d{2}\.\d{2})(?:-(?:dev|alpha|beta|rc))?</version>#', $content, $m)) {
                        $v = $m[1];
                        if ($highest === null || version_compare($v, $highest, '>')) {
                            $highest = $v;
                        }
                    }
                }
            }
        }

        return $highest;
    }
}

$app = new VersionBumpCli();
exit($app->execute());