moko-platform/cli/create_project.php

#!/usr/bin/env php
<?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: moko-platform.CLI
 * INGROUP: moko-platform
 * REPO: https://git.mokoconsulting.tech/MokoConsulting/moko-platform
 * PATH: /cli/create_project.php
 * BRIEF: Create baseline GitHub Projects for repositories with standard fields and views
 */

declare(strict_types=1);

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

use MokoEnterprise\CliFramework;

class CreateProjectCli extends CliFramework
{
    /** @var string[] */
    private array $ALWAYS_EXCLUDE = ['moko-platform', '.github-private'];

    /** @var array<string, string> */
    private array $PLATFORM_TO_TYPE = [
        'crm-module'     => 'dolibarr',
        'crm-platform'   => 'dolibarr',
        'waas-component' => 'joomla',
        'waas-library'   => 'joomla',
        'waas-plugin'    => 'joomla',
        'waas-package'   => 'joomla',
        'nodejs'         => 'nodejs',
        'terraform'      => 'terraform',
        'python'         => 'python',
        'wordpress'      => 'wordpress',
        'mobile'         => 'mobile-app',
        'api'            => 'api',
        'documentation'  => 'documentation',
    ];

    /** @var array<string, string> */
    private array $TYPE_TO_TEMPLATE = [
        'generic'       => 'generic-project-definition.tf',
        'dolibarr'      => 'dolibarr-project-definition.tf',
        'joomla'        => 'joomla-project-definition.tf',
        'nodejs'        => 'nodejs-project-definition.tf',
        'terraform'     => 'terraform-project-definition.tf',
        'python'        => 'python-project-definition.tf',
        'wordpress'     => 'wordpress-project-definition.tf',
        'mobile-app'    => 'mobile-app-project-definition.tf',
        'api'           => 'api-project-definition.tf',
        'documentation' => 'documentation-project-definition.tf',
    ];

    protected function configure(): void
    {
        $this->setDescription('Create baseline GitHub Projects for repositories with standard fields and views');
        $this->addArgument('--repo', 'Repository name', '');
        $this->addArgument('--org', 'Organization (default: mokoconsulting-tech)', 'mokoconsulting-tech');
        $this->addArgument('--type', 'Force project type', '');
        $this->addArgument('--all', 'Process all repos without projects', false);
    }

    protected function run(): int
    {
        $repoName = $this->getArgument('--repo') ?: null;
        $org = $this->getArgument('--org');
        $typeOverride = $this->getArgument('--type') ?: null;
        $allMode = $this->getArgument('--all');

        if (!$repoName && !$allMode) {
            $this->log('ERROR', "Usage: php create_project.php --repo <name> [--type <type>] [--dry-run]");
            $this->log('ERROR', "       php create_project.php --all [--org <org>] [--dry-run]");
            $this->log('ERROR', "Types: generic, dolibarr, joomla, nodejs, terraform, python, wordpress, mobile-app, api, documentation");
            return 2;
        }

        $config   = \MokoEnterprise\Config::load();
        $platformName = $config->getString('platform', 'gitea');
        try {
            $adapter = \MokoEnterprise\PlatformAdapterFactory::create($config);
            $api     = $adapter->getApiClient();
        } catch (\Exception $e) {
            $this->log('ERROR', "Platform initialization failed: " . $e->getMessage());
            return 1;
        }
        $token = $platformName === 'gitea'
            ? $config->getString('gitea.token', '')
            : $config->getString('github.token', '');

        $repoRoot     = dirname(__DIR__, 2);
        $templatesDir = "{$repoRoot}/templates/projects";

        $repos = [];

        if ($allMode) {
            echo "Fetching repositories from {$org}...\n";
            $page = 1;
            do {
                $batch = $this->restGet("orgs/{$org}/repos?per_page=100&page={$page}&type=all", $token, $api);
                foreach ($batch as $r) {
                    if (!$r['archived'] && !in_array($r['name'], $this->ALWAYS_EXCLUDE, true)) {
                        $repos[] = $r['name'];
                    }
                }
                $page++;
            } while (count($batch) === 100);

            sort($repos);
            echo "Found " . count($repos) . " repositories\n\n";
        } else {
            $repos = [$repoName];
        }

        $ownerId = $this->getOrgNodeId($org, $token);
        if (empty($ownerId)) {
            $this->log('ERROR', "Could not resolve org node ID for {$org}");
            return 1;
        }

        $created = 0;
        $skipped = 0;
        $failed  = 0;

        foreach ($repos as $repo) {
            echo "Processing {$repo}...\n";

            [$hasProject, $existingTitle] = $this->repoHasProject($org, $repo, $token);
            if ($hasProject) {
                echo "  Already has project: {$existingTitle} -- skipping\n";
                $skipped++;
                continue;
            }

            $type = $typeOverride;
            if (!$type) {
                $platform = $this->detectRepoPlatform($org, $repo, $token, $api);
                $type = $this->PLATFORM_TO_TYPE[$platform] ?? 'generic';
                echo "  Platform: {$platform} -> type: {$type}\n";
            }

            $templateFile = $this->TYPE_TO_TEMPLATE[$type] ?? $this->TYPE_TO_TEMPLATE['generic'];
            $template = $this->parseTemplate("{$templatesDir}/{$templateFile}");

            $repoId = $this->getRepoNodeId($org, $repo, $token);
            if (empty($repoId)) {
                $this->log('ERROR', "  Could not resolve repo node ID for {$repo}");
                $failed++;
                continue;
            }

            $ok = $this->createProject($org, $repo, $ownerId, $repoId, $template, $token);
            if ($ok) {
                $created++;
            } else {
                $failed++;
            }

            echo "\n";
        }

        echo str_repeat('-', 50) . "\n";
        echo "Done: {$created} created, {$skipped} skipped, {$failed} failed\n";
        return $failed > 0 ? 1 : 0;
    }

    private function graphql(string $query, array $variables, string $token, string $platformName = 'gitea'): array
    {
        if ($platformName !== 'github') {
            return [];
        }
        $payload = json_encode(['query' => $query, 'variables' => $variables]);
        $ch = curl_init('https://api.github.com/graphql');
        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_POST           => true,
            CURLOPT_POSTFIELDS     => $payload,
            CURLOPT_HTTPHEADER     => [
                'Authorization: bearer ' . $token,
                'Content-Type: application/json',
                'User-Agent: moko-platform-CreateProject',
            ],
        ]);
        $body = (string) curl_exec($ch);
        $status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($status !== 200) {
            $this->log('ERROR', "GraphQL request failed (HTTP {$status}): {$body}");
            return [];
        }

        $data = json_decode($body, true) ?? [];
        if (!empty($data['errors'])) {
            foreach ($data['errors'] as $err) {
                $this->log('ERROR', "  GraphQL error: " . ($err['message'] ?? 'unknown'));
            }
        }

        return $data['data'] ?? [];
    }

    private function restGet(string $path, string $token, ?\MokoEnterprise\ApiClient $apiClient = null): array
    {
        if ($apiClient !== null) {
            try {
                return $apiClient->get("/{$path}");
            } catch (\Exception $e) {
                return [];
            }
        }
        return [];
    }

    private function detectRepoPlatform(string $org, string $repo, string $token, ?\MokoEnterprise\ApiClient $apiClient = null): string
    {
        foreach (['.github/.mokostandards', '.mokogitea/.mokostandards', '.mokostandards'] as $path) {
            $data = $this->restGet("repos/{$org}/{$repo}/contents/{$path}", $token, $apiClient);
            if (!empty($data['content'])) {
                $content = base64_decode($data['content']);
                if (preg_match('/^platform:\s*(.+)/m', $content, $m)) {
                    return trim($m[1], " \t\n\r\"'");
                }
            }
        }
        return '';
    }

    private function getRepoNodeId(string $org, string $repo, string $token): string
    {
        $data = $this->graphql(
            'query($owner: String!, $name: String!) { repository(owner: $owner, name: $name) { id } }',
            ['owner' => $org, 'name' => $repo],
            $token
        );
        return $data['repository']['id'] ?? '';
    }

    private function getOrgNodeId(string $org, string $token): string
    {
        $data = $this->graphql(
            'query($login: String!) { organization(login: $login) { id } }',
            ['login' => $org],
            $token
        );
        return $data['organization']['id'] ?? '';
    }

    /** @return array{bool, string} */
    private function repoHasProject(string $org, string $repo, string $token): array
    {
        $data = $this->graphql(
            'query($owner: String!, $name: String!) {
                repository(owner: $owner, name: $name) {
                    projectsV2(first: 1) { nodes { id title } totalCount }
                }
            }',
            ['owner' => $org, 'name' => $repo],
            $token
        );

        $count = $data['repository']['projectsV2']['totalCount'] ?? 0;
        $title = $data['repository']['projectsV2']['nodes'][0]['title'] ?? '';
        return [$count > 0, $title];
    }

    /** @return array{name: string, fields: array, views: array} */
    private function parseTemplate(string $filePath): array
    {
        if (!file_exists($filePath)) {
            return ['name' => 'Development Board', 'fields' => [], 'views' => []];
        }

        $content = file_get_contents($filePath);
        $result  = ['name' => 'Development Board', 'fields' => [], 'views' => []];

        if (preg_match('/name\s*=\s*"([^"]+)"/', $content, $m)) {
            $result['name'] = $m[1];
        }

        if (preg_match_all('/\{\s*name\s*=\s*"([^"]+)"\s*type\s*=\s*"([^"]+)"\s*description\s*=\s*"([^"]+)"(?:\s*options\s*=\s*\[([^\]]*)\])?\s*\}/s', $content, $matches, PREG_SET_ORDER)) {
            foreach ($matches as $match) {
                $field = [
                    'name'        => $match[1],
                    'type'        => $match[2],
                    'description' => $match[3],
                ];
                if (!empty($match[4])) {
                    $field['options'] = array_map(
                        fn($o) => trim($o, " \t\n\r\"'"),
                        explode(',', $match[4])
                    );
                    $field['options'] = array_filter($field['options']);
                }
                $result['fields'][] = $field;
            }
        }

        return $result;
    }

    private function createProject(
        string $org,
        string $repo,
        string $ownerId,
        string $repoId,
        array $template,
        string $token
    ): bool {
        $title = "{$repo} -- {$template['name']}";

        if ($this->dryRun) {
            echo "  (dry-run) would create project: {$title}\n";
            echo "  (dry-run) fields: " . count($template['fields']) . "\n";
            return true;
        }

        echo "  Creating project: {$title}\n";
        $data = $this->graphql(
            'mutation($ownerId: ID!, $title: String!) {
                createProjectV2(input: { ownerId: $ownerId, title: $title }) {
                    projectV2 { id number url }
                }
            }',
            ['ownerId' => $ownerId, 'title' => $title],
            $token
        );

        $projectId = $data['createProjectV2']['projectV2']['id'] ?? '';
        $projectUrl = $data['createProjectV2']['projectV2']['url'] ?? '';

        if (empty($projectId)) {
            $this->log('ERROR', "  Failed to create project for {$repo}");
            return false;
        }

        echo "  Project created: {$projectUrl}\n";

        $this->graphql(
            'mutation($projectId: ID!, $repositoryId: ID!) {
                linkProjectV2ToRepository(input: { projectId: $projectId, repositoryId: $repositoryId }) {
                    repository { id }
                }
            }',
            ['projectId' => $projectId, 'repositoryId' => $repoId],
            $token
        );
        echo "  Linked to {$org}/{$repo}\n";

        $fieldCount = 0;
        foreach ($template['fields'] as $field) {
            $fieldType = match ($field['type']) {
                'single_select' => 'SINGLE_SELECT',
                'text'          => 'TEXT',
                'number'        => 'NUMBER',
                'date'          => 'DATE',
                'iteration'     => 'ITERATION',
                default         => 'TEXT',
            };

            $vars = [
                'projectId' => $projectId,
                'name'      => $field['name'],
                'dataType'  => $fieldType,
            ];

            if ($fieldType === 'SINGLE_SELECT' && !empty($field['options'])) {
                $optionInputs = array_map(
                    fn($o) => ['name' => $o, 'description' => '', 'color' => 'GRAY'],
                    $field['options']
                );
                $vars['singleSelectOptions'] = $optionInputs;

                $this->graphql(
                    'mutation($projectId: ID!, $name: String!, $dataType: ProjectV2CustomFieldType!, $singleSelectOptions: [ProjectV2SingleSelectFieldOptionInput!]) {
                        createProjectV2Field(input: {
                            projectId: $projectId,
                            dataType: $dataType,
                            name: $name,
                            singleSelectOptions: $singleSelectOptions
                        }) {
                            projectV2Field { ... on ProjectV2SingleSelectField { id name } }
                        }
                    }',
                    $vars,
                    $token
                );
            } else {
                $this->graphql(
                    'mutation($projectId: ID!, $name: String!, $dataType: ProjectV2CustomFieldType!) {
                        createProjectV2Field(input: {
                            projectId: $projectId,
                            dataType: $dataType,
                            name: $name
                        }) {
                            projectV2Field { ... on ProjectV2Field { id name } }
                        }
                    }',
                    $vars,
                    $token
                );
            }

            $fieldCount++;
        }

        echo "  Created {$fieldCount} custom fields\n";

        $this->graphql(
            'mutation($projectId: ID!, $shortDescription: String!) {
                updateProjectV2(input: {
                    projectId: $projectId,
                    shortDescription: $shortDescription,
                    readme: "Managed by moko-platform. Run `php cli/create_project.php` to regenerate."
                }) {
                    projectV2 { id }
                }
            }',
            [
                'projectId'        => $projectId,
                'shortDescription' => "Standard project board for {$repo}. Auto-created by moko-platform.",
            ],
            $token
        );

        echo "  Project setup complete\n";
        return true;
    }
}

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