docs: update for consolidated Joomla template repo
- Update WORKFLOW_STANDARDS.md to reference MokoStandards-Template-Joomla - Remove 6 obsolete sync definitions for deleted individual template repos - Update sync commands to use unified template Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
Jonathan Miller
+61
-1
@@ -1 +1,61 @@
|
||||
platform: default-repository
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!--
|
||||
MokoStandards Repository Manifest
|
||||
This file is managed by MokoStandards bulk sync.
|
||||
Manual edits to <governance> and <last-synced> may be overwritten.
|
||||
See: docs/standards/mokostandards-file-spec.md
|
||||
-->
|
||||
<mokostandards xmlns="https://standards.mokoconsulting.tech/mokostandards/1.0"
|
||||
schema-version="1.0">
|
||||
|
||||
<identity>
|
||||
<name>MokoStandards-API</name>
|
||||
<org>MokoConsulting</org>
|
||||
<description>MokoStandards Enterprise API — PHP implementation (Composer package: mokoconsulting-tech/enterprise)</description>
|
||||
<license spdx="GPL-3.0-or-later">GNU General Public License v3</license>
|
||||
<topics>
|
||||
<topic>coding</topic>
|
||||
<topic>standards</topic>
|
||||
</topics>
|
||||
</identity>
|
||||
|
||||
<governance>
|
||||
<platform>standards-repository</platform>
|
||||
<standards-version>04.07.00</standards-version>
|
||||
<standards-source>https://git.mokoconsulting.tech/MokoConsulting/MokoStandards</standards-source>
|
||||
</governance>
|
||||
|
||||
<build>
|
||||
<language>PHP</language>
|
||||
<runtime>php:>=8.1</runtime>
|
||||
<package-type>composer</package-type>
|
||||
<entry-point>bin/moko-enterprise</entry-point>
|
||||
<dependencies>
|
||||
<requires name="php" version=">=8.1" type="runtime" />
|
||||
</dependencies>
|
||||
</build>
|
||||
|
||||
<scripts>
|
||||
<script name="sync" phase="release">
|
||||
<command>php automation/bulk_sync.php --org MokoConsulting</command>
|
||||
<description>Bulk sync standards to all governed repositories</description>
|
||||
<runner>php</runner>
|
||||
</script>
|
||||
<script name="enforce-tags" phase="release">
|
||||
<command>bash automation/enforce_tags.sh</command>
|
||||
<description>Enforce standard release channel tags on all repos</description>
|
||||
<runner>bash</runner>
|
||||
</script>
|
||||
<script name="validate" phase="validate">
|
||||
<command>vendor/bin/moko-validate</command>
|
||||
<description>Validate MokoStandards compliance locally</description>
|
||||
<runner>composer</runner>
|
||||
</script>
|
||||
<script name="test" phase="test">
|
||||
<command>vendor/bin/phpunit</command>
|
||||
<description>Run PHPUnit test suite</description>
|
||||
<runner>composer</runner>
|
||||
</script>
|
||||
</scripts>
|
||||
|
||||
</mokostandards>
|
||||
|
||||
@@ -0,0 +1,308 @@
|
||||
#!/usr/bin/env php
|
||||
<?php
|
||||
/**
|
||||
* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
|
||||
* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* Enrich XML .mokostandards manifests with repo-specific build, deploy, and script details.
|
||||
*
|
||||
* Runs AFTER push_mokostandards_xml.php. Clones each repo, inspects its contents,
|
||||
* and updates the manifest with discovered build/deploy/scripts config.
|
||||
*
|
||||
* Usage:
|
||||
* php automation/enrich_mokostandards_xml.php [--dry-run] [--repo NAME] [--skip NAME,NAME]
|
||||
*
|
||||
* Note: This script uses proc_open for shell commands. All arguments are escaped
|
||||
* via escapeshellarg(). No user-supplied input reaches the shell unescaped.
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
require_once __DIR__ . '/../vendor/autoload.php';
|
||||
|
||||
use MokoEnterprise\MokoStandardsParser;
|
||||
|
||||
$giteaUrl = rtrim(getenv('GITEA_URL') ?: 'https://git.mokoconsulting.tech', '/');
|
||||
$giteaOrg = getenv('GITEA_ORG') ?: 'MokoConsulting';
|
||||
$token = getenv('GA_TOKEN') ?: getenv('GH_TOKEN') ?: '';
|
||||
|
||||
$dryRun = in_array('--dry-run', $argv, true);
|
||||
$repoFilter = null;
|
||||
$skipRepos = [];
|
||||
foreach ($argv as $i => $arg) {
|
||||
if ($arg === '--repo' && isset($argv[$i + 1])) $repoFilter = $argv[$i + 1];
|
||||
if ($arg === '--skip' && isset($argv[$i + 1])) $skipRepos = array_map('trim', explode(',', $argv[$i + 1]));
|
||||
}
|
||||
|
||||
$parser = new MokoStandardsParser();
|
||||
$tmpBase = sys_get_temp_dir() . '/moko-enrich-' . getmypid();
|
||||
|
||||
function safeExec(string $command, string $cwd = '.'): array {
|
||||
$proc = proc_open($command, [1 => ['pipe', 'w'], 2 => ['pipe', 'w']], $pipes, $cwd);
|
||||
if (!is_resource($proc)) return [1, "proc_open failed"];
|
||||
$stdout = stream_get_contents($pipes[1]);
|
||||
$stderr = stream_get_contents($pipes[2]);
|
||||
fclose($pipes[1]); fclose($pipes[2]);
|
||||
return [proc_close($proc), trim($stdout . "\n" . $stderr)];
|
||||
}
|
||||
|
||||
function rmTree(string $dir): void {
|
||||
if (!is_dir($dir)) return;
|
||||
$it = new RecursiveDirectoryIterator($dir, FilesystemIterator::SKIP_DOTS);
|
||||
$files = new RecursiveIteratorIterator($it, RecursiveIteratorIterator::CHILD_FIRST);
|
||||
foreach ($files as $file) {
|
||||
if ($file->isDir()) @rmdir($file->getPathname());
|
||||
else { @chmod($file->getPathname(), 0777); @unlink($file->getPathname()); }
|
||||
}
|
||||
@rmdir($dir);
|
||||
}
|
||||
|
||||
function gitCmd(string $workDir, string ...$args): array {
|
||||
$cmd = 'git';
|
||||
foreach ($args as $a) $cmd .= ' ' . escapeshellarg($a);
|
||||
return safeExec($cmd, $workDir);
|
||||
}
|
||||
|
||||
function fetchRepos(string $url, string $org, string $token): array {
|
||||
$repos = []; $page = 1;
|
||||
do {
|
||||
$ch = curl_init("{$url}/api/v1/orgs/{$org}/repos?page={$page}&limit=50");
|
||||
curl_setopt_array($ch, [CURLOPT_RETURNTRANSFER => true, CURLOPT_HTTPHEADER => ["Authorization: token {$token}"], CURLOPT_TIMEOUT => 30]);
|
||||
$body = curl_exec($ch); $code = curl_getinfo($ch, CURLINFO_HTTP_CODE); curl_close($ch);
|
||||
if ($code !== 200) break;
|
||||
$batch = json_decode($body, true); if (empty($batch)) break;
|
||||
$repos = array_merge($repos, $batch); $page++;
|
||||
} while (count($batch) >= 50);
|
||||
return $repos;
|
||||
}
|
||||
|
||||
function inspectRepo(string $workDir, string $platform): array {
|
||||
$enrichment = [];
|
||||
$build = [];
|
||||
|
||||
// Detect entry point
|
||||
if (is_dir("{$workDir}/src")) {
|
||||
foreach (glob("{$workDir}/src/*.xml") ?: [] as $xf) {
|
||||
$c = file_get_contents($xf);
|
||||
if (str_contains($c, '<extension') || str_contains($c, '<install')) {
|
||||
$build['entry_point'] = 'src/' . basename($xf); break;
|
||||
}
|
||||
}
|
||||
foreach (glob("{$workDir}/src/core/modules/mod*.class.php") ?: [] as $mf) {
|
||||
$build['entry_point'] = str_replace("{$workDir}/", '', $mf); break;
|
||||
}
|
||||
}
|
||||
|
||||
// composer.json
|
||||
if (file_exists("{$workDir}/composer.json")) {
|
||||
$composer = json_decode(file_get_contents("{$workDir}/composer.json"), true) ?: [];
|
||||
$phpReq = $composer['require']['php'] ?? null;
|
||||
if ($phpReq) $build['runtime'] = "php:{$phpReq}";
|
||||
|
||||
$deps = [];
|
||||
foreach (['joomla/cms', 'joomla/framework', 'dolibarr/dolibarr'] as $pd) {
|
||||
if (isset($composer['require'][$pd])) $deps[] = ['name' => $pd, 'version' => $composer['require'][$pd], 'type' => 'platform'];
|
||||
}
|
||||
if (isset($composer['require']['mokoconsulting-tech/enterprise']))
|
||||
$deps[] = ['name' => 'mokoconsulting-tech/enterprise', 'version' => $composer['require']['mokoconsulting-tech/enterprise'], 'type' => 'composer'];
|
||||
if (!empty($deps)) $build['dependencies'] = $deps;
|
||||
}
|
||||
|
||||
// Artifact from Makefile
|
||||
if (file_exists("{$workDir}/Makefile")) {
|
||||
$mk = file_get_contents("{$workDir}/Makefile");
|
||||
if (preg_match('/\bdist\/(\S+\.zip)\b/', $mk, $m)) $build['artifact'] = ['format' => 'zip', 'path' => 'dist/', 'filename' => $m[1]];
|
||||
}
|
||||
|
||||
if (!empty($build)) $enrichment['build'] = $build;
|
||||
|
||||
// Deploy targets from workflows
|
||||
$targets = [];
|
||||
$wfDir = is_dir("{$workDir}/.gitea/workflows") ? "{$workDir}/.gitea/workflows" : "{$workDir}/.github/workflows";
|
||||
if (is_dir($wfDir)) {
|
||||
foreach (['deploy-dev', 'deploy-demo', 'deploy-rs'] as $dn) {
|
||||
$wf = "{$wfDir}/{$dn}.yml";
|
||||
if (!file_exists($wf)) continue;
|
||||
$wc = file_get_contents($wf);
|
||||
$t = ['name' => str_replace('deploy-', '', $dn)];
|
||||
if (str_contains($wc, 'sftp') || str_contains($wc, 'SFTP')) $t['method'] = 'sftp';
|
||||
elseif (str_contains($wc, 'rsync')) $t['method'] = 'rsync';
|
||||
if (str_contains($wc, 'src/')) $t['src_dir'] = 'src/';
|
||||
if (preg_match('/branches:\s*\n\s*-\s*["\']?([^"\'}\s]+)/', $wc, $m)) $t['branch'] = $m[1];
|
||||
$targets[] = $t;
|
||||
}
|
||||
}
|
||||
if (!empty($targets)) $enrichment['deploy'] = $targets;
|
||||
|
||||
// Scripts from Makefile + composer
|
||||
$scripts = [];
|
||||
if (file_exists("{$workDir}/Makefile")) {
|
||||
$mk = file_get_contents("{$workDir}/Makefile");
|
||||
$known = ['build'=>'build','test'=>'test','lint'=>'lint','clean'=>'build','package'=>'build','validate'=>'validate','release'=>'release'];
|
||||
if (preg_match_all('/^([a-zA-Z_-]+)\s*:/m', $mk, $matches)) {
|
||||
foreach ($matches[1] as $tgt) {
|
||||
$tl = strtolower($tgt);
|
||||
if (isset($known[$tl])) $scripts[] = ['name'=>$tl, 'phase'=>$known[$tl], 'command'=>"make {$tgt}", 'desc'=>ucfirst($tl).' via make', 'runner'=>'make'];
|
||||
}
|
||||
}
|
||||
}
|
||||
if (file_exists("{$workDir}/composer.json")) {
|
||||
$composer = json_decode(file_get_contents("{$workDir}/composer.json"), true) ?: [];
|
||||
$km = ['test'=>'test','lint'=>'lint','cs'=>'lint','phpcs'=>'lint','phpstan'=>'lint','validate'=>'validate'];
|
||||
foreach ($composer['scripts'] ?? [] as $sn => $cmd) {
|
||||
$sl = strtolower($sn);
|
||||
foreach ($km as $match => $phase) {
|
||||
if (str_contains($sl, $match)) {
|
||||
$exists = false;
|
||||
foreach ($scripts as $s) { if ($s['name'] === $sl) { $exists = true; break; } }
|
||||
if (!$exists) $scripts[] = ['name'=>$sn, 'phase'=>$phase, 'command'=>"composer run {$sn}", 'desc'=>is_string($cmd)?$cmd:"Run {$sn}", 'runner'=>'composer'];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!empty($scripts)) $enrichment['scripts'] = $scripts;
|
||||
|
||||
return $enrichment;
|
||||
}
|
||||
|
||||
function enrichManifestXml(string $xml, array $enrichment): string {
|
||||
$dom = new DOMDocument('1.0', 'UTF-8');
|
||||
$dom->preserveWhiteSpace = false;
|
||||
$dom->formatOutput = true;
|
||||
if (!$dom->loadXML($xml)) return $xml;
|
||||
|
||||
$ns = MokoStandardsParser::NAMESPACE_URI;
|
||||
$root = $dom->documentElement;
|
||||
|
||||
foreach (['build', 'deploy', 'scripts'] as $tag) {
|
||||
$toRemove = [];
|
||||
$existing = $root->getElementsByTagNameNS($ns, $tag);
|
||||
for ($i = 0; $i < $existing->length; $i++) $toRemove[] = $existing->item($i);
|
||||
foreach ($toRemove as $node) $root->removeChild($node);
|
||||
}
|
||||
|
||||
if (!empty($enrichment['build'])) {
|
||||
$build = $dom->createElementNS($ns, 'build');
|
||||
$b = $enrichment['build'];
|
||||
foreach (['language', 'runtime'] as $f) { if (isset($b[$f])) $build->appendChild($dom->createElementNS($ns, $f, htmlspecialchars($b[$f], ENT_XML1))); }
|
||||
if (isset($b['package_type'])) $build->appendChild($dom->createElementNS($ns, 'package-type', htmlspecialchars($b['package_type'], ENT_XML1)));
|
||||
if (isset($b['entry_point'])) $build->appendChild($dom->createElementNS($ns, 'entry-point', htmlspecialchars($b['entry_point'], ENT_XML1)));
|
||||
if (isset($b['artifact'])) {
|
||||
$art = $dom->createElementNS($ns, 'artifact');
|
||||
foreach (['format','path','filename'] as $af) { if (isset($b['artifact'][$af])) $art->appendChild($dom->createElementNS($ns, $af, htmlspecialchars($b['artifact'][$af], ENT_XML1))); }
|
||||
$build->appendChild($art);
|
||||
}
|
||||
if (isset($b['dependencies'])) {
|
||||
$deps = $dom->createElementNS($ns, 'dependencies');
|
||||
foreach ($b['dependencies'] as $d) {
|
||||
$req = $dom->createElementNS($ns, 'requires', '');
|
||||
$req->setAttribute('name', $d['name']);
|
||||
if (isset($d['version'])) $req->setAttribute('version', $d['version']);
|
||||
if (isset($d['type'])) $req->setAttribute('type', $d['type']);
|
||||
$deps->appendChild($req);
|
||||
}
|
||||
$build->appendChild($deps);
|
||||
}
|
||||
$root->appendChild($build);
|
||||
}
|
||||
|
||||
if (!empty($enrichment['deploy'])) {
|
||||
$deploy = $dom->createElementNS($ns, 'deploy');
|
||||
foreach ($enrichment['deploy'] as $t) {
|
||||
$target = $dom->createElementNS($ns, 'target');
|
||||
$target->setAttribute('name', $t['name']);
|
||||
$target->appendChild($dom->createElementNS($ns, 'host', '${{ secrets.' . strtoupper($t['name']) . '_HOST }}'));
|
||||
$target->appendChild($dom->createElementNS($ns, 'path', '${{ secrets.' . strtoupper($t['name']) . '_PATH }}'));
|
||||
if (isset($t['method'])) $target->appendChild($dom->createElementNS($ns, 'method', $t['method']));
|
||||
if (isset($t['branch'])) $target->appendChild($dom->createElementNS($ns, 'branch', htmlspecialchars($t['branch'], ENT_XML1)));
|
||||
if (isset($t['src_dir'])) $target->appendChild($dom->createElementNS($ns, 'src-dir', htmlspecialchars($t['src_dir'], ENT_XML1)));
|
||||
$deploy->appendChild($target);
|
||||
}
|
||||
$root->appendChild($deploy);
|
||||
}
|
||||
|
||||
if (!empty($enrichment['scripts'])) {
|
||||
$scriptsEl = $dom->createElementNS($ns, 'scripts');
|
||||
foreach ($enrichment['scripts'] as $s) {
|
||||
$script = $dom->createElementNS($ns, 'script');
|
||||
$script->setAttribute('name', $s['name']);
|
||||
if (isset($s['phase'])) $script->setAttribute('phase', $s['phase']);
|
||||
$script->appendChild($dom->createElementNS($ns, 'command', htmlspecialchars($s['command'], ENT_XML1)));
|
||||
if (isset($s['desc'])) $script->appendChild($dom->createElementNS($ns, 'description', htmlspecialchars($s['desc'], ENT_XML1)));
|
||||
if (isset($s['runner'])) $script->appendChild($dom->createElementNS($ns, 'runner', htmlspecialchars($s['runner'], ENT_XML1)));
|
||||
$scriptsEl->appendChild($script);
|
||||
}
|
||||
$root->appendChild($scriptsEl);
|
||||
}
|
||||
|
||||
return $dom->saveXML();
|
||||
}
|
||||
|
||||
// ── Main ─────────────────────────────────────────────────────────────────
|
||||
echo "=== MokoStandards XML Manifest Enrichment ===\n";
|
||||
echo "Mode: " . ($dryRun ? "DRY RUN" : "LIVE") . "\n";
|
||||
if (!empty($skipRepos)) echo "Skipping: " . implode(', ', $skipRepos) . "\n";
|
||||
echo "\n";
|
||||
|
||||
if (empty($token)) { fprintf(STDERR, "ERROR: GA_TOKEN required\n"); exit(1); }
|
||||
|
||||
$repos = fetchRepos($giteaUrl, $giteaOrg, $token);
|
||||
echo "Found " . count($repos) . " repositories\n\n";
|
||||
|
||||
$stats = ['enriched' => 0, 'skipped' => 0, 'failed' => 0];
|
||||
|
||||
foreach ($repos as $repo) {
|
||||
$name = $repo['name'];
|
||||
if ($repoFilter && $name !== $repoFilter) continue;
|
||||
if (in_array($name, $skipRepos, true)) { echo " {$name} ... SKIP (excluded)\n"; $stats['skipped']++; continue; }
|
||||
if ($repo['archived'] ?? false) { $stats['skipped']++; continue; }
|
||||
|
||||
$defaultBranch = $repo['default_branch'] ?? 'main';
|
||||
$httpsUrl = $repo['clone_url'] ?? "{$giteaUrl}/{$giteaOrg}/{$name}.git";
|
||||
$authedUrl = preg_replace('#^https://#', "https://gitea-actions:{$token}@", $httpsUrl);
|
||||
|
||||
echo " {$name} ... ";
|
||||
|
||||
$workDir = "{$tmpBase}/{$name}";
|
||||
@mkdir($workDir, 0755, true);
|
||||
[$ret] = safeExec('git clone --depth 1 --branch ' . escapeshellarg($defaultBranch) . ' ' . escapeshellarg($authedUrl) . ' ' . escapeshellarg($workDir));
|
||||
if ($ret !== 0) { echo "FAIL (clone)\n"; $stats['failed']++; continue; }
|
||||
|
||||
$manifestPath = "{$workDir}/.gitea/.mokostandards";
|
||||
if (!file_exists($manifestPath) || !str_contains(file_get_contents($manifestPath), '<mokostandards')) {
|
||||
echo "SKIP (no XML manifest)\n"; $stats['skipped']++; rmTree($workDir); continue;
|
||||
}
|
||||
|
||||
$existingXml = file_get_contents($manifestPath);
|
||||
$platform = $parser->extractPlatform($existingXml) ?? 'default-repository';
|
||||
$enrichment = inspectRepo($workDir, $platform);
|
||||
|
||||
if (!isset($enrichment['build'])) $enrichment['build'] = [];
|
||||
$enrichment['build']['language'] = $enrichment['build']['language'] ?? $repo['language'] ?? MokoStandardsParser::platformLanguage($platform);
|
||||
$enrichment['build']['package_type'] = $enrichment['build']['package_type'] ?? MokoStandardsParser::platformPackageType($platform);
|
||||
|
||||
$enrichedXml = enrichManifestXml($existingXml, $enrichment);
|
||||
$dc = count($enrichment['deploy'] ?? []);
|
||||
$sc = count($enrichment['scripts'] ?? []);
|
||||
$details = "deploy={$dc} scripts={$sc}";
|
||||
|
||||
if ($dryRun) { echo "WOULD ENRICH [{$details}]\n"; $stats['enriched']++; rmTree($workDir); continue; }
|
||||
|
||||
file_put_contents($manifestPath, $enrichedXml);
|
||||
gitCmd($workDir, 'config', 'user.name', 'gitea-actions[bot]');
|
||||
gitCmd($workDir, 'config', 'user.email', 'gitea-actions[bot]@git.mokoconsulting.tech');
|
||||
gitCmd($workDir, 'add', '.gitea/.mokostandards');
|
||||
|
||||
[$cr, $co] = gitCmd($workDir, 'commit', '-m', "chore: enrich .mokostandards with build/deploy/scripts\n\nAuto-detected: {$details}");
|
||||
if ($cr !== 0) { echo "SKIP (no diff)\n"; $stats['skipped']++; rmTree($workDir); continue; }
|
||||
|
||||
[$pr] = gitCmd($workDir, 'push', 'origin', $defaultBranch);
|
||||
if ($pr !== 0) { echo "FAIL (push)\n"; $stats['failed']++; }
|
||||
else { echo "ENRICHED [{$details}]\n"; $stats['enriched']++; }
|
||||
|
||||
rmTree($workDir);
|
||||
}
|
||||
|
||||
@rmdir($tmpBase);
|
||||
echo "\n=== Summary ===\nEnriched: {$stats['enriched']}\nSkipped: {$stats['skipped']}\nFailed: {$stats['failed']}\n";
|
||||
@@ -0,0 +1,308 @@
|
||||
#!/usr/bin/env php
|
||||
<?php
|
||||
/**
|
||||
* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
|
||||
* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* Push XML .mokostandards manifest to all governed repositories.
|
||||
*
|
||||
* Uses git SSH to bypass the Gitea reverse-proxy WAF that blocks
|
||||
* API requests to paths containing ".gitea".
|
||||
*
|
||||
* Usage:
|
||||
* php automation/push_mokostandards_xml.php [--dry-run] [--repo NAME] [--force]
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
require_once __DIR__ . '/../vendor/autoload.php';
|
||||
|
||||
use MokoEnterprise\MokoStandardsParser;
|
||||
|
||||
// ── Configuration ────────────────────────────────────────────────────────
|
||||
$giteaUrl = rtrim(getenv('GITEA_URL') ?: 'https://git.mokoconsulting.tech', '/');
|
||||
$giteaOrg = getenv('GITEA_ORG') ?: 'MokoConsulting';
|
||||
$token = getenv('GA_TOKEN') ?: getenv('GH_TOKEN') ?: '';
|
||||
$sshBase = 'ssh://gitea@git.mokoconsulting.tech:2222';
|
||||
|
||||
// ── CLI args ─────────────────────────────────────────────────────────────
|
||||
$dryRun = in_array('--dry-run', $argv, true);
|
||||
$force = in_array('--force', $argv, true);
|
||||
$repoFilter = null;
|
||||
$skipRepos = [];
|
||||
foreach ($argv as $i => $arg) {
|
||||
if ($arg === '--repo' && isset($argv[$i + 1])) {
|
||||
$repoFilter = $argv[$i + 1];
|
||||
}
|
||||
if ($arg === '--skip' && isset($argv[$i + 1])) {
|
||||
$skipRepos = array_map('trim', explode(',', $argv[$i + 1]));
|
||||
}
|
||||
}
|
||||
|
||||
$parser = new MokoStandardsParser();
|
||||
$tmpBase = sys_get_temp_dir() . '/moko-manifest-push-' . getmypid();
|
||||
|
||||
// ── Platform detection heuristics (mirrors RepositorySynchronizer) ───────
|
||||
$CRM_PLATFORM_REPOS = ['MokoDolibarr', 'MokoDoliMods'];
|
||||
|
||||
function detectPlatform(array $repo): string {
|
||||
global $CRM_PLATFORM_REPOS;
|
||||
$name = $repo['name'] ?? '';
|
||||
$nameLower = strtolower($name);
|
||||
$description = strtolower($repo['description'] ?? '');
|
||||
$topics = $repo['topics'] ?? [];
|
||||
|
||||
if (in_array($name, $CRM_PLATFORM_REPOS, true)) return 'crm-platform';
|
||||
if (in_array('dolibarr-platform', $topics)) return 'crm-platform';
|
||||
if (in_array('joomla-template', $topics)) return 'joomla-template';
|
||||
if (in_array('joomla', $topics) || in_array('joomla-extension', $topics)) return 'waas-component';
|
||||
if (in_array('dolibarr', $topics) || in_array('dolibarr-module', $topics)) return 'crm-module';
|
||||
|
||||
if (str_contains($nameLower, 'template') && (str_contains($nameLower, 'joomla') || str_contains($nameLower, 'tpl'))) return 'joomla-template';
|
||||
if (str_contains($nameLower, 'joomla') || str_contains($nameLower, 'waas')) return 'waas-component';
|
||||
if (str_contains($nameLower, 'doli') || str_contains($nameLower, 'crm')) return 'crm-module';
|
||||
|
||||
if (str_contains($description, 'joomla template')) return 'joomla-template';
|
||||
if (str_contains($description, 'joomla') || str_contains($description, 'component')) return 'waas-component';
|
||||
if (str_contains($description, 'dolibarr') || str_contains($description, 'module')) return 'crm-module';
|
||||
|
||||
if (str_contains($nameLower, 'standard')) return 'standards-repository';
|
||||
return 'default-repository';
|
||||
}
|
||||
|
||||
/**
|
||||
* Safe shell execution — uses proc_open with explicit arguments to avoid injection.
|
||||
* @return array{int, string}
|
||||
*/
|
||||
function safeExec(string $command, string $cwd = '.'): array {
|
||||
$proc = proc_open(
|
||||
$command,
|
||||
[1 => ['pipe', 'w'], 2 => ['pipe', 'w']],
|
||||
$pipes,
|
||||
$cwd
|
||||
);
|
||||
if (!is_resource($proc)) {
|
||||
return [1, "proc_open failed for: {$command}"];
|
||||
}
|
||||
$stdout = stream_get_contents($pipes[1]);
|
||||
$stderr = stream_get_contents($pipes[2]);
|
||||
fclose($pipes[1]);
|
||||
fclose($pipes[2]);
|
||||
$code = proc_close($proc);
|
||||
return [$code, trim($stdout . "\n" . $stderr)];
|
||||
}
|
||||
|
||||
/** Recursively remove a directory (cross-platform). */
|
||||
function rmTree(string $dir): void {
|
||||
if (!is_dir($dir)) return;
|
||||
$it = new RecursiveDirectoryIterator($dir, FilesystemIterator::SKIP_DOTS);
|
||||
$files = new RecursiveIteratorIterator($it, RecursiveIteratorIterator::CHILD_FIRST);
|
||||
foreach ($files as $file) {
|
||||
if ($file->isDir()) {
|
||||
@rmdir($file->getPathname());
|
||||
} else {
|
||||
// Clear read-only flag (git objects on Windows)
|
||||
@chmod($file->getPathname(), 0777);
|
||||
@unlink($file->getPathname());
|
||||
}
|
||||
}
|
||||
@rmdir($dir);
|
||||
}
|
||||
|
||||
/**
|
||||
* Run a git command safely in a given working directory.
|
||||
* @return array{int, string}
|
||||
*/
|
||||
function gitCmd(string $workDir, string ...$args): array {
|
||||
$cmd = 'git';
|
||||
foreach ($args as $a) {
|
||||
$cmd .= ' ' . escapeshellarg($a);
|
||||
}
|
||||
return safeExec($cmd, $workDir);
|
||||
}
|
||||
|
||||
// ── Fetch all repos via API ──────────────────────────────────────────────
|
||||
function fetchRepos(string $url, string $org, string $token): array {
|
||||
$repos = [];
|
||||
$page = 1;
|
||||
do {
|
||||
$ch = curl_init("{$url}/api/v1/orgs/{$org}/repos?page={$page}&limit=50");
|
||||
curl_setopt_array($ch, [
|
||||
CURLOPT_RETURNTRANSFER => true,
|
||||
CURLOPT_HTTPHEADER => ["Authorization: token {$token}"],
|
||||
CURLOPT_TIMEOUT => 30,
|
||||
]);
|
||||
$body = curl_exec($ch);
|
||||
$code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
|
||||
curl_close($ch);
|
||||
|
||||
if ($code !== 200) {
|
||||
fprintf(STDERR, "API error (HTTP %d) fetching repos page %d\n", $code, $page);
|
||||
break;
|
||||
}
|
||||
|
||||
$batch = json_decode($body, true);
|
||||
if (empty($batch)) break;
|
||||
$repos = array_merge($repos, $batch);
|
||||
$page++;
|
||||
} while (count($batch) >= 50);
|
||||
|
||||
return $repos;
|
||||
}
|
||||
|
||||
// ── Main ─────────────────────────────────────────────────────────────────
|
||||
echo "=== MokoStandards XML Manifest Push ===\n";
|
||||
echo "Org: {$giteaOrg}\n";
|
||||
echo "Mode: " . ($dryRun ? "DRY RUN" : "LIVE") . "\n";
|
||||
if ($repoFilter) echo "Filter: {$repoFilter}\n";
|
||||
echo "\n";
|
||||
|
||||
if (empty($token)) {
|
||||
fprintf(STDERR, "ERROR: GA_TOKEN or GH_TOKEN environment variable required\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
$repos = fetchRepos($giteaUrl, $giteaOrg, $token);
|
||||
echo "Found " . count($repos) . " repositories\n\n";
|
||||
|
||||
$stats = ['created' => 0, 'updated' => 0, 'skipped' => 0, 'failed' => 0];
|
||||
|
||||
foreach ($repos as $repo) {
|
||||
$name = $repo['name'];
|
||||
if ($repoFilter && $name !== $repoFilter) continue;
|
||||
if (in_array($name, $skipRepos, true)) {
|
||||
echo " SKIP {$name} (excluded)\n";
|
||||
$stats['skipped']++;
|
||||
continue;
|
||||
}
|
||||
if ($repo['archived'] ?? false) {
|
||||
echo " SKIP {$name} (archived)\n";
|
||||
$stats['skipped']++;
|
||||
continue;
|
||||
}
|
||||
|
||||
$platform = detectPlatform($repo);
|
||||
$defaultBranch = $repo['default_branch'] ?? 'main';
|
||||
// Prefer HTTPS with token (SSH port 2222 may be blocked); fall back to SSH
|
||||
$httpsUrl = $repo['clone_url'] ?? "{$giteaUrl}/{$giteaOrg}/{$name}.git";
|
||||
// Embed token in HTTPS URL for push auth
|
||||
$authedUrl = preg_replace('#^https://#', "https://gitea-actions:{$token}@", $httpsUrl);
|
||||
|
||||
echo " {$name} [{$platform}] ... ";
|
||||
|
||||
// Generate XML manifest
|
||||
$xmlContent = $parser->generate([
|
||||
'name' => $name,
|
||||
'org' => $giteaOrg,
|
||||
'platform' => $platform,
|
||||
'standards_version' => '04.07.00',
|
||||
'description' => $repo['description'] ?? '',
|
||||
'license' => 'GPL-3.0-or-later',
|
||||
'topics' => $repo['topics'] ?? [],
|
||||
'language' => $repo['language'] ?? MokoStandardsParser::platformLanguage($platform),
|
||||
'package_type' => MokoStandardsParser::platformPackageType($platform),
|
||||
'last_synced' => date('c'),
|
||||
]);
|
||||
|
||||
if ($dryRun) {
|
||||
echo "WOULD WRITE ({$platform})\n";
|
||||
$stats['created']++;
|
||||
continue;
|
||||
}
|
||||
|
||||
// Clone shallow via HTTPS (token-authed)
|
||||
$workDir = "{$tmpBase}/{$name}";
|
||||
@mkdir($workDir, 0755, true);
|
||||
|
||||
[$ret, $out] = safeExec(
|
||||
'git clone --depth 1 --branch ' . escapeshellarg($defaultBranch) . ' '
|
||||
. escapeshellarg($authedUrl) . ' ' . escapeshellarg($workDir)
|
||||
);
|
||||
if ($ret !== 0) {
|
||||
echo "FAIL (clone)\n";
|
||||
fprintf(STDERR, " %s\n", $out);
|
||||
$stats['failed']++;
|
||||
continue;
|
||||
}
|
||||
|
||||
// Check if already XML and up-to-date
|
||||
$manifestPath = "{$workDir}/.gitea/.mokostandards";
|
||||
$existingIsXml = file_exists($manifestPath) && str_contains(file_get_contents($manifestPath), '<mokostandards');
|
||||
if ($existingIsXml && !$force) {
|
||||
$existingPlatform = $parser->extractPlatform(file_get_contents($manifestPath));
|
||||
if ($existingPlatform === $platform) {
|
||||
echo "SKIP (already XML)\n";
|
||||
$stats['skipped']++;
|
||||
rmTree($workDir);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// Write manifest
|
||||
@mkdir("{$workDir}/.gitea", 0755, true);
|
||||
file_put_contents($manifestPath, $xmlContent);
|
||||
|
||||
// Delete legacy files if present
|
||||
$legacyDeleted = [];
|
||||
foreach (['.mokostandards', '.github/.mokostandards'] as $legacy) {
|
||||
$legacyPath = "{$workDir}/{$legacy}";
|
||||
if (file_exists($legacyPath)) {
|
||||
unlink($legacyPath);
|
||||
$legacyDeleted[] = $legacy;
|
||||
}
|
||||
}
|
||||
|
||||
// Commit
|
||||
$isNew = !$existingIsXml;
|
||||
$commitMsg = $isNew
|
||||
? 'chore: add XML .mokostandards manifest'
|
||||
: 'chore: update .mokostandards to XML format';
|
||||
if (!empty($legacyDeleted)) {
|
||||
$commitMsg .= "\n\nRemoved legacy: " . implode(', ', $legacyDeleted);
|
||||
}
|
||||
|
||||
gitCmd($workDir, 'config', 'user.name', 'gitea-actions[bot]');
|
||||
gitCmd($workDir, 'config', 'user.email', 'gitea-actions[bot]@git.mokoconsulting.tech');
|
||||
gitCmd($workDir, 'add', '.gitea/.mokostandards');
|
||||
foreach ($legacyDeleted as $lf) {
|
||||
gitCmd($workDir, 'add', $lf);
|
||||
}
|
||||
|
||||
[$commitRet, $commitOut] = gitCmd($workDir, 'commit', '-m', $commitMsg);
|
||||
if ($commitRet !== 0 && str_contains($commitOut, 'nothing to commit')) {
|
||||
echo "SKIP (no changes)\n";
|
||||
$stats['skipped']++;
|
||||
rmTree($workDir);
|
||||
continue;
|
||||
}
|
||||
if ($commitRet !== 0) {
|
||||
echo "FAIL (commit)\n";
|
||||
fprintf(STDERR, " %s\n", $commitOut);
|
||||
$stats['failed']++;
|
||||
rmTree($workDir);
|
||||
continue;
|
||||
}
|
||||
|
||||
[$pushRet, $pushOut] = gitCmd($workDir, 'push', 'origin', $defaultBranch);
|
||||
if ($pushRet !== 0) {
|
||||
echo "FAIL (push)\n";
|
||||
fprintf(STDERR, " %s\n", $pushOut);
|
||||
$stats['failed']++;
|
||||
} else {
|
||||
$action = $isNew ? 'CREATED' : 'UPDATED';
|
||||
echo "{$action}\n";
|
||||
$stats[$isNew ? 'created' : 'updated']++;
|
||||
}
|
||||
|
||||
// Cleanup
|
||||
rmTree($workDir);
|
||||
}
|
||||
|
||||
// Cleanup tmp base
|
||||
@rmdir($tmpBase);
|
||||
|
||||
echo "\n=== Summary ===\n";
|
||||
echo "Created: {$stats['created']}\n";
|
||||
echo "Updated: {$stats['updated']}\n";
|
||||
echo "Skipped: {$stats['skipped']}\n";
|
||||
echo "Failed: {$stats['failed']}\n";
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -7,14 +7,23 @@
|
||||
```
|
||||
Template Repos (canonical source) → Production Repos (synced copies)
|
||||
───────────────────────────────────── ──────────────────────────────────
|
||||
MokoStandards-Template-Joomla-* → MokoOnyx, MokoCassiopeia, MokoJGDPC, etc.
|
||||
MokoStandards-Template-Joomla → MokoOnyx, MokoCassiopeia, MokoJGDPC, etc.
|
||||
MokoStandards-Template-Dolibarr → MokoCRM, MokoDoliForm, MokoDoliAuth, etc.
|
||||
MokoStandards-Template-Generic → MokoISOUpdatePortable, etc.
|
||||
MokoStandards-Template-Client → client-*, etc.
|
||||
MokoStandards-Template-Client → client-clarksvillefurs, client-kiddieland
|
||||
```
|
||||
|
||||
**MokoOnyx** is the living reference implementation for Joomla workflows. Template repos are the canonical source for distribution. The MokoStandards-API repo does NOT store workflow templates — it only has `bulk-repo-sync.yml` for its own CI.
|
||||
|
||||
## Template Repos
|
||||
|
||||
| Repo | Purpose | Types |
|
||||
|------|---------|-------|
|
||||
| `MokoStandards-Template-Joomla` | All Joomla extension types in one repo | plugin, template, module, component, package, library |
|
||||
| `MokoStandards-Template-Dolibarr` | Dolibarr module scaffold | — |
|
||||
| `MokoStandards-Template-Generic` | Non-platform projects | — |
|
||||
| `MokoStandards-Template-Client` | Client Joomla sites with media sync | — |
|
||||
|
||||
## Standard Workflow Suite
|
||||
|
||||
### Joomla Repositories (10 workflows)
|
||||
@@ -104,16 +113,16 @@ These secrets and variables are set at the MokoConsulting org level and availabl
|
||||
To update workflows across all repos from the canonical template:
|
||||
|
||||
```bash
|
||||
# Joomla repos — sync from MokoOnyx
|
||||
for REPO in MokoOnyx MokoCassiopeia MokoJGDPC MokoJoomHero ...; do
|
||||
# Joomla repos — sync from unified template
|
||||
for REPO in MokoOnyx MokoCassiopeia MokoJGDPC MokoJoomHero MokoJoomTOS MokoWaaS MokoWaaSAnnounce MokoDPCalendarAPI; do
|
||||
cd /a/$REPO
|
||||
rm -f .gitea/workflows/*.yml
|
||||
cp /a/MokoStandards-Template-Joomla-Plugin/.gitea/workflows/*.yml .gitea/workflows/
|
||||
cp /a/MokoStandards-Template-Joomla/.gitea/workflows/*.yml .gitea/workflows/
|
||||
git add .gitea/workflows/ && git commit -m "chore: sync workflows" && git push
|
||||
done
|
||||
|
||||
# Dolibarr repos — sync from Dolibarr template
|
||||
for REPO in MokoCRM MokoDoliForm MokoDoliAuth ...; do
|
||||
for REPO in MokoCRM MokoDoliForm MokoDoliAuth MokoDolibarr ...; do
|
||||
cd /a/$REPO
|
||||
rm -f .gitea/workflows/*.yml
|
||||
cp /a/MokoStandards-Template-Dolibarr/.gitea/workflows/*.yml .gitea/workflows/
|
||||
@@ -140,5 +149,6 @@ done
|
||||
| 2026-05-02 | Added workflows to all 22 Dolibarr production repos |
|
||||
| 2026-05-02 | Moved canonical source from API repo to template repos |
|
||||
| 2026-05-02 | Added sync-media.yml to Client template (bidirectional SFTP) |
|
||||
| 2026-05-02 | Deployed workflows to 22 Dolibarr production repos |
|
||||
| 2026-05-02 | Deployed workflows to 2 client repos (clarksvillefurs, kiddieland) |
|
||||
| 2026-05-02 | Deployed workflows to client repos (clarksvillefurs, kiddieland) |
|
||||
| 2026-05-02 | Consolidated 6 Joomla template repos → `MokoStandards-Template-Joomla` |
|
||||
| 2026-05-02 | Deleted individual template repos (Plugin, Template, Module, Component, Package, Library) |
|
||||
|
||||
@@ -0,0 +1,243 @@
|
||||
# `.mokostandards` File Specification
|
||||
|
||||
> **Version:** 1.0
|
||||
> **Status:** Active
|
||||
> **Schema:** [`mokostandards-schema.xsd`](mokostandards-schema.xsd)
|
||||
> **Last Updated:** 2026-05-02
|
||||
|
||||
## Overview
|
||||
|
||||
The `.mokostandards` file is the **repository manifest** for every repo governed by [MokoStandards](https://git.mokoconsulting.tech/MokoConsulting/MokoStandards). It lives at `.gitea/.mokostandards` (no file extension) and uses **XML format** internally.
|
||||
|
||||
The file serves three purposes:
|
||||
|
||||
1. **Identity** — declares the repo's name, organization, description, license, and topics.
|
||||
2. **Governance binding** — ties the repo to a specific MokoStandards platform definition, enabling the bulk sync to know which files, workflows, and templates to enforce.
|
||||
3. **Repo-specific configuration** — captures build/deploy targets, automation scripts, and per-repo sync overrides so that tooling (CI, `make`, `composer run`) can operate without guessing.
|
||||
|
||||
## Location
|
||||
|
||||
```
|
||||
.gitea/.mokostandards ← primary (Gitea-hosted repos)
|
||||
```
|
||||
|
||||
Legacy locations (`.mokostandards` at repo root, `.github/.mokostandards`) are auto-migrated by the bulk sync into `.gitea/.mokostandards`.
|
||||
|
||||
## Format
|
||||
|
||||
The file is well-formed XML with no `.xml` extension. It uses the namespace `https://standards.mokoconsulting.tech/mokostandards/1.0` and is validated against `mokostandards-schema.xsd`.
|
||||
|
||||
## Sections
|
||||
|
||||
### `<identity>` — Required
|
||||
|
||||
| Element | Required | Description |
|
||||
|---------------|----------|-------------|
|
||||
| `<name>` | yes | Repository name (e.g. `MokoCRM`) |
|
||||
| `<org>` | yes | Organization slug (e.g. `MokoConsulting`) |
|
||||
| `<description>` | no | Human-readable project description |
|
||||
| `<license>` | no | License name; optional `spdx` attribute for the SPDX identifier |
|
||||
| `<topics>` | no | Container for `<topic>` elements — Gitea/GitHub topics |
|
||||
|
||||
### `<governance>` — Required
|
||||
|
||||
| Element | Required | Description |
|
||||
|----------------------|----------|-------------|
|
||||
| `<platform>` | yes | Platform slug — must match a `definitions/default/*.tf` file. One of: `default-repository`, `crm-module`, `crm-platform`, `generic-repository`, `github-private-repository`, `joomla-template`, `standards-repository`, `waas-component` |
|
||||
| `<standards-version>` | yes | MokoStandards version that last synced this repo (e.g. `04.07.00`) |
|
||||
| `<standards-source>` | yes | URL to the MokoStandards repo |
|
||||
| `<last-synced>` | no | ISO 8601 timestamp of last bulk sync |
|
||||
|
||||
### `<build>` — Optional
|
||||
|
||||
| Element | Required | Description |
|
||||
|-----------------|----------|-------------|
|
||||
| `<language>` | no | Primary language (`PHP`, `JavaScript`, `CSS`, etc.) |
|
||||
| `<runtime>` | no | Runtime version requirement (e.g. `php:>=8.1`) |
|
||||
| `<package-type>`| no | Package format (`composer`, `npm`, `joomla-extension`, `dolibarr-module`) |
|
||||
| `<entry-point>` | no | Main entry file relative to repo root |
|
||||
| `<artifact>` | no | Build output: `<format>`, `<path>`, `<filename>` |
|
||||
| `<dependencies>` | no | Container for `<requires name="" version="" type="">` elements |
|
||||
|
||||
### `<deploy>` — Optional
|
||||
|
||||
Contains one or more `<target>` elements:
|
||||
|
||||
| Attribute/Element | Required | Description |
|
||||
|-------------------|----------|-------------|
|
||||
| `@name` | yes | Target name (`dev`, `demo`, `staging`, `production`) |
|
||||
| `@enabled` | no | Boolean, default `true` |
|
||||
| `<host>` | yes | Hostname or secret reference (e.g. `${{ secrets.DEV_HOST }}`) |
|
||||
| `<path>` | yes | Remote deployment path |
|
||||
| `<method>` | no | One of: `sftp`, `rsync`, `scp`, `composer`, `webhook` |
|
||||
| `<branch>` | no | Branch that triggers this deploy |
|
||||
| `<src-dir>` | no | Local source directory to deploy (default: `src/`) |
|
||||
|
||||
### `<scripts>` — Optional
|
||||
|
||||
Contains one or more `<script>` elements:
|
||||
|
||||
| Attribute/Element | Required | Description |
|
||||
|-------------------|----------|-------------|
|
||||
| `@name` | yes | Script identifier (e.g. `build`, `test`, `lint`, `package`) |
|
||||
| `@phase` | no | Lifecycle phase: `pre-build`, `build`, `post-build`, `test`, `lint`, `pre-deploy`, `post-deploy`, `release`, `validate` |
|
||||
| `<command>` | yes | Shell command to execute |
|
||||
| `<description>` | no | Human-readable purpose |
|
||||
| `<runner>` | no | Execution context (`make`, `composer`, `bash`, `php`) |
|
||||
|
||||
### `<overrides>` — Optional
|
||||
|
||||
Per-repo exceptions to the platform definition:
|
||||
|
||||
| Element | Description |
|
||||
|--------------------|-------------|
|
||||
| `<skip-files>` | `<file>` elements listing paths that bulk sync should NOT overwrite |
|
||||
| `<skip-workflows>` | `<file>` elements listing workflow filenames to skip |
|
||||
| `<extra-secrets>` | `<secret name="" required="" scope="">` for repo-specific secrets beyond the platform default |
|
||||
|
||||
## Minimal Example
|
||||
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<mokostandards xmlns="https://standards.mokoconsulting.tech/mokostandards/1.0"
|
||||
schema-version="1.0">
|
||||
<identity>
|
||||
<name>MokoTesting</name>
|
||||
<org>MokoConsulting</org>
|
||||
</identity>
|
||||
<governance>
|
||||
<platform>default-repository</platform>
|
||||
<standards-version>04.07.00</standards-version>
|
||||
<standards-source>https://git.mokoconsulting.tech/MokoConsulting/MokoStandards</standards-source>
|
||||
</governance>
|
||||
</mokostandards>
|
||||
```
|
||||
|
||||
## Full Example (WaaS Component)
|
||||
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<mokostandards xmlns="https://standards.mokoconsulting.tech/mokostandards/1.0"
|
||||
schema-version="1.0">
|
||||
|
||||
<identity>
|
||||
<name>MokoJoomTOS</name>
|
||||
<org>MokoConsulting</org>
|
||||
<description>A component to present a site's Terms of Service and privacy policy even through offline.</description>
|
||||
<license spdx="GPL-3.0-or-later">GNU General Public License v3</license>
|
||||
<topics>
|
||||
<topic>joomla</topic>
|
||||
<topic>system-plugin</topic>
|
||||
<topic>terms-of-service</topic>
|
||||
<topic>waas</topic>
|
||||
</topics>
|
||||
</identity>
|
||||
|
||||
<governance>
|
||||
<platform>waas-component</platform>
|
||||
<standards-version>04.07.00</standards-version>
|
||||
<standards-source>https://git.mokoconsulting.tech/MokoConsulting/MokoStandards</standards-source>
|
||||
<last-synced>2026-05-01T12:00:00Z</last-synced>
|
||||
</governance>
|
||||
|
||||
<build>
|
||||
<language>PHP</language>
|
||||
<runtime>php:>=8.1</runtime>
|
||||
<package-type>joomla-extension</package-type>
|
||||
<entry-point>src/mokojoomtos.xml</entry-point>
|
||||
<artifact>
|
||||
<format>zip</format>
|
||||
<path>dist/</path>
|
||||
<filename>plg_system_mokojoomtos.zip</filename>
|
||||
</artifact>
|
||||
<dependencies>
|
||||
<requires name="joomla/cms" version=">=5.0" type="platform" />
|
||||
<requires name="mokoconsulting-tech/enterprise" version="*" type="composer" />
|
||||
</dependencies>
|
||||
</build>
|
||||
|
||||
<deploy>
|
||||
<target name="dev" enabled="true">
|
||||
<host>${{ secrets.DEV_HOST }}</host>
|
||||
<path>/var/www/dev/plugins/system/mokojoomtos</path>
|
||||
<method>sftp</method>
|
||||
<branch>dev/**</branch>
|
||||
<src-dir>src/</src-dir>
|
||||
</target>
|
||||
<target name="demo">
|
||||
<host>${{ secrets.DEMO_HOST }}</host>
|
||||
<path>/var/www/demo/plugins/system/mokojoomtos</path>
|
||||
<method>sftp</method>
|
||||
<branch>main</branch>
|
||||
<src-dir>src/</src-dir>
|
||||
</target>
|
||||
</deploy>
|
||||
|
||||
<scripts>
|
||||
<script name="build" phase="build">
|
||||
<command>make build</command>
|
||||
<description>Build the extension zip package</description>
|
||||
<runner>make</runner>
|
||||
</script>
|
||||
<script name="lint" phase="lint">
|
||||
<command>vendor/bin/phpcs --standard=Joomla src/</command>
|
||||
<description>Run PHP_CodeSniffer with Joomla coding standard</description>
|
||||
<runner>composer</runner>
|
||||
</script>
|
||||
<script name="test" phase="test">
|
||||
<command>vendor/bin/phpunit</command>
|
||||
<description>Run PHPUnit test suite</description>
|
||||
<runner>composer</runner>
|
||||
</script>
|
||||
<script name="validate" phase="validate">
|
||||
<command>vendor/bin/moko-validate</command>
|
||||
<description>Validate MokoStandards compliance</description>
|
||||
<runner>composer</runner>
|
||||
</script>
|
||||
</scripts>
|
||||
|
||||
<overrides>
|
||||
<skip-files>
|
||||
<file>composer.json</file>
|
||||
</skip-files>
|
||||
<extra-secrets>
|
||||
<secret name="JOOMLA_API_TOKEN" required="true" scope="repository" />
|
||||
</extra-secrets>
|
||||
</overrides>
|
||||
|
||||
</mokostandards>
|
||||
```
|
||||
|
||||
## Migration from Legacy Format
|
||||
|
||||
The old format was a single YAML-like line:
|
||||
|
||||
```
|
||||
platform: default-repository
|
||||
```
|
||||
|
||||
The bulk sync will:
|
||||
1. Read the legacy value
|
||||
2. Generate a new XML `.mokostandards` with the detected platform
|
||||
3. Commit the replacement file to `.gitea/.mokostandards`
|
||||
4. Delete the old file from legacy locations (root, `.github/`)
|
||||
|
||||
## Validation
|
||||
|
||||
Repos are validated against `mokostandards-schema.xsd` during:
|
||||
- Bulk sync (`automation/bulk_sync.php`)
|
||||
- Standards compliance workflow (`.gitea/workflows/standards-compliance.yml`)
|
||||
- Local validation via `vendor/bin/moko-validate`
|
||||
|
||||
A missing or invalid `.mokostandards` file is a **compliance failure**.
|
||||
|
||||
## Tooling Integration
|
||||
|
||||
| Tool | How it uses `.mokostandards` |
|
||||
|------|------------------------------|
|
||||
| **bulk_sync.php** | Reads `<governance><platform>` to select the correct definition `.tf` file; updates `<last-synced>` on success |
|
||||
| **enforce_tags.sh** | Reads `<identity><name>` for tag naming |
|
||||
| **deploy-*.yml** | Reads `<deploy><target>` for host, path, method |
|
||||
| **Makefile** | Can source `<scripts>` for consistent `make` targets |
|
||||
| **moko-validate** | Validates the XML against the XSD and checks required fields |
|
||||
| **detectPlatform()** | Falls back to name/topic heuristics only when `.mokostandards` is missing or unparseable |
|
||||
@@ -0,0 +1,273 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!--
|
||||
Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
|
||||
SPDX-License-Identifier: GPL-3.0-or-later
|
||||
FILE INFORMATION
|
||||
DEFGROUP: MokoStandards.Schema
|
||||
INGROUP: MokoStandards.Governance
|
||||
REPO: https://git.mokoconsulting.tech/MokoConsulting/MokoStandards-API
|
||||
PATH: /docs/standards/mokostandards-schema.xsd
|
||||
VERSION: 04.07.00
|
||||
BRIEF: XML Schema Definition for the .mokostandards repository manifest file
|
||||
-->
|
||||
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
|
||||
xmlns:moko="https://standards.mokoconsulting.tech/mokostandards/1.0"
|
||||
targetNamespace="https://standards.mokoconsulting.tech/mokostandards/1.0"
|
||||
elementFormDefault="qualified"
|
||||
version="1.0">
|
||||
|
||||
<!-- ════════════════════════════════════════════════════════════════════
|
||||
ROOT ELEMENT
|
||||
════════════════════════════════════════════════════════════════════ -->
|
||||
<xs:element name="mokostandards" type="moko:MokoStandardsType">
|
||||
<xs:annotation>
|
||||
<xs:documentation>
|
||||
Root element of the .mokostandards repository manifest.
|
||||
Every governed repository MUST contain this file at .gitea/.mokostandards
|
||||
</xs:documentation>
|
||||
</xs:annotation>
|
||||
</xs:element>
|
||||
|
||||
<xs:complexType name="MokoStandardsType">
|
||||
<xs:all>
|
||||
<xs:element name="identity" type="moko:IdentityType" />
|
||||
<xs:element name="governance" type="moko:GovernanceType" />
|
||||
<xs:element name="build" type="moko:BuildType" minOccurs="0" />
|
||||
<xs:element name="deploy" type="moko:DeployType" minOccurs="0" />
|
||||
<xs:element name="scripts" type="moko:ScriptsType" minOccurs="0" />
|
||||
<xs:element name="overrides" type="moko:OverridesType" minOccurs="0" />
|
||||
</xs:all>
|
||||
<xs:attribute name="schema-version" type="xs:string" use="required" fixed="1.0" />
|
||||
</xs:complexType>
|
||||
|
||||
<!-- ════════════════════════════════════════════════════════════════════
|
||||
IDENTITY — who is this repo?
|
||||
════════════════════════════════════════════════════════════════════ -->
|
||||
<xs:complexType name="IdentityType">
|
||||
<xs:annotation>
|
||||
<xs:documentation>
|
||||
Repository identity metadata. Provides authoritative repo-level
|
||||
information consumed by sync tools, CI, and documentation generators.
|
||||
</xs:documentation>
|
||||
</xs:annotation>
|
||||
<xs:all>
|
||||
<xs:element name="name" type="xs:string" />
|
||||
<xs:element name="org" type="xs:string" />
|
||||
<xs:element name="description" type="xs:string" minOccurs="0" />
|
||||
<xs:element name="license" type="moko:LicenseType" minOccurs="0" />
|
||||
<xs:element name="topics" type="moko:TopicsType" minOccurs="0" />
|
||||
</xs:all>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="LicenseType">
|
||||
<xs:annotation>
|
||||
<xs:documentation>SPDX license identifier for the repository</xs:documentation>
|
||||
</xs:annotation>
|
||||
<xs:simpleContent>
|
||||
<xs:extension base="xs:string">
|
||||
<xs:attribute name="spdx" type="xs:string" use="optional" />
|
||||
</xs:extension>
|
||||
</xs:simpleContent>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="TopicsType">
|
||||
<xs:sequence>
|
||||
<xs:element name="topic" type="xs:string" maxOccurs="unbounded" />
|
||||
</xs:sequence>
|
||||
</xs:complexType>
|
||||
|
||||
<!-- ════════════════════════════════════════════════════════════════════
|
||||
GOVERNANCE — how does MokoStandards manage this repo?
|
||||
════════════════════════════════════════════════════════════════════ -->
|
||||
<xs:complexType name="GovernanceType">
|
||||
<xs:annotation>
|
||||
<xs:documentation>
|
||||
Binds this repository to a MokoStandards platform definition and
|
||||
tracks the governance source and version.
|
||||
</xs:documentation>
|
||||
</xs:annotation>
|
||||
<xs:all>
|
||||
<xs:element name="platform" type="moko:PlatformEnum" />
|
||||
<xs:element name="standards-version" type="xs:string" />
|
||||
<xs:element name="standards-source" type="xs:anyURI" />
|
||||
<xs:element name="last-synced" type="xs:dateTime" minOccurs="0" />
|
||||
</xs:all>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:simpleType name="PlatformEnum">
|
||||
<xs:annotation>
|
||||
<xs:documentation>
|
||||
Platform slug — must match a .tf file in definitions/default/.
|
||||
Controls which structure definition and workflows are synced.
|
||||
</xs:documentation>
|
||||
</xs:annotation>
|
||||
<xs:restriction base="xs:string">
|
||||
<xs:enumeration value="default-repository" />
|
||||
<xs:enumeration value="crm-module" />
|
||||
<xs:enumeration value="crm-platform" />
|
||||
<xs:enumeration value="generic-repository" />
|
||||
<xs:enumeration value="github-private-repository" />
|
||||
<xs:enumeration value="joomla-template" />
|
||||
<xs:enumeration value="standards-repository" />
|
||||
<xs:enumeration value="waas-component" />
|
||||
</xs:restriction>
|
||||
</xs:simpleType>
|
||||
|
||||
<!-- ════════════════════════════════════════════════════════════════════
|
||||
BUILD — how is this repo built/packaged?
|
||||
════════════════════════════════════════════════════════════════════ -->
|
||||
<xs:complexType name="BuildType">
|
||||
<xs:annotation>
|
||||
<xs:documentation>
|
||||
Build and packaging configuration. Describes the toolchain,
|
||||
entry points, and artifact outputs for this repository.
|
||||
</xs:documentation>
|
||||
</xs:annotation>
|
||||
<xs:all>
|
||||
<xs:element name="language" type="xs:string" minOccurs="0" />
|
||||
<xs:element name="runtime" type="xs:string" minOccurs="0" />
|
||||
<xs:element name="package-type" type="xs:string" minOccurs="0" />
|
||||
<xs:element name="entry-point" type="xs:string" minOccurs="0" />
|
||||
<xs:element name="artifact" type="moko:ArtifactType" minOccurs="0" />
|
||||
<xs:element name="dependencies" type="moko:DependenciesType" minOccurs="0" />
|
||||
</xs:all>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="ArtifactType">
|
||||
<xs:annotation>
|
||||
<xs:documentation>Describes the build output artifact (zip, phar, etc.)</xs:documentation>
|
||||
</xs:annotation>
|
||||
<xs:all>
|
||||
<xs:element name="format" type="xs:string" />
|
||||
<xs:element name="path" type="xs:string" minOccurs="0" />
|
||||
<xs:element name="filename" type="xs:string" minOccurs="0" />
|
||||
</xs:all>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="DependenciesType">
|
||||
<xs:sequence>
|
||||
<xs:element name="requires" type="moko:DependencyType" minOccurs="0" maxOccurs="unbounded" />
|
||||
</xs:sequence>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="DependencyType">
|
||||
<xs:attribute name="name" type="xs:string" use="required" />
|
||||
<xs:attribute name="version" type="xs:string" use="optional" />
|
||||
<xs:attribute name="type" type="xs:string" use="optional" />
|
||||
</xs:complexType>
|
||||
|
||||
<!-- ════════════════════════════════════════════════════════════════════
|
||||
DEPLOY — where does this repo get deployed?
|
||||
════════════════════════════════════════════════════════════════════ -->
|
||||
<xs:complexType name="DeployType">
|
||||
<xs:annotation>
|
||||
<xs:documentation>
|
||||
Deployment targets. Each target maps to a CI workflow and
|
||||
defines the connection method and remote path.
|
||||
</xs:documentation>
|
||||
</xs:annotation>
|
||||
<xs:sequence>
|
||||
<xs:element name="target" type="moko:DeployTargetType" maxOccurs="unbounded" />
|
||||
</xs:sequence>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="DeployTargetType">
|
||||
<xs:all>
|
||||
<xs:element name="host" type="xs:string" />
|
||||
<xs:element name="path" type="xs:string" />
|
||||
<xs:element name="method" type="moko:DeployMethodEnum" minOccurs="0" />
|
||||
<xs:element name="branch" type="xs:string" minOccurs="0" />
|
||||
<xs:element name="src-dir" type="xs:string" minOccurs="0" />
|
||||
</xs:all>
|
||||
<xs:attribute name="name" type="xs:string" use="required" />
|
||||
<xs:attribute name="enabled" type="xs:boolean" use="optional" default="true" />
|
||||
</xs:complexType>
|
||||
|
||||
<xs:simpleType name="DeployMethodEnum">
|
||||
<xs:restriction base="xs:string">
|
||||
<xs:enumeration value="sftp" />
|
||||
<xs:enumeration value="rsync" />
|
||||
<xs:enumeration value="scp" />
|
||||
<xs:enumeration value="composer" />
|
||||
<xs:enumeration value="webhook" />
|
||||
</xs:restriction>
|
||||
</xs:simpleType>
|
||||
|
||||
<!-- ════════════════════════════════════════════════════════════════════
|
||||
SCRIPTS — repo-specific automation hooks
|
||||
════════════════════════════════════════════════════════════════════ -->
|
||||
<xs:complexType name="ScriptsType">
|
||||
<xs:annotation>
|
||||
<xs:documentation>
|
||||
Repo-specific scripts and automation hooks.
|
||||
Each script element defines a named command that CI or
|
||||
developers can invoke via `make`, `composer run`, or directly.
|
||||
</xs:documentation>
|
||||
</xs:annotation>
|
||||
<xs:sequence>
|
||||
<xs:element name="script" type="moko:ScriptType" maxOccurs="unbounded" />
|
||||
</xs:sequence>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="ScriptType">
|
||||
<xs:all>
|
||||
<xs:element name="command" type="xs:string" />
|
||||
<xs:element name="description" type="xs:string" minOccurs="0" />
|
||||
<xs:element name="runner" type="xs:string" minOccurs="0" />
|
||||
</xs:all>
|
||||
<xs:attribute name="name" type="xs:string" use="required" />
|
||||
<xs:attribute name="phase" type="moko:ScriptPhaseEnum" use="optional" />
|
||||
</xs:complexType>
|
||||
|
||||
<xs:simpleType name="ScriptPhaseEnum">
|
||||
<xs:restriction base="xs:string">
|
||||
<xs:enumeration value="pre-build" />
|
||||
<xs:enumeration value="build" />
|
||||
<xs:enumeration value="post-build" />
|
||||
<xs:enumeration value="test" />
|
||||
<xs:enumeration value="lint" />
|
||||
<xs:enumeration value="pre-deploy" />
|
||||
<xs:enumeration value="post-deploy" />
|
||||
<xs:enumeration value="release" />
|
||||
<xs:enumeration value="validate" />
|
||||
</xs:restriction>
|
||||
</xs:simpleType>
|
||||
|
||||
<!-- ════════════════════════════════════════════════════════════════════
|
||||
OVERRIDES — per-repo sync overrides
|
||||
════════════════════════════════════════════════════════════════════ -->
|
||||
<xs:complexType name="OverridesType">
|
||||
<xs:annotation>
|
||||
<xs:documentation>
|
||||
Per-repo overrides for the bulk sync process.
|
||||
Allows a repository to skip specific synced files or
|
||||
opt out of certain governance features without forking
|
||||
the entire platform definition.
|
||||
</xs:documentation>
|
||||
</xs:annotation>
|
||||
<xs:all>
|
||||
<xs:element name="skip-files" type="moko:FileListType" minOccurs="0" />
|
||||
<xs:element name="skip-workflows" type="moko:FileListType" minOccurs="0" />
|
||||
<xs:element name="extra-secrets" type="moko:SecretsListType" minOccurs="0" />
|
||||
</xs:all>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="FileListType">
|
||||
<xs:sequence>
|
||||
<xs:element name="file" type="xs:string" maxOccurs="unbounded" />
|
||||
</xs:sequence>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="SecretsListType">
|
||||
<xs:sequence>
|
||||
<xs:element name="secret" type="moko:SecretType" maxOccurs="unbounded" />
|
||||
</xs:sequence>
|
||||
</xs:complexType>
|
||||
|
||||
<xs:complexType name="SecretType">
|
||||
<xs:attribute name="name" type="xs:string" use="required" />
|
||||
<xs:attribute name="required" type="xs:boolean" use="optional" default="true" />
|
||||
<xs:attribute name="scope" type="xs:string" use="optional" />
|
||||
</xs:complexType>
|
||||
|
||||
</xs:schema>
|
||||
@@ -0,0 +1,546 @@
|
||||
<?php
|
||||
/**
|
||||
* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
|
||||
*
|
||||
* This file is part of a Moko Consulting project.
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* FILE INFORMATION
|
||||
* DEFGROUP: MokoStandards.Enterprise
|
||||
* INGROUP: MokoStandards
|
||||
* REPO: https://git.mokoconsulting.tech/MokoConsulting/MokoStandards-API
|
||||
* PATH: /lib/Enterprise/MokoStandardsParser.php
|
||||
* VERSION: 04.07.00
|
||||
* BRIEF: Parser for the XML-based .mokostandards repository manifest
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace MokoEnterprise;
|
||||
|
||||
use DOMDocument;
|
||||
use SimpleXMLElement;
|
||||
|
||||
/**
|
||||
* MokoStandards Parser
|
||||
*
|
||||
* Reads, writes, and validates the .mokostandards repository manifest.
|
||||
* The file uses XML format (no file extension) and lives at .gitea/.mokostandards.
|
||||
*
|
||||
* @package MokoStandards\Enterprise
|
||||
* @version 04.07.00
|
||||
*/
|
||||
class MokoStandardsParser
|
||||
{
|
||||
public const SCHEMA_VERSION = '1.0';
|
||||
public const NAMESPACE_URI = 'https://standards.mokoconsulting.tech/mokostandards/1.0';
|
||||
public const STANDARDS_SOURCE = 'https://git.mokoconsulting.tech/MokoConsulting/MokoStandards';
|
||||
|
||||
/** Valid platform slugs — must match definitions/default/*.tf filenames. */
|
||||
public const VALID_PLATFORMS = [
|
||||
'default-repository',
|
||||
'crm-module',
|
||||
'crm-platform',
|
||||
'generic-repository',
|
||||
'github-private-repository',
|
||||
'joomla-template',
|
||||
'standards-repository',
|
||||
'waas-component',
|
||||
];
|
||||
|
||||
/**
|
||||
* Parse a .mokostandards XML string into a structured array.
|
||||
*
|
||||
* @param string $xmlContent Raw XML content of .mokostandards
|
||||
* @return array{
|
||||
* identity: array{name: string, org: string, description?: string, license?: string, license_spdx?: string, topics?: list<string>},
|
||||
* governance: array{platform: string, standards_version: string, standards_source: string, last_synced?: string},
|
||||
* build?: array,
|
||||
* deploy?: array,
|
||||
* scripts?: array,
|
||||
* overrides?: array
|
||||
* }
|
||||
* @throws \RuntimeException If XML is invalid or missing required elements
|
||||
*/
|
||||
public function parse(string $xmlContent): array
|
||||
{
|
||||
libxml_use_internal_errors(true);
|
||||
$xml = simplexml_load_string($xmlContent);
|
||||
|
||||
if ($xml === false) {
|
||||
$errors = libxml_get_errors();
|
||||
libxml_clear_errors();
|
||||
$msg = !empty($errors) ? $errors[0]->message : 'Unknown XML parse error';
|
||||
throw new \RuntimeException("Invalid .mokostandards XML: " . trim($msg));
|
||||
}
|
||||
|
||||
// Register namespace for XPath
|
||||
$xml->registerXPathNamespace('m', self::NAMESPACE_URI);
|
||||
|
||||
$result = [
|
||||
'schema_version' => (string) ($xml['schema-version'] ?? self::SCHEMA_VERSION),
|
||||
'identity' => $this->parseIdentity($xml),
|
||||
'governance' => $this->parseGovernance($xml),
|
||||
];
|
||||
|
||||
if (isset($xml->build)) {
|
||||
$result['build'] = $this->parseBuild($xml->build);
|
||||
}
|
||||
if (isset($xml->deploy)) {
|
||||
$result['deploy'] = $this->parseDeploy($xml->deploy);
|
||||
}
|
||||
if (isset($xml->scripts)) {
|
||||
$result['scripts'] = $this->parseScripts($xml->scripts);
|
||||
}
|
||||
if (isset($xml->overrides)) {
|
||||
$result['overrides'] = $this->parseOverrides($xml->overrides);
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Try to parse content, returning null on failure instead of throwing.
|
||||
*
|
||||
* @param string $content Raw file content (XML or legacy YAML-like)
|
||||
* @return array|null Parsed data or null if unparseable
|
||||
*/
|
||||
public function tryParse(string $content): ?array
|
||||
{
|
||||
// Try XML first
|
||||
if (str_contains($content, '<mokostandards')) {
|
||||
try {
|
||||
return $this->parse($content);
|
||||
} catch (\RuntimeException $e) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// Try legacy YAML-like format (e.g. "platform: default-repository")
|
||||
return $this->parseLegacy($content);
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse the legacy single-line YAML-like format.
|
||||
*
|
||||
* @param string $content e.g. "platform: default-repository\n"
|
||||
* @return array|null Minimal parsed structure or null
|
||||
*/
|
||||
public function parseLegacy(string $content): ?array
|
||||
{
|
||||
$platform = null;
|
||||
$fields = [];
|
||||
|
||||
foreach (explode("\n", $content) as $line) {
|
||||
$line = trim($line);
|
||||
if ($line === '' || str_starts_with($line, '#')) {
|
||||
continue;
|
||||
}
|
||||
if (preg_match('/^(\w[\w_-]*)\s*:\s*"?([^"]*)"?\s*$/', $line, $m)) {
|
||||
$fields[$m[1]] = $m[2];
|
||||
}
|
||||
}
|
||||
|
||||
$platform = $fields['platform'] ?? null;
|
||||
if ($platform === null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return [
|
||||
'schema_version' => '0.0', // legacy marker
|
||||
'identity' => [
|
||||
'name' => $fields['governed_repo'] ?? '',
|
||||
'org' => '',
|
||||
],
|
||||
'governance' => [
|
||||
'platform' => $platform,
|
||||
'standards_version' => $fields['standards_version'] ?? '',
|
||||
'standards_source' => $fields['standards_source'] ?? '',
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract just the platform slug from any .mokostandards content (XML or legacy).
|
||||
*
|
||||
* @param string $content Raw file content
|
||||
* @return string|null Platform slug or null if unreadable
|
||||
*/
|
||||
public function extractPlatform(string $content): ?string
|
||||
{
|
||||
$data = $this->tryParse($content);
|
||||
return $data['governance']['platform'] ?? null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate XML .mokostandards content for a repository.
|
||||
*
|
||||
* @param array $params {
|
||||
* @type string $name Repository name (required)
|
||||
* @type string $org Organization (required)
|
||||
* @type string $platform Platform slug (required)
|
||||
* @type string $standards_version MokoStandards version
|
||||
* @type string $description Repo description
|
||||
* @type string $license SPDX license identifier
|
||||
* @type list<string> $topics Repo topics
|
||||
* @type string $language Primary language
|
||||
* @type string $runtime Runtime requirement
|
||||
* @type string $package_type Package format
|
||||
* @type string $entry_point Main entry file
|
||||
* @type string $last_synced ISO 8601 timestamp
|
||||
* }
|
||||
* @return string Well-formed XML content
|
||||
*/
|
||||
public function generate(array $params): string
|
||||
{
|
||||
$name = $params['name'] ?? '';
|
||||
$org = $params['org'] ?? '';
|
||||
$platform = $params['platform'] ?? 'default-repository';
|
||||
$version = $params['standards_version'] ?? '';
|
||||
|
||||
$dom = new DOMDocument('1.0', 'UTF-8');
|
||||
$dom->formatOutput = true;
|
||||
|
||||
// Add comment header
|
||||
$dom->appendChild($dom->createComment(
|
||||
"\n MokoStandards Repository Manifest\n"
|
||||
. " Auto-generated by MokoStandards bulk sync.\n"
|
||||
. " Manual edits to <governance> and <last-synced> may be overwritten.\n"
|
||||
. " See: docs/standards/mokostandards-file-spec.md\n"
|
||||
));
|
||||
|
||||
// Root element
|
||||
$root = $dom->createElementNS(self::NAMESPACE_URI, 'mokostandards');
|
||||
$root->setAttribute('schema-version', self::SCHEMA_VERSION);
|
||||
$dom->appendChild($root);
|
||||
|
||||
// <identity>
|
||||
$identity = $dom->createElement('identity');
|
||||
$identity->appendChild($dom->createElement('name', $this->xmlEscape($name)));
|
||||
$identity->appendChild($dom->createElement('org', $this->xmlEscape($org)));
|
||||
|
||||
if (!empty($params['description'])) {
|
||||
$identity->appendChild($dom->createElement('description', $this->xmlEscape($params['description'])));
|
||||
}
|
||||
|
||||
if (!empty($params['license'])) {
|
||||
$license = $dom->createElement('license', $this->xmlEscape($this->licenseLabel($params['license'])));
|
||||
$license->setAttribute('spdx', $params['license']);
|
||||
$identity->appendChild($license);
|
||||
}
|
||||
|
||||
if (!empty($params['topics'])) {
|
||||
$topics = $dom->createElement('topics');
|
||||
foreach ($params['topics'] as $topic) {
|
||||
$topics->appendChild($dom->createElement('topic', $this->xmlEscape($topic)));
|
||||
}
|
||||
$identity->appendChild($topics);
|
||||
}
|
||||
|
||||
$root->appendChild($identity);
|
||||
|
||||
// <governance>
|
||||
$governance = $dom->createElement('governance');
|
||||
$governance->appendChild($dom->createElement('platform', $this->xmlEscape($platform)));
|
||||
$governance->appendChild($dom->createElement('standards-version', $this->xmlEscape($version)));
|
||||
$governance->appendChild($dom->createElement('standards-source', self::STANDARDS_SOURCE));
|
||||
|
||||
if (!empty($params['last_synced'])) {
|
||||
$governance->appendChild($dom->createElement('last-synced', $params['last_synced']));
|
||||
}
|
||||
|
||||
$root->appendChild($governance);
|
||||
|
||||
// <build> (optional)
|
||||
if (!empty($params['language']) || !empty($params['runtime']) || !empty($params['package_type']) || !empty($params['entry_point'])) {
|
||||
$build = $dom->createElement('build');
|
||||
if (!empty($params['language'])) {
|
||||
$build->appendChild($dom->createElement('language', $this->xmlEscape($params['language'])));
|
||||
}
|
||||
if (!empty($params['runtime'])) {
|
||||
$build->appendChild($dom->createElement('runtime', $this->xmlEscape($params['runtime'])));
|
||||
}
|
||||
if (!empty($params['package_type'])) {
|
||||
$build->appendChild($dom->createElement('package-type', $this->xmlEscape($params['package_type'])));
|
||||
}
|
||||
if (!empty($params['entry_point'])) {
|
||||
$build->appendChild($dom->createElement('entry-point', $this->xmlEscape($params['entry_point'])));
|
||||
}
|
||||
$root->appendChild($build);
|
||||
}
|
||||
|
||||
return $dom->saveXML();
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate XML content against the XSD schema.
|
||||
*
|
||||
* @param string $xmlContent Raw XML content
|
||||
* @param string|null $xsdPath Path to the XSD file (auto-detected if null)
|
||||
* @return array{valid: bool, errors: list<string>}
|
||||
*/
|
||||
public function validate(string $xmlContent, ?string $xsdPath = null): array
|
||||
{
|
||||
if ($xsdPath === null) {
|
||||
$xsdPath = dirname(dirname(__DIR__)) . '/docs/standards/mokostandards-schema.xsd';
|
||||
}
|
||||
|
||||
if (!file_exists($xsdPath)) {
|
||||
return ['valid' => false, 'errors' => ["XSD schema not found: {$xsdPath}"]];
|
||||
}
|
||||
|
||||
libxml_use_internal_errors(true);
|
||||
$dom = new DOMDocument();
|
||||
$dom->loadXML($xmlContent);
|
||||
|
||||
$valid = $dom->schemaValidate($xsdPath);
|
||||
$errors = [];
|
||||
|
||||
if (!$valid) {
|
||||
foreach (libxml_get_errors() as $error) {
|
||||
$errors[] = "Line {$error->line}: " . trim($error->message);
|
||||
}
|
||||
}
|
||||
|
||||
libxml_clear_errors();
|
||||
|
||||
return ['valid' => $valid, 'errors' => $errors];
|
||||
}
|
||||
|
||||
// ──────────────────────────────────────────────────────────────
|
||||
// Private parsing helpers
|
||||
// ──────────────────────────────────────────────────────────────
|
||||
|
||||
private function parseIdentity(SimpleXMLElement $xml): array
|
||||
{
|
||||
$id = $xml->identity ?? null;
|
||||
if ($id === null) {
|
||||
throw new \RuntimeException('.mokostandards: missing required <identity> element');
|
||||
}
|
||||
|
||||
$result = [
|
||||
'name' => (string) ($id->name ?? ''),
|
||||
'org' => (string) ($id->org ?? ''),
|
||||
];
|
||||
|
||||
if ($result['name'] === '') {
|
||||
throw new \RuntimeException('.mokostandards: <identity><name> is required');
|
||||
}
|
||||
|
||||
if (isset($id->description)) {
|
||||
$result['description'] = (string) $id->description;
|
||||
}
|
||||
if (isset($id->license)) {
|
||||
$result['license'] = (string) $id->license;
|
||||
$spdx = (string) ($id->license['spdx'] ?? '');
|
||||
if ($spdx !== '') {
|
||||
$result['license_spdx'] = $spdx;
|
||||
}
|
||||
}
|
||||
if (isset($id->topics)) {
|
||||
$result['topics'] = [];
|
||||
foreach ($id->topics->topic as $topic) {
|
||||
$result['topics'][] = (string) $topic;
|
||||
}
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
private function parseGovernance(SimpleXMLElement $xml): array
|
||||
{
|
||||
$gov = $xml->governance ?? null;
|
||||
if ($gov === null) {
|
||||
throw new \RuntimeException('.mokostandards: missing required <governance> element');
|
||||
}
|
||||
|
||||
$result = [
|
||||
'platform' => (string) ($gov->platform ?? ''),
|
||||
'standards_version' => (string) ($gov->{'standards-version'} ?? ''),
|
||||
'standards_source' => (string) ($gov->{'standards-source'} ?? ''),
|
||||
];
|
||||
|
||||
if ($result['platform'] === '') {
|
||||
throw new \RuntimeException('.mokostandards: <governance><platform> is required');
|
||||
}
|
||||
|
||||
if (isset($gov->{'last-synced'})) {
|
||||
$result['last_synced'] = (string) $gov->{'last-synced'};
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
private function parseBuild(SimpleXMLElement $build): array
|
||||
{
|
||||
$result = [];
|
||||
|
||||
foreach (['language', 'runtime', 'entry-point'] as $field) {
|
||||
if (isset($build->$field)) {
|
||||
$key = str_replace('-', '_', $field);
|
||||
$result[$key] = (string) $build->$field;
|
||||
}
|
||||
}
|
||||
if (isset($build->{'package-type'})) {
|
||||
$result['package_type'] = (string) $build->{'package-type'};
|
||||
}
|
||||
|
||||
if (isset($build->artifact)) {
|
||||
$result['artifact'] = [];
|
||||
foreach (['format', 'path', 'filename'] as $f) {
|
||||
if (isset($build->artifact->$f)) {
|
||||
$result['artifact'][$f] = (string) $build->artifact->$f;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (isset($build->dependencies)) {
|
||||
$result['dependencies'] = [];
|
||||
foreach ($build->dependencies->requires as $req) {
|
||||
$dep = ['name' => (string) ($req['name'] ?? '')];
|
||||
if (isset($req['version'])) {
|
||||
$dep['version'] = (string) $req['version'];
|
||||
}
|
||||
if (isset($req['type'])) {
|
||||
$dep['type'] = (string) $req['type'];
|
||||
}
|
||||
$result['dependencies'][] = $dep;
|
||||
}
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
private function parseDeploy(SimpleXMLElement $deploy): array
|
||||
{
|
||||
$targets = [];
|
||||
foreach ($deploy->target as $target) {
|
||||
$t = [
|
||||
'name' => (string) ($target['name'] ?? ''),
|
||||
'enabled' => ((string) ($target['enabled'] ?? 'true')) !== 'false',
|
||||
'host' => (string) ($target->host ?? ''),
|
||||
'path' => (string) ($target->path ?? ''),
|
||||
];
|
||||
if (isset($target->method)) {
|
||||
$t['method'] = (string) $target->method;
|
||||
}
|
||||
if (isset($target->branch)) {
|
||||
$t['branch'] = (string) $target->branch;
|
||||
}
|
||||
if (isset($target->{'src-dir'})) {
|
||||
$t['src_dir'] = (string) $target->{'src-dir'};
|
||||
}
|
||||
$targets[] = $t;
|
||||
}
|
||||
return ['targets' => $targets];
|
||||
}
|
||||
|
||||
private function parseScripts(SimpleXMLElement $scripts): array
|
||||
{
|
||||
$result = [];
|
||||
foreach ($scripts->script as $script) {
|
||||
$s = [
|
||||
'name' => (string) ($script['name'] ?? ''),
|
||||
'command' => (string) ($script->command ?? ''),
|
||||
];
|
||||
if (isset($script['phase'])) {
|
||||
$s['phase'] = (string) $script['phase'];
|
||||
}
|
||||
if (isset($script->description)) {
|
||||
$s['description'] = (string) $script->description;
|
||||
}
|
||||
if (isset($script->runner)) {
|
||||
$s['runner'] = (string) $script->runner;
|
||||
}
|
||||
$result[] = $s;
|
||||
}
|
||||
return ['scripts' => $result];
|
||||
}
|
||||
|
||||
private function parseOverrides(SimpleXMLElement $overrides): array
|
||||
{
|
||||
$result = [];
|
||||
|
||||
if (isset($overrides->{'skip-files'})) {
|
||||
$result['skip_files'] = [];
|
||||
foreach ($overrides->{'skip-files'}->file as $file) {
|
||||
$result['skip_files'][] = (string) $file;
|
||||
}
|
||||
}
|
||||
|
||||
if (isset($overrides->{'skip-workflows'})) {
|
||||
$result['skip_workflows'] = [];
|
||||
foreach ($overrides->{'skip-workflows'}->file as $file) {
|
||||
$result['skip_workflows'][] = (string) $file;
|
||||
}
|
||||
}
|
||||
|
||||
if (isset($overrides->{'extra-secrets'})) {
|
||||
$result['extra_secrets'] = [];
|
||||
foreach ($overrides->{'extra-secrets'}->secret as $secret) {
|
||||
$s = ['name' => (string) ($secret['name'] ?? '')];
|
||||
if (isset($secret['required'])) {
|
||||
$s['required'] = ((string) $secret['required']) !== 'false';
|
||||
}
|
||||
if (isset($secret['scope'])) {
|
||||
$s['scope'] = (string) $secret['scope'];
|
||||
}
|
||||
$result['extra_secrets'][] = $s;
|
||||
}
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Escape a string for XML element content.
|
||||
*/
|
||||
private function xmlEscape(string $value): string
|
||||
{
|
||||
return htmlspecialchars($value, ENT_XML1 | ENT_QUOTES, 'UTF-8');
|
||||
}
|
||||
|
||||
/**
|
||||
* Map SPDX identifier to a human-readable license label.
|
||||
*/
|
||||
private function licenseLabel(string $spdx): string
|
||||
{
|
||||
return match ($spdx) {
|
||||
'GPL-3.0-or-later' => 'GNU General Public License v3',
|
||||
'GPL-2.0-or-later' => 'GNU General Public License v2',
|
||||
'MIT' => 'MIT License',
|
||||
'Apache-2.0' => 'Apache License 2.0',
|
||||
'BSD-3-Clause' => 'BSD 3-Clause License',
|
||||
'LGPL-3.0-or-later' => 'GNU Lesser General Public License v3',
|
||||
default => $spdx,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Map a platform slug to its default package type.
|
||||
*/
|
||||
public static function platformPackageType(string $platform): string
|
||||
{
|
||||
return match ($platform) {
|
||||
'crm-module', 'crm-platform' => 'dolibarr-module',
|
||||
'waas-component' => 'joomla-extension',
|
||||
'joomla-template' => 'joomla-extension',
|
||||
'standards-repository' => 'composer',
|
||||
default => 'composer',
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Map a platform slug to its default primary language.
|
||||
*/
|
||||
public static function platformLanguage(string $platform): string
|
||||
{
|
||||
return match ($platform) {
|
||||
'crm-module', 'crm-platform' => 'PHP',
|
||||
'waas-component', 'joomla-template' => 'PHP',
|
||||
'standards-repository' => 'PHP',
|
||||
default => 'PHP',
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -39,12 +39,13 @@ class RepositorySynchronizer
|
||||
private const VERSION_BRANCH = 'version/' . self::STANDARDS_MAJOR;
|
||||
private const SYNC_BRANCH = 'chore/sync-mokostandards-v' . self::STANDARDS_MINOR;
|
||||
|
||||
private ApiClient $apiClient;
|
||||
private GitPlatformAdapter $adapter;
|
||||
private AuditLogger $logger;
|
||||
private MetricsCollector $metrics;
|
||||
private CheckpointManager $checkpoints;
|
||||
private DefinitionParser $definitionParser;
|
||||
private ApiClient $apiClient;
|
||||
private GitPlatformAdapter $adapter;
|
||||
private AuditLogger $logger;
|
||||
private MetricsCollector $metrics;
|
||||
private CheckpointManager $checkpoints;
|
||||
private DefinitionParser $definitionParser;
|
||||
private MokoStandardsParser $manifestParser;
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
@@ -70,6 +71,7 @@ class RepositorySynchronizer
|
||||
$this->metrics = $metrics;
|
||||
$this->checkpoints = $checkpoints ?? new CheckpointManager('.checkpoints');
|
||||
$this->definitionParser = $definitionParser ?? new DefinitionParser();
|
||||
$this->manifestParser = new MokoStandardsParser();
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -400,7 +402,65 @@ HCL;
|
||||
/** Repos that are the full Dolibarr platform, not individual modules. */
|
||||
private const CRM_PLATFORM_REPOS = ['MokoDolibarr', 'MokoDoliMods'];
|
||||
|
||||
/**
|
||||
* Detect platform from the .mokostandards manifest (authoritative), falling
|
||||
* back to name/topic/description heuristics when the manifest is missing or
|
||||
* unparseable.
|
||||
*/
|
||||
private function detectPlatform(array $repoInfo): string
|
||||
{
|
||||
$org = $repoInfo['full_name'] ? explode('/', $repoInfo['full_name'])[0] : '';
|
||||
$name = $repoInfo['name'] ?? '';
|
||||
|
||||
// ── 1. Try reading the XML .mokostandards manifest ────────────��─
|
||||
$manifestPlatform = $this->readManifestPlatform($org, $name);
|
||||
if ($manifestPlatform !== null) {
|
||||
$this->logger->logInfo("Platform for {$name} from .mokostandards manifest: {$manifestPlatform}");
|
||||
return $manifestPlatform;
|
||||
}
|
||||
|
||||
// ── 2. Fallback: heuristic detection ────────────────────────────
|
||||
return $this->detectPlatformByHeuristics($repoInfo);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read the platform slug from the remote .mokostandards manifest.
|
||||
* Checks .gitea/.mokostandards, .github/.mokostandards, and root .mokostandards.
|
||||
*
|
||||
* @return string|null Platform slug or null if not found/parseable
|
||||
*/
|
||||
private function readManifestPlatform(string $org, string $repo): ?string
|
||||
{
|
||||
$metaDir = $this->adapter->getMetadataDir();
|
||||
$paths = [
|
||||
"{$metaDir}/.mokostandards",
|
||||
'.mokostandards',
|
||||
];
|
||||
if ($metaDir === '.gitea') {
|
||||
$paths[] = '.github/.mokostandards';
|
||||
}
|
||||
|
||||
foreach ($paths as $path) {
|
||||
try {
|
||||
$file = $this->adapter->getFileContents($org, $repo, $path);
|
||||
$content = base64_decode($file['content'] ?? '');
|
||||
$platform = $this->manifestParser->extractPlatform($content);
|
||||
if ($platform !== null && in_array($platform, MokoStandardsParser::VALID_PLATFORMS, true)) {
|
||||
return $platform;
|
||||
}
|
||||
} catch (Exception $e) {
|
||||
$this->adapter->getApiClient()->resetCircuitBreaker();
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Heuristic platform detection from repo name, topics, and description.
|
||||
* Used as fallback when .mokostandards manifest is missing or unparseable.
|
||||
*/
|
||||
private function detectPlatformByHeuristics(array $repoInfo): string
|
||||
{
|
||||
$name = $repoInfo['name'] ?? '';
|
||||
$nameLower = strtolower($name);
|
||||
@@ -448,7 +508,7 @@ HCL;
|
||||
if (str_contains($description, 'dolibarr') || str_contains($description, 'module')) {
|
||||
return 'crm-module';
|
||||
}
|
||||
|
||||
|
||||
// Default
|
||||
return 'default-repository';
|
||||
}
|
||||
@@ -503,8 +563,8 @@ HCL;
|
||||
// Ensure composer.json requires mokoconsulting-tech/enterprise (default branch only)
|
||||
$this->ensureComposerEnterprise($org, $repo, $defaultBranch, $summary);
|
||||
|
||||
// Migrate .mokostandards (default branch only)
|
||||
$this->migrateMokoStandards($org, $repo, $defaultBranch, $summary);
|
||||
// Migrate .mokostandards to XML manifest (default branch only)
|
||||
$this->migrateMokoStandards($org, $repo, $defaultBranch, $platform, $repoInfo, $summary);
|
||||
|
||||
if (count($summary['copied']) === 0) {
|
||||
$this->logger->logWarning("No files were created/updated for {$repo}");
|
||||
@@ -706,80 +766,229 @@ HCL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Migrate .mokostandards to the platform metadata dir (.gitea/ or .github/).
|
||||
* Handles migration from root and from .github/ → .gitea/ on Gitea.
|
||||
* Migrate .mokostandards to the platform metadata dir (.gitea/ or .github/)
|
||||
* and convert legacy YAML-like format to the new XML manifest.
|
||||
*
|
||||
* Handles:
|
||||
* 1. Location migration: root or .github/ → .gitea/.mokostandards
|
||||
* 2. Format migration: legacy "platform: xxx" → XML manifest
|
||||
* 3. Update existing XML: refresh <governance><last-synced> timestamp
|
||||
*/
|
||||
private function migrateMokoStandards(string $org, string $repo, string $branchName, array &$summary): void
|
||||
{
|
||||
$metaDir = $this->adapter->getMetadataDir();
|
||||
private function migrateMokoStandards(
|
||||
string $org,
|
||||
string $repo,
|
||||
string $branchName,
|
||||
string $platform,
|
||||
array $repoInfo,
|
||||
array &$summary
|
||||
): void {
|
||||
$metaDir = $this->adapter->getMetadataDir();
|
||||
$targetPath = "{$metaDir}/.mokostandards";
|
||||
|
||||
// Sources to check, in priority order
|
||||
$sources = ['.mokostandards'];
|
||||
// On Gitea, also migrate from .github/.mokostandards → .gitea/.mokostandards
|
||||
// ── Collect existing files from all legacy locations ─────────
|
||||
$legacySources = ['.mokostandards'];
|
||||
if ($metaDir === '.gitea') {
|
||||
$sources[] = '.github/.mokostandards';
|
||||
$legacySources[] = '.github/.mokostandards';
|
||||
}
|
||||
|
||||
$rootFile = null;
|
||||
$sourcePath = null;
|
||||
foreach ($sources as $path) {
|
||||
$legacyFiles = []; // path => ['content' => raw, 'sha' => sha]
|
||||
foreach ($legacySources as $path) {
|
||||
try {
|
||||
$rootFile = $this->adapter->getFileContents($org, $repo, $path, $branchName);
|
||||
$sourcePath = $path;
|
||||
break;
|
||||
$file = $this->adapter->getFileContents($org, $repo, $path, $branchName);
|
||||
$legacyFiles[$path] = [
|
||||
'content' => base64_decode($file['content'] ?? ''),
|
||||
'sha' => $file['sha'] ?? '',
|
||||
];
|
||||
} catch (Exception $e) {
|
||||
$this->adapter->getApiClient()->resetCircuitBreaker();
|
||||
}
|
||||
}
|
||||
|
||||
if ($rootFile === null) {
|
||||
return; // Nothing to migrate
|
||||
}
|
||||
|
||||
// Check if already exists in metadata dir
|
||||
$existsInMetaDir = false;
|
||||
// Check if target already exists in metadata dir
|
||||
$existingTarget = null;
|
||||
try {
|
||||
$this->adapter->getFileContents($org, $repo, $targetPath, $branchName);
|
||||
$existsInMetaDir = true;
|
||||
$file = $this->adapter->getFileContents($org, $repo, $targetPath, $branchName);
|
||||
$existingTarget = [
|
||||
'content' => base64_decode($file['content'] ?? ''),
|
||||
'sha' => $file['sha'] ?? '',
|
||||
];
|
||||
} catch (Exception $e) {
|
||||
$this->adapter->getApiClient()->resetCircuitBreaker();
|
||||
}
|
||||
|
||||
$content = base64_decode($rootFile['content'] ?? '');
|
||||
$rootSha = $rootFile['sha'] ?? '';
|
||||
// ── Determine the best existing content to work from ────────
|
||||
$currentContent = $existingTarget['content'] ?? null;
|
||||
if ($currentContent === null) {
|
||||
// Pick from legacy sources (first found)
|
||||
foreach ($legacyFiles as $data) {
|
||||
$currentContent = $data['content'];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// ── Generate the new XML manifest ───────────────────────────
|
||||
$xmlContent = $this->generateMokoStandardsXml(
|
||||
$org,
|
||||
$repo,
|
||||
$platform,
|
||||
$repoInfo,
|
||||
$currentContent
|
||||
);
|
||||
|
||||
// ── Write to target path ────────────────────────────────────
|
||||
$targetSha = $existingTarget['sha'] ?? null;
|
||||
$isNew = $existingTarget === null;
|
||||
$needsUpdate = $isNew || $existingTarget['content'] !== $xmlContent;
|
||||
|
||||
if ($needsUpdate) {
|
||||
$action = $isNew ? 'create' : 'update';
|
||||
$commitMsg = $isNew
|
||||
? "chore: add XML .mokostandards manifest to {$metaDir}/"
|
||||
: "chore: update .mokostandards manifest (XML format)";
|
||||
|
||||
if (!$existsInMetaDir) {
|
||||
// Copy to metadata dir
|
||||
try {
|
||||
$this->adapter->createOrUpdateFile(
|
||||
$org, $repo, $targetPath, $content,
|
||||
"chore: migrate .mokostandards to {$metaDir}/",
|
||||
null, $branchName
|
||||
$org, $repo, $targetPath, $xmlContent,
|
||||
$commitMsg, $targetSha, $branchName
|
||||
);
|
||||
$this->logger->logInfo("Migrated .mokostandards → {$targetPath}");
|
||||
$summary['copied'][] = ['file' => $targetPath, 'action' => 'migrated from root'];
|
||||
$this->logger->logInfo(ucfirst($action) . "d XML .mokostandards → {$targetPath}");
|
||||
$summary['copied'][] = ['file' => $targetPath, 'action' => "{$action}d (XML manifest)"];
|
||||
} catch (Exception $e) {
|
||||
$this->adapter->getApiClient()->resetCircuitBreaker();
|
||||
$this->logger->logWarning("Could not {$action} .mokostandards: " . $e->getMessage());
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// Delete old source file
|
||||
if (!empty($rootSha) && $sourcePath !== $targetPath) {
|
||||
// ── Delete legacy source files ──────────────────────────────
|
||||
foreach ($legacyFiles as $path => $data) {
|
||||
if ($path === $targetPath || empty($data['sha'])) {
|
||||
continue;
|
||||
}
|
||||
try {
|
||||
$this->adapter->deleteFile(
|
||||
$org, $repo, $sourcePath, $rootSha,
|
||||
"chore: remove {$sourcePath} (moved to {$targetPath})",
|
||||
$org, $repo, $path, $data['sha'],
|
||||
"chore: remove legacy {$path} (replaced by {$targetPath})",
|
||||
$branchName
|
||||
);
|
||||
$this->logger->logInfo("Deleted {$sourcePath}");
|
||||
$this->logger->logInfo("Deleted legacy {$path}");
|
||||
} catch (Exception $e) {
|
||||
$this->adapter->getApiClient()->resetCircuitBreaker();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate an XML .mokostandards manifest for a repository.
|
||||
*
|
||||
* If existing content is valid XML, preserves user-edited sections
|
||||
* (build, deploy, scripts, overrides) and only refreshes governance metadata.
|
||||
*
|
||||
* @param string $org Organization name
|
||||
* @param string $repo Repository name
|
||||
* @param string $platform Detected platform slug
|
||||
* @param array $repoInfo Gitea API repo object
|
||||
* @param string|null $existingContent Current .mokostandards content (XML or legacy)
|
||||
* @return string Well-formed XML content
|
||||
*/
|
||||
private function generateMokoStandardsXml(
|
||||
string $org,
|
||||
string $repo,
|
||||
string $platform,
|
||||
array $repoInfo,
|
||||
?string $existingContent
|
||||
): string {
|
||||
$params = [
|
||||
'name' => $repoInfo['name'] ?? $repo,
|
||||
'org' => $org,
|
||||
'platform' => $platform,
|
||||
'standards_version' => self::STANDARDS_VERSION,
|
||||
'description' => $repoInfo['description'] ?? '',
|
||||
'license' => 'GPL-3.0-or-later',
|
||||
'topics' => $repoInfo['topics'] ?? [],
|
||||
'language' => $repoInfo['language'] ?? MokoStandardsParser::platformLanguage($platform),
|
||||
'package_type' => MokoStandardsParser::platformPackageType($platform),
|
||||
'last_synced' => date('c'),
|
||||
];
|
||||
|
||||
// If existing content is already valid XML, try to preserve user sections
|
||||
if ($existingContent !== null && str_contains($existingContent, '<mokostandards')) {
|
||||
try {
|
||||
$existing = $this->manifestParser->parse($existingContent);
|
||||
|
||||
// Preserve user-edited build, deploy, scripts, overrides by re-emitting
|
||||
// the existing XML with only governance fields refreshed.
|
||||
// For now, we use the simple generate() which creates identity + governance + build.
|
||||
// User-managed sections (deploy, scripts, overrides) are preserved by doing
|
||||
// a targeted replacement of governance fields in the existing XML.
|
||||
return $this->refreshGovernanceInXml(
|
||||
$existingContent,
|
||||
$platform,
|
||||
self::STANDARDS_VERSION,
|
||||
date('c')
|
||||
);
|
||||
} catch (\RuntimeException $e) {
|
||||
// Existing XML is broken — regenerate from scratch
|
||||
$this->logger->logInfo("Existing .mokostandards XML invalid, regenerating: " . $e->getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
return $this->manifestParser->generate($params);
|
||||
}
|
||||
|
||||
/**
|
||||
* Refresh only the <governance> fields in an existing XML .mokostandards,
|
||||
* preserving all other sections (build, deploy, scripts, overrides).
|
||||
*/
|
||||
private function refreshGovernanceInXml(
|
||||
string $xml,
|
||||
string $platform,
|
||||
string $standardsVersion,
|
||||
string $lastSynced
|
||||
): string {
|
||||
$dom = new \DOMDocument('1.0', 'UTF-8');
|
||||
$dom->preserveWhiteSpace = true;
|
||||
$dom->formatOutput = true;
|
||||
|
||||
if (!$dom->loadXML($xml)) {
|
||||
// If parsing fails, return as-is
|
||||
return $xml;
|
||||
}
|
||||
|
||||
$xpath = new \DOMXPath($dom);
|
||||
$xpath->registerNamespace('m', MokoStandardsParser::NAMESPACE_URI);
|
||||
|
||||
// Update <platform>
|
||||
$nodes = $xpath->query('//m:governance/m:platform');
|
||||
if ($nodes->length > 0) {
|
||||
$nodes->item(0)->textContent = $platform;
|
||||
}
|
||||
|
||||
// Update <standards-version>
|
||||
$nodes = $xpath->query('//m:governance/m:standards-version');
|
||||
if ($nodes->length > 0) {
|
||||
$nodes->item(0)->textContent = $standardsVersion;
|
||||
}
|
||||
|
||||
// Update or create <last-synced>
|
||||
$nodes = $xpath->query('//m:governance/m:last-synced');
|
||||
if ($nodes->length > 0) {
|
||||
$nodes->item(0)->textContent = $lastSynced;
|
||||
} else {
|
||||
$govNodes = $xpath->query('//m:governance');
|
||||
if ($govNodes->length > 0) {
|
||||
$lastSyncedEl = $dom->createElementNS(
|
||||
MokoStandardsParser::NAMESPACE_URI,
|
||||
'last-synced'
|
||||
);
|
||||
$lastSyncedEl->textContent = $lastSynced;
|
||||
$govNodes->item(0)->appendChild($lastSyncedEl);
|
||||
}
|
||||
}
|
||||
|
||||
return $dom->saveXML();
|
||||
}
|
||||
|
||||
private function ensureComposerEnterprise(string $org, string $repo, string $branchName, array &$summary): void
|
||||
{
|
||||
try {
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!--
|
||||
Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
|
||||
SPDX-License-Identifier: GPL-3.0-or-later
|
||||
FILE INFORMATION
|
||||
DEFGROUP: MokoStandards.Templates.Config
|
||||
INGROUP: MokoStandards.Templates
|
||||
REPO: https://git.mokoconsulting.tech/MokoConsulting/MokoStandards-API
|
||||
PATH: /templates/configs/mokostandards.xml.template
|
||||
VERSION: 04.07.00
|
||||
BRIEF: XML manifest template — synced to .gitea/.mokostandards in every governed repository
|
||||
NOTE: This template is a reference only. The bulk sync generates XML via MokoStandardsParser::generate().
|
||||
|
||||
MokoStandards Repository Manifest
|
||||
Auto-generated by MokoStandards bulk sync.
|
||||
Manual edits to <governance> and <last-synced> may be overwritten.
|
||||
See: docs/standards/mokostandards-file-spec.md
|
||||
-->
|
||||
<mokostandards xmlns="https://standards.mokoconsulting.tech/mokostandards/1.0"
|
||||
schema-version="1.0">
|
||||
|
||||
<identity>
|
||||
<name>{{REPO_NAME}}</name>
|
||||
<org>{{org}}</org>
|
||||
<description>{{REPO_DESCRIPTION}}</description>
|
||||
<license spdx="GPL-3.0-or-later">GNU General Public License v3</license>
|
||||
</identity>
|
||||
|
||||
<governance>
|
||||
<platform>{{platform}}</platform>
|
||||
<standards-version>{{standards_version}}</standards-version>
|
||||
<standards-source>https://git.mokoconsulting.tech/MokoConsulting/MokoStandards</standards-source>
|
||||
</governance>
|
||||
|
||||
<build>
|
||||
<language>{{PRIMARY_LANGUAGE}}</language>
|
||||
</build>
|
||||
|
||||
</mokostandards>
|
||||
@@ -32,7 +32,7 @@ use MokoEnterprise\CliFramework;
|
||||
* - Required root files present (README.md, CHANGELOG.md, LICENSE, CONTRIBUTING.md,
|
||||
* SECURITY.md, .gitignore, .editorconfig, composer.json)
|
||||
* - Required directories present (src/, docs/, tests/)
|
||||
* - .mokostandards.yml governance attachment present
|
||||
* - .gitea/.mokostandards XML governance manifest present
|
||||
* - SPDX-License-Identifier header present in all PHP source files
|
||||
* - No tab characters in YAML/JSON config files
|
||||
* - No Windows path separators in PHP source
|
||||
@@ -74,10 +74,25 @@ class ValidateStructure extends CliFramework
|
||||
|
||||
// ── Governance attachment ─────────────────────────────────────────
|
||||
$this->section('MokoStandards governance');
|
||||
$mokoFile = file_exists("{$path}/.mokostandards.yml");
|
||||
$this->status($mokoFile, '.mokostandards.yml');
|
||||
$mokoFile = file_exists("{$path}/.gitea/.mokostandards")
|
||||
|| file_exists("{$path}/.github/.mokostandards")
|
||||
|| file_exists("{$path}/.mokostandards");
|
||||
$this->status($mokoFile, '.gitea/.mokostandards (XML manifest)');
|
||||
$mokoFile ? $passed++ : $failed++;
|
||||
|
||||
// Validate XML format if file exists
|
||||
if ($mokoFile) {
|
||||
$manifestPath = file_exists("{$path}/.gitea/.mokostandards")
|
||||
? "{$path}/.gitea/.mokostandards"
|
||||
: (file_exists("{$path}/.github/.mokostandards")
|
||||
? "{$path}/.github/.mokostandards"
|
||||
: "{$path}/.mokostandards");
|
||||
$manifestContent = file_get_contents($manifestPath);
|
||||
$isXml = str_contains($manifestContent, '<mokostandards');
|
||||
$this->status($isXml, '.mokostandards uses XML format');
|
||||
$isXml ? $passed++ : $failed++;
|
||||
}
|
||||
|
||||
// ── Required directories ──────────────────────────────────────────
|
||||
$this->section('Required directories');
|
||||
foreach (['src', 'docs', 'tests'] as $dir) {
|
||||
|
||||
@@ -337,8 +337,17 @@ jobs:
|
||||
|
||||
# ── Platform-specific path safety guards ──────────────────────────────
|
||||
PLATFORM=""
|
||||
MOKO_FILE=".github/.mokostandards"; [ ! -f "$MOKO_FILE" ] && MOKO_FILE=".mokostandards"; if [ -f "$MOKO_FILE" ]; then
|
||||
PLATFORM=$(grep -E '^platform:' "$MOKO_FILE" | sed 's/.*:[[:space:]]*//' | tr -d '"')
|
||||
MOKO_FILE=".gitea/.mokostandards"
|
||||
[ ! -f "$MOKO_FILE" ] && MOKO_FILE=".github/.mokostandards"
|
||||
[ ! -f "$MOKO_FILE" ] && MOKO_FILE=".mokostandards"
|
||||
if [ -f "$MOKO_FILE" ]; then
|
||||
# XML format: extract <platform>value</platform>
|
||||
if grep -q '<mokostandards' "$MOKO_FILE" 2>/dev/null; then
|
||||
PLATFORM=$(sed -n 's/.*<platform>\([^<]*\)<\/platform>.*/\1/p' "$MOKO_FILE" | head -1)
|
||||
else
|
||||
# Legacy YAML-like format: platform: value
|
||||
PLATFORM=$(grep -E '^platform:' "$MOKO_FILE" | sed 's/.*:[[:space:]]*//' | tr -d '"')
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ "$PLATFORM" = "crm-module" ]; then
|
||||
|
||||
@@ -336,8 +336,17 @@ jobs:
|
||||
|
||||
# ── Platform-specific path safety guards ──────────────────────────────
|
||||
PLATFORM=""
|
||||
MOKO_FILE=".github/.mokostandards"; [ ! -f "$MOKO_FILE" ] && MOKO_FILE=".mokostandards"; if [ -f "$MOKO_FILE" ]; then
|
||||
PLATFORM=$(grep -oP '^platform:.*' "$MOKO_FILE" 2>/dev/null || true)
|
||||
MOKO_FILE=".gitea/.mokostandards"
|
||||
[ ! -f "$MOKO_FILE" ] && MOKO_FILE=".github/.mokostandards"
|
||||
[ ! -f "$MOKO_FILE" ] && MOKO_FILE=".mokostandards"
|
||||
if [ -f "$MOKO_FILE" ]; then
|
||||
# XML format: extract <platform>value</platform>
|
||||
if grep -q '<mokostandards' "$MOKO_FILE" 2>/dev/null; then
|
||||
PLATFORM=$(sed -n 's/.*<platform>\([^<]*\)<\/platform>.*/\1/p' "$MOKO_FILE" | head -1)
|
||||
else
|
||||
# Legacy YAML-like format: platform: value
|
||||
PLATFORM=$(grep -oP '(?<=^platform:\s).+' "$MOKO_FILE" 2>/dev/null | tr -d '"' || true)
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ "$PLATFORM" = "crm-module" ]; then
|
||||
|
||||
@@ -352,8 +352,17 @@ jobs:
|
||||
|
||||
# ── Platform-specific path safety guards ──────────────────────────────
|
||||
PLATFORM=""
|
||||
MOKO_FILE=".github/.mokostandards"; [ ! -f "$MOKO_FILE" ] && MOKO_FILE=".mokostandards"; if [ -f "$MOKO_FILE" ]; then
|
||||
PLATFORM=$(grep -E '^platform:' "$MOKO_FILE" | sed 's/.*:[[:space:]]*//' | tr -d '"')
|
||||
MOKO_FILE=".gitea/.mokostandards"
|
||||
[ ! -f "$MOKO_FILE" ] && MOKO_FILE=".github/.mokostandards"
|
||||
[ ! -f "$MOKO_FILE" ] && MOKO_FILE=".mokostandards"
|
||||
if [ -f "$MOKO_FILE" ]; then
|
||||
# XML format: extract <platform>value</platform>
|
||||
if grep -q '<mokostandards' "$MOKO_FILE" 2>/dev/null; then
|
||||
PLATFORM=$(sed -n 's/.*<platform>\([^<]*\)<\/platform>.*/\1/p' "$MOKO_FILE" | head -1)
|
||||
else
|
||||
# Legacy YAML-like format: platform: value
|
||||
PLATFORM=$(grep -E '^platform:' "$MOKO_FILE" | sed 's/.*:[[:space:]]*//' | tr -d '"')
|
||||
fi
|
||||
fi
|
||||
|
||||
# RS deployment: no path restrictions for any platform
|
||||
|
||||
Reference in New Issue
Block a user