moko-platform/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
 * DEFGROUP: moko-platform.CLI
 * INGROUP: moko-platform
 * REPO: https://git.mokoconsulting.tech/MokoConsulting/moko-platform
 * PATH: /cli/version_bump.php
 * BRIEF: Auto-increment version — manifest.xml is canonical, cascades to all XML and MD files
 */

declare(strict_types=1);

$path = '.';
$type = 'patch'; // patch | minor | major
foreach ($argv as $i => $arg) {
    if ($arg === '--path' && isset($argv[$i + 1])) $path = $argv[$i + 1];
    if ($arg === '--minor') $type = 'minor';
    if ($arg === '--major') $type = 'major';
}

$root = realpath($path) ?: $path;

// -- 1. Read version from .mokogitea/manifest.xml (canonical) --
$mokoVersion = null;
$mokoSuffix = '';
$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];
        $mokoSuffix = isset($m[2]) ? $m[2] : '';
    }
}

// -- 2. Fallback: README.md --
$readmeVersion = null;
$readme = "{$root}/README.md";
$readmeContent = '';
if (file_exists($readme)) {
    $readmeContent = file_get_contents($readme);
    if (preg_match('/VERSION:\s*(\d{2}\.\d{2}\.\d{2})/m', $readmeContent, $m)) {
        $readmeVersion = $m[1];
    }
}

// -- 3. Fallback: Joomla manifest XML --
$manifestVersion = null;
$manifestSuffix = '';
$manifestFiles = array_merge(
    glob("{$root}/src/pkg_*.xml") ?: [],
    glob("{$root}/src/*.xml") ?: [],
    glob("{$root}/src/packages/*/mokowaas.xml") ?: [],
    glob("{$root}/src/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 (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;
            // Preserve the suffix from the manifest (e.g. dev, rc) — strip leading dash
            $manifestSuffix = ltrim($xm[2] ?? '', '-');
        }
    }
}

// -- Use the highest version as base --
$baseVersion = null;
$candidates = array_filter([$mokoVersion, $readmeVersion, $manifestVersion]);
foreach ($candidates as $v) {
    if ($baseVersion === null || version_compare($v, $baseVersion, '>')) {
        $baseVersion = $v;
    }
}

if ($baseVersion === null) {
    fwrite(STDERR, "No version found in manifest.xml, README.md, or Joomla XML\n");
    exit(1);
}

// -- Parse and bump --
if (!preg_match('/^(\d{2})\.(\d{2})\.(\d{2})$/', $baseVersion, $parts)) {
    fwrite(STDERR, "Invalid version format: {$baseVersion}\n");
    exit(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;
}

$new = sprintf('%02d.%02d.%02d', $major, $minor, $patch);

// -- Write clean version (no suffix) ------------------------------------------
// Suffixes (-dev, -alpha, -beta, -rc) are managed by version_set_platform.php
// called from CI workflows with the appropriate --stability flag. version_bump
// always writes a clean base version so the suffix layer stays consistent.
$newFull = $new;

// -- Update .mokogitea/manifest.xml (canonical — preserves suffix) --
if (file_exists($mokoManifest) && !empty($mokoContent)) {
    $updated = preg_replace(
        '#<version>\d{2}\.\d{2}\.\d{2}(?:(?:-(?:dev|alpha|beta|rc))+)?</version>#',
        "<version>{$newFull}</version>",
        $mokoContent,
        1
    );
    if ($updated !== null) {
        file_put_contents($mokoManifest, $updated);
    }
}

// -- Update README.md --
if (file_exists($readme) && !empty($readmeContent)) {
    $updated = preg_replace(
        '/(VERSION:\s*)\d{2}\.\d{2}\.\d{2}(?:(?:-(?:dev|alpha|beta|rc))+)?/m',
        '${1}' . $newFull,
        $readmeContent,
        1
    );
    if ($updated !== null) {
        file_put_contents($readme, $updated);
    }
}

// -- Cascade to ALL Joomla extension XML manifests --
$xmlPatterns = [
    "{$root}/src/pkg_*.xml",
    "{$root}/src/*.xml",
    "{$root}/src/packages/*/*.xml",
    "{$root}/*.xml",
];

$updatedFiles = [];
foreach ($xmlPatterns as $pattern) {
    foreach (glob($pattern) ?: [] as $xmlFile) {
        $content = file_get_contents($xmlFile);
        // Only update files that have an <extension> tag (Joomla manifests)
        if (strpos($content, '<extension') === false) {
            continue;
        }
        $newContent = preg_replace(
            '#<version>\d{2}\.\d{2}\.\d{2}(?:(?:-(?:dev|alpha|beta|rc))+)?</version>#',
            "<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");
}

// -- Update package.json (Node.js / MCP) --
$packageJsonFile = "{$root}/package.json";
if (file_exists($packageJsonFile)) {
    $pkgContent = file_get_contents($packageJsonFile);
    $updatedPkg = preg_replace(
        '/("version"\s*:\s*")\d{2}\.\d{2}\.\d{2}(?:(?:-(?:dev|alpha|beta|rc))+)?(")/m',
        '${1}' . $newFull . '${2}',
        $pkgContent
    );
    if ($updatedPkg !== $pkgContent) {
        file_put_contents($packageJsonFile, $updatedPkg);
        fwrite(STDERR, "Updated package.json\n");
    }
}

// -- Update pyproject.toml (Python) --
$pyprojectFile = "{$root}/pyproject.toml";
if (file_exists($pyprojectFile)) {
    $pyContent = file_get_contents($pyprojectFile);
    $updatedPy = preg_replace(
        '/^(version\s*=\s*")\d{2}\.\d{2}\.\d{2}(?:(?:-(?:dev|alpha|beta|rc))+)?(")/m',
        '${1}' . $newFull . '${2}',
        $pyContent
    );
    if ($updatedPy !== $pyContent) {
        file_put_contents($pyprojectFile, $updatedPy);
        fwrite(STDERR, "Updated pyproject.toml\n");
    }
}

// -- Update CHANGELOG.md --
$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}' . $newFull,
        $clContent
    );
    if ($updatedCl !== null && $updatedCl !== $clContent) {
        file_put_contents($changelogFile, $updatedCl);
        fwrite(STDERR, "Updated CHANGELOG.md\n");
    }
}

// -- Generic VERSION: pattern scan across all text files --
$scanExtensions = ['php', 'yml', 'yaml', 'md', 'txt', 'xml', 'sh', 'toml', 'ini', 'css', 'js'];
$excludeDirs = ['.git', 'vendor', 'node_modules', 'build', 'dist', '.claude'];
$versionPattern = '/(VERSION:\s*)\d{2}\.\d{2}\.\d{2}(?:(?:-(?:dev|alpha|beta|rc))+)?/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();

    // Skip files already handled above
    $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;
    }

    // Skip synced files — they have their own version managed by their source repo
    if (preg_match('/^#\s*REPO:\s*https?:\/\//m', $content)) {
        continue;
    }

    $updated = preg_replace($versionPattern, '${1}' . $newFull, $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";
exit(0);